1 // Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
2 // This source code is licensed under both the GPLv2 (found in the
3 // COPYING file in the root directory) and Apache 2.0 License
4 // (found in the LICENSE.Apache file in the root directory).
5 //
6 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
7 // Use of this source code is governed by a BSD-style license that can be
8 // found in the LICENSE file. See the AUTHORS file for names of contributors.
9
10 #ifndef ROCKSDB_LITE
11
12 #include "rocksdb/c.h"
13
14 #include <stdlib.h>
15 #include "port/port.h"
16 #include "rocksdb/cache.h"
17 #include "rocksdb/compaction_filter.h"
18 #include "rocksdb/comparator.h"
19 #include "rocksdb/convenience.h"
20 #include "rocksdb/db.h"
21 #include "rocksdb/env.h"
22 #include "rocksdb/filter_policy.h"
23 #include "rocksdb/iterator.h"
24 #include "rocksdb/memtablerep.h"
25 #include "rocksdb/merge_operator.h"
26 #include "rocksdb/options.h"
27 #include "rocksdb/rate_limiter.h"
28 #include "rocksdb/slice_transform.h"
29 #include "rocksdb/statistics.h"
30 #include "rocksdb/status.h"
31 #include "rocksdb/table.h"
32 #include "rocksdb/universal_compaction.h"
33 #include "rocksdb/utilities/backupable_db.h"
34 #include "rocksdb/utilities/checkpoint.h"
35 #include "rocksdb/utilities/db_ttl.h"
36 #include "rocksdb/utilities/memory_util.h"
37 #include "rocksdb/utilities/optimistic_transaction_db.h"
38 #include "rocksdb/utilities/transaction.h"
39 #include "rocksdb/utilities/transaction_db.h"
40 #include "rocksdb/utilities/write_batch_with_index.h"
41 #include "rocksdb/write_batch.h"
42 #include "rocksdb/perf_context.h"
43 #include "utilities/merge_operators.h"
44
45 #include <vector>
46 #include <unordered_set>
47 #include <map>
48
49 using ROCKSDB_NAMESPACE::BackupableDBOptions;
50 using ROCKSDB_NAMESPACE::BackupEngine;
51 using ROCKSDB_NAMESPACE::BackupID;
52 using ROCKSDB_NAMESPACE::BackupInfo;
53 using ROCKSDB_NAMESPACE::BatchResult;
54 using ROCKSDB_NAMESPACE::BlockBasedTableOptions;
55 using ROCKSDB_NAMESPACE::BottommostLevelCompaction;
56 using ROCKSDB_NAMESPACE::BytewiseComparator;
57 using ROCKSDB_NAMESPACE::Cache;
58 using ROCKSDB_NAMESPACE::Checkpoint;
59 using ROCKSDB_NAMESPACE::ColumnFamilyDescriptor;
60 using ROCKSDB_NAMESPACE::ColumnFamilyHandle;
61 using ROCKSDB_NAMESPACE::ColumnFamilyOptions;
62 using ROCKSDB_NAMESPACE::CompactionFilter;
63 using ROCKSDB_NAMESPACE::CompactionFilterContext;
64 using ROCKSDB_NAMESPACE::CompactionFilterFactory;
65 using ROCKSDB_NAMESPACE::CompactionOptionsFIFO;
66 using ROCKSDB_NAMESPACE::CompactRangeOptions;
67 using ROCKSDB_NAMESPACE::Comparator;
68 using ROCKSDB_NAMESPACE::CompressionType;
69 using ROCKSDB_NAMESPACE::CuckooTableOptions;
70 using ROCKSDB_NAMESPACE::DB;
71 using ROCKSDB_NAMESPACE::DBOptions;
72 using ROCKSDB_NAMESPACE::DbPath;
73 using ROCKSDB_NAMESPACE::Env;
74 using ROCKSDB_NAMESPACE::EnvOptions;
75 using ROCKSDB_NAMESPACE::FileLock;
76 using ROCKSDB_NAMESPACE::FilterPolicy;
77 using ROCKSDB_NAMESPACE::FlushOptions;
78 using ROCKSDB_NAMESPACE::InfoLogLevel;
79 using ROCKSDB_NAMESPACE::IngestExternalFileOptions;
80 using ROCKSDB_NAMESPACE::Iterator;
81 using ROCKSDB_NAMESPACE::LiveFileMetaData;
82 using ROCKSDB_NAMESPACE::Logger;
83 using ROCKSDB_NAMESPACE::MemoryUtil;
84 using ROCKSDB_NAMESPACE::MergeOperator;
85 using ROCKSDB_NAMESPACE::MergeOperators;
86 using ROCKSDB_NAMESPACE::NewBloomFilterPolicy;
87 using ROCKSDB_NAMESPACE::NewGenericRateLimiter;
88 using ROCKSDB_NAMESPACE::NewLRUCache;
89 using ROCKSDB_NAMESPACE::OptimisticTransactionDB;
90 using ROCKSDB_NAMESPACE::OptimisticTransactionOptions;
91 using ROCKSDB_NAMESPACE::Options;
92 using ROCKSDB_NAMESPACE::PerfContext;
93 using ROCKSDB_NAMESPACE::PerfLevel;
94 using ROCKSDB_NAMESPACE::PinnableSlice;
95 using ROCKSDB_NAMESPACE::RandomAccessFile;
96 using ROCKSDB_NAMESPACE::Range;
97 using ROCKSDB_NAMESPACE::RateLimiter;
98 using ROCKSDB_NAMESPACE::ReadOptions;
99 using ROCKSDB_NAMESPACE::RestoreOptions;
100 using ROCKSDB_NAMESPACE::SequentialFile;
101 using ROCKSDB_NAMESPACE::Slice;
102 using ROCKSDB_NAMESPACE::SliceParts;
103 using ROCKSDB_NAMESPACE::SliceTransform;
104 using ROCKSDB_NAMESPACE::Snapshot;
105 using ROCKSDB_NAMESPACE::SstFileWriter;
106 using ROCKSDB_NAMESPACE::Status;
107 using ROCKSDB_NAMESPACE::Transaction;
108 using ROCKSDB_NAMESPACE::TransactionDB;
109 using ROCKSDB_NAMESPACE::TransactionDBOptions;
110 using ROCKSDB_NAMESPACE::TransactionLogIterator;
111 using ROCKSDB_NAMESPACE::TransactionOptions;
112 using ROCKSDB_NAMESPACE::WALRecoveryMode;
113 using ROCKSDB_NAMESPACE::WritableFile;
114 using ROCKSDB_NAMESPACE::WriteBatch;
115 using ROCKSDB_NAMESPACE::WriteBatchWithIndex;
116 using ROCKSDB_NAMESPACE::WriteOptions;
117
118 using std::shared_ptr;
119 using std::vector;
120 using std::unordered_set;
121 using std::map;
122
123 extern "C" {
124
125 struct rocksdb_t { DB* rep; };
126 struct rocksdb_backup_engine_t { BackupEngine* rep; };
127 struct rocksdb_backup_engine_info_t { std::vector<BackupInfo> rep; };
128 struct rocksdb_restore_options_t { RestoreOptions rep; };
129 struct rocksdb_iterator_t { Iterator* rep; };
130 struct rocksdb_writebatch_t { WriteBatch rep; };
131 struct rocksdb_writebatch_wi_t { WriteBatchWithIndex* rep; };
132 struct rocksdb_snapshot_t { const Snapshot* rep; };
133 struct rocksdb_flushoptions_t { FlushOptions rep; };
134 struct rocksdb_fifo_compaction_options_t { CompactionOptionsFIFO rep; };
135 struct rocksdb_readoptions_t {
136 ReadOptions rep;
137 // stack variables to set pointers to in ReadOptions
138 Slice upper_bound;
139 Slice lower_bound;
140 };
141 struct rocksdb_writeoptions_t { WriteOptions rep; };
142 struct rocksdb_options_t { Options rep; };
143 struct rocksdb_compactoptions_t {
144 CompactRangeOptions rep;
145 };
146 struct rocksdb_block_based_table_options_t { BlockBasedTableOptions rep; };
147 struct rocksdb_cuckoo_table_options_t { CuckooTableOptions rep; };
148 struct rocksdb_seqfile_t { SequentialFile* rep; };
149 struct rocksdb_randomfile_t { RandomAccessFile* rep; };
150 struct rocksdb_writablefile_t { WritableFile* rep; };
151 struct rocksdb_wal_iterator_t { TransactionLogIterator* rep; };
152 struct rocksdb_wal_readoptions_t { TransactionLogIterator::ReadOptions rep; };
153 struct rocksdb_filelock_t { FileLock* rep; };
154 struct rocksdb_logger_t {
155 std::shared_ptr<Logger> rep;
156 };
157 struct rocksdb_cache_t {
158 std::shared_ptr<Cache> rep;
159 };
160 struct rocksdb_livefiles_t { std::vector<LiveFileMetaData> rep; };
161 struct rocksdb_column_family_handle_t { ColumnFamilyHandle* rep; };
162 struct rocksdb_envoptions_t { EnvOptions rep; };
163 struct rocksdb_ingestexternalfileoptions_t { IngestExternalFileOptions rep; };
164 struct rocksdb_sstfilewriter_t { SstFileWriter* rep; };
165 struct rocksdb_ratelimiter_t {
166 std::shared_ptr<RateLimiter> rep;
167 };
168 struct rocksdb_perfcontext_t { PerfContext* rep; };
169 struct rocksdb_pinnableslice_t {
170 PinnableSlice rep;
171 };
172 struct rocksdb_transactiondb_options_t {
173 TransactionDBOptions rep;
174 };
175 struct rocksdb_transactiondb_t {
176 TransactionDB* rep;
177 };
178 struct rocksdb_transaction_options_t {
179 TransactionOptions rep;
180 };
181 struct rocksdb_transaction_t {
182 Transaction* rep;
183 };
184 struct rocksdb_checkpoint_t {
185 Checkpoint* rep;
186 };
187 struct rocksdb_optimistictransactiondb_t {
188 OptimisticTransactionDB* rep;
189 };
190 struct rocksdb_optimistictransaction_options_t {
191 OptimisticTransactionOptions rep;
192 };
193
194 struct rocksdb_compactionfiltercontext_t {
195 CompactionFilter::Context rep;
196 };
197
198 struct rocksdb_compactionfilter_t : public CompactionFilter {
199 void* state_;
200 void (*destructor_)(void*);
201 unsigned char (*filter_)(
202 void*,
203 int level,
204 const char* key, size_t key_length,
205 const char* existing_value, size_t value_length,
206 char** new_value, size_t *new_value_length,
207 unsigned char* value_changed);
208 const char* (*name_)(void*);
209 unsigned char ignore_snapshots_;
210
~rocksdb_compactionfilter_trocksdb_compactionfilter_t211 ~rocksdb_compactionfilter_t() override { (*destructor_)(state_); }
212
Filterrocksdb_compactionfilter_t213 bool Filter(int level, const Slice& key, const Slice& existing_value,
214 std::string* new_value, bool* value_changed) const override {
215 char* c_new_value = nullptr;
216 size_t new_value_length = 0;
217 unsigned char c_value_changed = 0;
218 unsigned char result = (*filter_)(
219 state_,
220 level,
221 key.data(), key.size(),
222 existing_value.data(), existing_value.size(),
223 &c_new_value, &new_value_length, &c_value_changed);
224 if (c_value_changed) {
225 new_value->assign(c_new_value, new_value_length);
226 *value_changed = true;
227 }
228 return result;
229 }
230
Namerocksdb_compactionfilter_t231 const char* Name() const override { return (*name_)(state_); }
232
IgnoreSnapshotsrocksdb_compactionfilter_t233 bool IgnoreSnapshots() const override { return ignore_snapshots_; }
234 };
235
236 struct rocksdb_compactionfilterfactory_t : public CompactionFilterFactory {
237 void* state_;
238 void (*destructor_)(void*);
239 rocksdb_compactionfilter_t* (*create_compaction_filter_)(
240 void*, rocksdb_compactionfiltercontext_t* context);
241 const char* (*name_)(void*);
242
~rocksdb_compactionfilterfactory_trocksdb_compactionfilterfactory_t243 ~rocksdb_compactionfilterfactory_t() override { (*destructor_)(state_); }
244
CreateCompactionFilterrocksdb_compactionfilterfactory_t245 std::unique_ptr<CompactionFilter> CreateCompactionFilter(
246 const CompactionFilter::Context& context) override {
247 rocksdb_compactionfiltercontext_t ccontext;
248 ccontext.rep = context;
249 CompactionFilter* cf = (*create_compaction_filter_)(state_, &ccontext);
250 return std::unique_ptr<CompactionFilter>(cf);
251 }
252
Namerocksdb_compactionfilterfactory_t253 const char* Name() const override { return (*name_)(state_); }
254 };
255
256 struct rocksdb_comparator_t : public Comparator {
257 void* state_;
258 void (*destructor_)(void*);
259 int (*compare_)(
260 void*,
261 const char* a, size_t alen,
262 const char* b, size_t blen);
263 const char* (*name_)(void*);
264
~rocksdb_comparator_trocksdb_comparator_t265 ~rocksdb_comparator_t() override { (*destructor_)(state_); }
266
Comparerocksdb_comparator_t267 int Compare(const Slice& a, const Slice& b) const override {
268 return (*compare_)(state_, a.data(), a.size(), b.data(), b.size());
269 }
270
Namerocksdb_comparator_t271 const char* Name() const override { return (*name_)(state_); }
272
273 // No-ops since the C binding does not support key shortening methods.
FindShortestSeparatorrocksdb_comparator_t274 void FindShortestSeparator(std::string*, const Slice&) const override {}
FindShortSuccessorrocksdb_comparator_t275 void FindShortSuccessor(std::string* /*key*/) const override {}
276 };
277
278 struct rocksdb_filterpolicy_t : public FilterPolicy {
279 void* state_;
280 void (*destructor_)(void*);
281 const char* (*name_)(void*);
282 char* (*create_)(
283 void*,
284 const char* const* key_array, const size_t* key_length_array,
285 int num_keys,
286 size_t* filter_length);
287 unsigned char (*key_match_)(
288 void*,
289 const char* key, size_t length,
290 const char* filter, size_t filter_length);
291 void (*delete_filter_)(
292 void*,
293 const char* filter, size_t filter_length);
294
~rocksdb_filterpolicy_trocksdb_filterpolicy_t295 ~rocksdb_filterpolicy_t() override { (*destructor_)(state_); }
296
Namerocksdb_filterpolicy_t297 const char* Name() const override { return (*name_)(state_); }
298
CreateFilterrocksdb_filterpolicy_t299 void CreateFilter(const Slice* keys, int n, std::string* dst) const override {
300 std::vector<const char*> key_pointers(n);
301 std::vector<size_t> key_sizes(n);
302 for (int i = 0; i < n; i++) {
303 key_pointers[i] = keys[i].data();
304 key_sizes[i] = keys[i].size();
305 }
306 size_t len;
307 char* filter = (*create_)(state_, &key_pointers[0], &key_sizes[0], n, &len);
308 dst->append(filter, len);
309
310 if (delete_filter_ != nullptr) {
311 (*delete_filter_)(state_, filter, len);
312 } else {
313 free(filter);
314 }
315 }
316
KeyMayMatchrocksdb_filterpolicy_t317 bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
318 return (*key_match_)(state_, key.data(), key.size(),
319 filter.data(), filter.size());
320 }
321 };
322
323 struct rocksdb_mergeoperator_t : public MergeOperator {
324 void* state_;
325 void (*destructor_)(void*);
326 const char* (*name_)(void*);
327 char* (*full_merge_)(
328 void*,
329 const char* key, size_t key_length,
330 const char* existing_value, size_t existing_value_length,
331 const char* const* operands_list, const size_t* operands_list_length,
332 int num_operands,
333 unsigned char* success, size_t* new_value_length);
334 char* (*partial_merge_)(void*, const char* key, size_t key_length,
335 const char* const* operands_list,
336 const size_t* operands_list_length, int num_operands,
337 unsigned char* success, size_t* new_value_length);
338 void (*delete_value_)(
339 void*,
340 const char* value, size_t value_length);
341
~rocksdb_mergeoperator_trocksdb_mergeoperator_t342 ~rocksdb_mergeoperator_t() override { (*destructor_)(state_); }
343
Namerocksdb_mergeoperator_t344 const char* Name() const override { return (*name_)(state_); }
345
FullMergeV2rocksdb_mergeoperator_t346 bool FullMergeV2(const MergeOperationInput& merge_in,
347 MergeOperationOutput* merge_out) const override {
348 size_t n = merge_in.operand_list.size();
349 std::vector<const char*> operand_pointers(n);
350 std::vector<size_t> operand_sizes(n);
351 for (size_t i = 0; i < n; i++) {
352 Slice operand(merge_in.operand_list[i]);
353 operand_pointers[i] = operand.data();
354 operand_sizes[i] = operand.size();
355 }
356
357 const char* existing_value_data = nullptr;
358 size_t existing_value_len = 0;
359 if (merge_in.existing_value != nullptr) {
360 existing_value_data = merge_in.existing_value->data();
361 existing_value_len = merge_in.existing_value->size();
362 }
363
364 unsigned char success;
365 size_t new_value_len;
366 char* tmp_new_value = (*full_merge_)(
367 state_, merge_in.key.data(), merge_in.key.size(), existing_value_data,
368 existing_value_len, &operand_pointers[0], &operand_sizes[0],
369 static_cast<int>(n), &success, &new_value_len);
370 merge_out->new_value.assign(tmp_new_value, new_value_len);
371
372 if (delete_value_ != nullptr) {
373 (*delete_value_)(state_, tmp_new_value, new_value_len);
374 } else {
375 free(tmp_new_value);
376 }
377
378 return success;
379 }
380
PartialMergeMultirocksdb_mergeoperator_t381 bool PartialMergeMulti(const Slice& key,
382 const std::deque<Slice>& operand_list,
383 std::string* new_value,
384 Logger* /*logger*/) const override {
385 size_t operand_count = operand_list.size();
386 std::vector<const char*> operand_pointers(operand_count);
387 std::vector<size_t> operand_sizes(operand_count);
388 for (size_t i = 0; i < operand_count; ++i) {
389 Slice operand(operand_list[i]);
390 operand_pointers[i] = operand.data();
391 operand_sizes[i] = operand.size();
392 }
393
394 unsigned char success;
395 size_t new_value_len;
396 char* tmp_new_value = (*partial_merge_)(
397 state_, key.data(), key.size(), &operand_pointers[0], &operand_sizes[0],
398 static_cast<int>(operand_count), &success, &new_value_len);
399 new_value->assign(tmp_new_value, new_value_len);
400
401 if (delete_value_ != nullptr) {
402 (*delete_value_)(state_, tmp_new_value, new_value_len);
403 } else {
404 free(tmp_new_value);
405 }
406
407 return success;
408 }
409 };
410
411 struct rocksdb_dbpath_t {
412 DbPath rep;
413 };
414
415 struct rocksdb_env_t {
416 Env* rep;
417 bool is_default;
418 };
419
420 struct rocksdb_slicetransform_t : public SliceTransform {
421 void* state_;
422 void (*destructor_)(void*);
423 const char* (*name_)(void*);
424 char* (*transform_)(
425 void*,
426 const char* key, size_t length,
427 size_t* dst_length);
428 unsigned char (*in_domain_)(
429 void*,
430 const char* key, size_t length);
431 unsigned char (*in_range_)(
432 void*,
433 const char* key, size_t length);
434
~rocksdb_slicetransform_trocksdb_slicetransform_t435 ~rocksdb_slicetransform_t() override { (*destructor_)(state_); }
436
Namerocksdb_slicetransform_t437 const char* Name() const override { return (*name_)(state_); }
438
Transformrocksdb_slicetransform_t439 Slice Transform(const Slice& src) const override {
440 size_t len;
441 char* dst = (*transform_)(state_, src.data(), src.size(), &len);
442 return Slice(dst, len);
443 }
444
InDomainrocksdb_slicetransform_t445 bool InDomain(const Slice& src) const override {
446 return (*in_domain_)(state_, src.data(), src.size());
447 }
448
InRangerocksdb_slicetransform_t449 bool InRange(const Slice& src) const override {
450 return (*in_range_)(state_, src.data(), src.size());
451 }
452 };
453
454 struct rocksdb_universal_compaction_options_t {
455 ROCKSDB_NAMESPACE::CompactionOptionsUniversal* rep;
456 };
457
SaveError(char ** errptr,const Status & s)458 static bool SaveError(char** errptr, const Status& s) {
459 assert(errptr != nullptr);
460 if (s.ok()) {
461 return false;
462 } else if (*errptr == nullptr) {
463 *errptr = strdup(s.ToString().c_str());
464 } else {
465 // TODO(sanjay): Merge with existing error?
466 // This is a bug if *errptr is not created by malloc()
467 free(*errptr);
468 *errptr = strdup(s.ToString().c_str());
469 }
470 return true;
471 }
472
CopyString(const std::string & str)473 static char* CopyString(const std::string& str) {
474 char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size()));
475 memcpy(result, str.data(), sizeof(char) * str.size());
476 return result;
477 }
478
rocksdb_open(const rocksdb_options_t * options,const char * name,char ** errptr)479 rocksdb_t* rocksdb_open(
480 const rocksdb_options_t* options,
481 const char* name,
482 char** errptr) {
483 DB* db;
484 if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) {
485 return nullptr;
486 }
487 rocksdb_t* result = new rocksdb_t;
488 result->rep = db;
489 return result;
490 }
491
rocksdb_open_with_ttl(const rocksdb_options_t * options,const char * name,int ttl,char ** errptr)492 rocksdb_t* rocksdb_open_with_ttl(
493 const rocksdb_options_t* options,
494 const char* name,
495 int ttl,
496 char** errptr) {
497 ROCKSDB_NAMESPACE::DBWithTTL* db;
498 if (SaveError(errptr, ROCKSDB_NAMESPACE::DBWithTTL::Open(
499 options->rep, std::string(name), &db, ttl))) {
500 return nullptr;
501 }
502 rocksdb_t* result = new rocksdb_t;
503 result->rep = db;
504 return result;
505 }
506
rocksdb_open_for_read_only(const rocksdb_options_t * options,const char * name,unsigned char error_if_log_file_exist,char ** errptr)507 rocksdb_t* rocksdb_open_for_read_only(
508 const rocksdb_options_t* options,
509 const char* name,
510 unsigned char error_if_log_file_exist,
511 char** errptr) {
512 DB* db;
513 if (SaveError(errptr, DB::OpenForReadOnly(options->rep, std::string(name), &db, error_if_log_file_exist))) {
514 return nullptr;
515 }
516 rocksdb_t* result = new rocksdb_t;
517 result->rep = db;
518 return result;
519 }
520
rocksdb_open_as_secondary(const rocksdb_options_t * options,const char * name,const char * secondary_path,char ** errptr)521 rocksdb_t* rocksdb_open_as_secondary(const rocksdb_options_t* options,
522 const char* name,
523 const char* secondary_path,
524 char** errptr) {
525 DB* db;
526 if (SaveError(errptr,
527 DB::OpenAsSecondary(options->rep, std::string(name),
528 std::string(secondary_path), &db))) {
529 return nullptr;
530 }
531 rocksdb_t* result = new rocksdb_t;
532 result->rep = db;
533 return result;
534 }
535
rocksdb_backup_engine_open(const rocksdb_options_t * options,const char * path,char ** errptr)536 rocksdb_backup_engine_t* rocksdb_backup_engine_open(
537 const rocksdb_options_t* options, const char* path, char** errptr) {
538 BackupEngine* be;
539 if (SaveError(errptr, BackupEngine::Open(options->rep.env,
540 BackupableDBOptions(path,
541 nullptr,
542 true,
543 options->rep.info_log.get()),
544 &be))) {
545 return nullptr;
546 }
547 rocksdb_backup_engine_t* result = new rocksdb_backup_engine_t;
548 result->rep = be;
549 return result;
550 }
551
rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t * be,rocksdb_t * db,char ** errptr)552 void rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t* be,
553 rocksdb_t* db,
554 char** errptr) {
555 SaveError(errptr, be->rep->CreateNewBackup(db->rep));
556 }
557
rocksdb_backup_engine_create_new_backup_flush(rocksdb_backup_engine_t * be,rocksdb_t * db,unsigned char flush_before_backup,char ** errptr)558 void rocksdb_backup_engine_create_new_backup_flush(rocksdb_backup_engine_t* be,
559 rocksdb_t* db,
560 unsigned char flush_before_backup,
561 char** errptr) {
562 SaveError(errptr, be->rep->CreateNewBackup(db->rep, flush_before_backup));
563 }
564
rocksdb_backup_engine_purge_old_backups(rocksdb_backup_engine_t * be,uint32_t num_backups_to_keep,char ** errptr)565 void rocksdb_backup_engine_purge_old_backups(rocksdb_backup_engine_t* be,
566 uint32_t num_backups_to_keep,
567 char** errptr) {
568 SaveError(errptr, be->rep->PurgeOldBackups(num_backups_to_keep));
569 }
570
rocksdb_restore_options_create()571 rocksdb_restore_options_t* rocksdb_restore_options_create() {
572 return new rocksdb_restore_options_t;
573 }
574
rocksdb_restore_options_destroy(rocksdb_restore_options_t * opt)575 void rocksdb_restore_options_destroy(rocksdb_restore_options_t* opt) {
576 delete opt;
577 }
578
rocksdb_restore_options_set_keep_log_files(rocksdb_restore_options_t * opt,int v)579 void rocksdb_restore_options_set_keep_log_files(rocksdb_restore_options_t* opt,
580 int v) {
581 opt->rep.keep_log_files = v;
582 }
583
584
rocksdb_backup_engine_verify_backup(rocksdb_backup_engine_t * be,uint32_t backup_id,char ** errptr)585 void rocksdb_backup_engine_verify_backup(rocksdb_backup_engine_t* be,
586 uint32_t backup_id, char** errptr) {
587 SaveError(errptr, be->rep->VerifyBackup(static_cast<BackupID>(backup_id)));
588 }
589
rocksdb_backup_engine_restore_db_from_latest_backup(rocksdb_backup_engine_t * be,const char * db_dir,const char * wal_dir,const rocksdb_restore_options_t * restore_options,char ** errptr)590 void rocksdb_backup_engine_restore_db_from_latest_backup(
591 rocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir,
592 const rocksdb_restore_options_t* restore_options, char** errptr) {
593 SaveError(errptr, be->rep->RestoreDBFromLatestBackup(std::string(db_dir),
594 std::string(wal_dir),
595 restore_options->rep));
596 }
597
rocksdb_backup_engine_get_backup_info(rocksdb_backup_engine_t * be)598 const rocksdb_backup_engine_info_t* rocksdb_backup_engine_get_backup_info(
599 rocksdb_backup_engine_t* be) {
600 rocksdb_backup_engine_info_t* result = new rocksdb_backup_engine_info_t;
601 be->rep->GetBackupInfo(&result->rep);
602 return result;
603 }
604
rocksdb_backup_engine_info_count(const rocksdb_backup_engine_info_t * info)605 int rocksdb_backup_engine_info_count(const rocksdb_backup_engine_info_t* info) {
606 return static_cast<int>(info->rep.size());
607 }
608
rocksdb_backup_engine_info_timestamp(const rocksdb_backup_engine_info_t * info,int index)609 int64_t rocksdb_backup_engine_info_timestamp(
610 const rocksdb_backup_engine_info_t* info, int index) {
611 return info->rep[index].timestamp;
612 }
613
rocksdb_backup_engine_info_backup_id(const rocksdb_backup_engine_info_t * info,int index)614 uint32_t rocksdb_backup_engine_info_backup_id(
615 const rocksdb_backup_engine_info_t* info, int index) {
616 return info->rep[index].backup_id;
617 }
618
rocksdb_backup_engine_info_size(const rocksdb_backup_engine_info_t * info,int index)619 uint64_t rocksdb_backup_engine_info_size(
620 const rocksdb_backup_engine_info_t* info, int index) {
621 return info->rep[index].size;
622 }
623
rocksdb_backup_engine_info_number_files(const rocksdb_backup_engine_info_t * info,int index)624 uint32_t rocksdb_backup_engine_info_number_files(
625 const rocksdb_backup_engine_info_t* info, int index) {
626 return info->rep[index].number_files;
627 }
628
rocksdb_backup_engine_info_destroy(const rocksdb_backup_engine_info_t * info)629 void rocksdb_backup_engine_info_destroy(
630 const rocksdb_backup_engine_info_t* info) {
631 delete info;
632 }
633
rocksdb_backup_engine_close(rocksdb_backup_engine_t * be)634 void rocksdb_backup_engine_close(rocksdb_backup_engine_t* be) {
635 delete be->rep;
636 delete be;
637 }
638
rocksdb_checkpoint_object_create(rocksdb_t * db,char ** errptr)639 rocksdb_checkpoint_t* rocksdb_checkpoint_object_create(rocksdb_t* db,
640 char** errptr) {
641 Checkpoint* checkpoint;
642 if (SaveError(errptr, Checkpoint::Create(db->rep, &checkpoint))) {
643 return nullptr;
644 }
645 rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t;
646 result->rep = checkpoint;
647 return result;
648 }
649
rocksdb_checkpoint_create(rocksdb_checkpoint_t * checkpoint,const char * checkpoint_dir,uint64_t log_size_for_flush,char ** errptr)650 void rocksdb_checkpoint_create(rocksdb_checkpoint_t* checkpoint,
651 const char* checkpoint_dir,
652 uint64_t log_size_for_flush, char** errptr) {
653 SaveError(errptr, checkpoint->rep->CreateCheckpoint(
654 std::string(checkpoint_dir), log_size_for_flush));
655 }
656
rocksdb_checkpoint_object_destroy(rocksdb_checkpoint_t * checkpoint)657 void rocksdb_checkpoint_object_destroy(rocksdb_checkpoint_t* checkpoint) {
658 delete checkpoint->rep;
659 delete checkpoint;
660 }
661
rocksdb_close(rocksdb_t * db)662 void rocksdb_close(rocksdb_t* db) {
663 delete db->rep;
664 delete db;
665 }
666
rocksdb_options_set_uint64add_merge_operator(rocksdb_options_t * opt)667 void rocksdb_options_set_uint64add_merge_operator(rocksdb_options_t* opt) {
668 opt->rep.merge_operator =
669 ROCKSDB_NAMESPACE::MergeOperators::CreateUInt64AddOperator();
670 }
671
rocksdb_open_column_families(const rocksdb_options_t * db_options,const char * name,int num_column_families,const char * const * column_family_names,const rocksdb_options_t * const * column_family_options,rocksdb_column_family_handle_t ** column_family_handles,char ** errptr)672 rocksdb_t* rocksdb_open_column_families(
673 const rocksdb_options_t* db_options, const char* name,
674 int num_column_families, const char* const* column_family_names,
675 const rocksdb_options_t* const* column_family_options,
676 rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
677 std::vector<ColumnFamilyDescriptor> column_families;
678 for (int i = 0; i < num_column_families; i++) {
679 column_families.push_back(ColumnFamilyDescriptor(
680 std::string(column_family_names[i]),
681 ColumnFamilyOptions(column_family_options[i]->rep)));
682 }
683
684 DB* db;
685 std::vector<ColumnFamilyHandle*> handles;
686 if (SaveError(errptr, DB::Open(DBOptions(db_options->rep),
687 std::string(name), column_families, &handles, &db))) {
688 return nullptr;
689 }
690
691 for (size_t i = 0; i < handles.size(); i++) {
692 rocksdb_column_family_handle_t* c_handle = new rocksdb_column_family_handle_t;
693 c_handle->rep = handles[i];
694 column_family_handles[i] = c_handle;
695 }
696 rocksdb_t* result = new rocksdb_t;
697 result->rep = db;
698 return result;
699 }
700
rocksdb_open_for_read_only_column_families(const rocksdb_options_t * db_options,const char * name,int num_column_families,const char * const * column_family_names,const rocksdb_options_t * const * column_family_options,rocksdb_column_family_handle_t ** column_family_handles,unsigned char error_if_log_file_exist,char ** errptr)701 rocksdb_t* rocksdb_open_for_read_only_column_families(
702 const rocksdb_options_t* db_options, const char* name,
703 int num_column_families, const char* const* column_family_names,
704 const rocksdb_options_t* const* column_family_options,
705 rocksdb_column_family_handle_t** column_family_handles,
706 unsigned char error_if_log_file_exist, char** errptr) {
707 std::vector<ColumnFamilyDescriptor> column_families;
708 for (int i = 0; i < num_column_families; i++) {
709 column_families.push_back(ColumnFamilyDescriptor(
710 std::string(column_family_names[i]),
711 ColumnFamilyOptions(column_family_options[i]->rep)));
712 }
713
714 DB* db;
715 std::vector<ColumnFamilyHandle*> handles;
716 if (SaveError(errptr, DB::OpenForReadOnly(DBOptions(db_options->rep),
717 std::string(name), column_families, &handles, &db, error_if_log_file_exist))) {
718 return nullptr;
719 }
720
721 for (size_t i = 0; i < handles.size(); i++) {
722 rocksdb_column_family_handle_t* c_handle = new rocksdb_column_family_handle_t;
723 c_handle->rep = handles[i];
724 column_family_handles[i] = c_handle;
725 }
726 rocksdb_t* result = new rocksdb_t;
727 result->rep = db;
728 return result;
729 }
730
rocksdb_open_as_secondary_column_families(const rocksdb_options_t * db_options,const char * name,const char * secondary_path,int num_column_families,const char * const * column_family_names,const rocksdb_options_t * const * column_family_options,rocksdb_column_family_handle_t ** column_family_handles,char ** errptr)731 rocksdb_t* rocksdb_open_as_secondary_column_families(
732 const rocksdb_options_t* db_options, const char* name,
733 const char* secondary_path, int num_column_families,
734 const char* const* column_family_names,
735 const rocksdb_options_t* const* column_family_options,
736 rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
737 std::vector<ColumnFamilyDescriptor> column_families;
738 for (int i = 0; i != num_column_families; ++i) {
739 column_families.emplace_back(
740 std::string(column_family_names[i]),
741 ColumnFamilyOptions(column_family_options[i]->rep));
742 }
743 DB* db;
744 std::vector<ColumnFamilyHandle*> handles;
745 if (SaveError(errptr, DB::OpenAsSecondary(DBOptions(db_options->rep),
746 std::string(name),
747 std::string(secondary_path),
748 column_families, &handles, &db))) {
749 return nullptr;
750 }
751 for (size_t i = 0; i != handles.size(); ++i) {
752 rocksdb_column_family_handle_t* c_handle =
753 new rocksdb_column_family_handle_t;
754 c_handle->rep = handles[i];
755 column_family_handles[i] = c_handle;
756 }
757 rocksdb_t* result = new rocksdb_t;
758 result->rep = db;
759 return result;
760 }
761
rocksdb_list_column_families(const rocksdb_options_t * options,const char * name,size_t * lencfs,char ** errptr)762 char** rocksdb_list_column_families(
763 const rocksdb_options_t* options,
764 const char* name,
765 size_t* lencfs,
766 char** errptr) {
767 std::vector<std::string> fams;
768 SaveError(errptr,
769 DB::ListColumnFamilies(DBOptions(options->rep),
770 std::string(name), &fams));
771
772 *lencfs = fams.size();
773 char** column_families = static_cast<char**>(malloc(sizeof(char*) * fams.size()));
774 for (size_t i = 0; i < fams.size(); i++) {
775 column_families[i] = strdup(fams[i].c_str());
776 }
777 return column_families;
778 }
779
rocksdb_list_column_families_destroy(char ** list,size_t len)780 void rocksdb_list_column_families_destroy(char** list, size_t len) {
781 for (size_t i = 0; i < len; ++i) {
782 free(list[i]);
783 }
784 free(list);
785 }
786
rocksdb_create_column_family(rocksdb_t * db,const rocksdb_options_t * column_family_options,const char * column_family_name,char ** errptr)787 rocksdb_column_family_handle_t* rocksdb_create_column_family(
788 rocksdb_t* db,
789 const rocksdb_options_t* column_family_options,
790 const char* column_family_name,
791 char** errptr) {
792 rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t;
793 SaveError(errptr,
794 db->rep->CreateColumnFamily(ColumnFamilyOptions(column_family_options->rep),
795 std::string(column_family_name), &(handle->rep)));
796 return handle;
797 }
798
rocksdb_drop_column_family(rocksdb_t * db,rocksdb_column_family_handle_t * handle,char ** errptr)799 void rocksdb_drop_column_family(
800 rocksdb_t* db,
801 rocksdb_column_family_handle_t* handle,
802 char** errptr) {
803 SaveError(errptr, db->rep->DropColumnFamily(handle->rep));
804 }
805
rocksdb_column_family_handle_destroy(rocksdb_column_family_handle_t * handle)806 void rocksdb_column_family_handle_destroy(rocksdb_column_family_handle_t* handle) {
807 delete handle->rep;
808 delete handle;
809 }
810
rocksdb_put(rocksdb_t * db,const rocksdb_writeoptions_t * options,const char * key,size_t keylen,const char * val,size_t vallen,char ** errptr)811 void rocksdb_put(
812 rocksdb_t* db,
813 const rocksdb_writeoptions_t* options,
814 const char* key, size_t keylen,
815 const char* val, size_t vallen,
816 char** errptr) {
817 SaveError(errptr,
818 db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
819 }
820
rocksdb_put_cf(rocksdb_t * db,const rocksdb_writeoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,const char * val,size_t vallen,char ** errptr)821 void rocksdb_put_cf(
822 rocksdb_t* db,
823 const rocksdb_writeoptions_t* options,
824 rocksdb_column_family_handle_t* column_family,
825 const char* key, size_t keylen,
826 const char* val, size_t vallen,
827 char** errptr) {
828 SaveError(errptr,
829 db->rep->Put(options->rep, column_family->rep,
830 Slice(key, keylen), Slice(val, vallen)));
831 }
832
rocksdb_delete(rocksdb_t * db,const rocksdb_writeoptions_t * options,const char * key,size_t keylen,char ** errptr)833 void rocksdb_delete(
834 rocksdb_t* db,
835 const rocksdb_writeoptions_t* options,
836 const char* key, size_t keylen,
837 char** errptr) {
838 SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
839 }
840
rocksdb_delete_cf(rocksdb_t * db,const rocksdb_writeoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,char ** errptr)841 void rocksdb_delete_cf(
842 rocksdb_t* db,
843 const rocksdb_writeoptions_t* options,
844 rocksdb_column_family_handle_t* column_family,
845 const char* key, size_t keylen,
846 char** errptr) {
847 SaveError(errptr, db->rep->Delete(options->rep, column_family->rep,
848 Slice(key, keylen)));
849 }
850
rocksdb_delete_range_cf(rocksdb_t * db,const rocksdb_writeoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * start_key,size_t start_key_len,const char * end_key,size_t end_key_len,char ** errptr)851 void rocksdb_delete_range_cf(rocksdb_t* db,
852 const rocksdb_writeoptions_t* options,
853 rocksdb_column_family_handle_t* column_family,
854 const char* start_key, size_t start_key_len,
855 const char* end_key, size_t end_key_len,
856 char** errptr) {
857 SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep,
858 Slice(start_key, start_key_len),
859 Slice(end_key, end_key_len)));
860 }
861
rocksdb_merge(rocksdb_t * db,const rocksdb_writeoptions_t * options,const char * key,size_t keylen,const char * val,size_t vallen,char ** errptr)862 void rocksdb_merge(
863 rocksdb_t* db,
864 const rocksdb_writeoptions_t* options,
865 const char* key, size_t keylen,
866 const char* val, size_t vallen,
867 char** errptr) {
868 SaveError(errptr,
869 db->rep->Merge(options->rep, Slice(key, keylen), Slice(val, vallen)));
870 }
871
rocksdb_merge_cf(rocksdb_t * db,const rocksdb_writeoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,const char * val,size_t vallen,char ** errptr)872 void rocksdb_merge_cf(
873 rocksdb_t* db,
874 const rocksdb_writeoptions_t* options,
875 rocksdb_column_family_handle_t* column_family,
876 const char* key, size_t keylen,
877 const char* val, size_t vallen,
878 char** errptr) {
879 SaveError(errptr,
880 db->rep->Merge(options->rep, column_family->rep,
881 Slice(key, keylen), Slice(val, vallen)));
882 }
883
rocksdb_write(rocksdb_t * db,const rocksdb_writeoptions_t * options,rocksdb_writebatch_t * batch,char ** errptr)884 void rocksdb_write(
885 rocksdb_t* db,
886 const rocksdb_writeoptions_t* options,
887 rocksdb_writebatch_t* batch,
888 char** errptr) {
889 SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
890 }
891
rocksdb_get(rocksdb_t * db,const rocksdb_readoptions_t * options,const char * key,size_t keylen,size_t * vallen,char ** errptr)892 char* rocksdb_get(
893 rocksdb_t* db,
894 const rocksdb_readoptions_t* options,
895 const char* key, size_t keylen,
896 size_t* vallen,
897 char** errptr) {
898 char* result = nullptr;
899 std::string tmp;
900 Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp);
901 if (s.ok()) {
902 *vallen = tmp.size();
903 result = CopyString(tmp);
904 } else {
905 *vallen = 0;
906 if (!s.IsNotFound()) {
907 SaveError(errptr, s);
908 }
909 }
910 return result;
911 }
912
rocksdb_get_cf(rocksdb_t * db,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,size_t * vallen,char ** errptr)913 char* rocksdb_get_cf(
914 rocksdb_t* db,
915 const rocksdb_readoptions_t* options,
916 rocksdb_column_family_handle_t* column_family,
917 const char* key, size_t keylen,
918 size_t* vallen,
919 char** errptr) {
920 char* result = nullptr;
921 std::string tmp;
922 Status s = db->rep->Get(options->rep, column_family->rep,
923 Slice(key, keylen), &tmp);
924 if (s.ok()) {
925 *vallen = tmp.size();
926 result = CopyString(tmp);
927 } else {
928 *vallen = 0;
929 if (!s.IsNotFound()) {
930 SaveError(errptr, s);
931 }
932 }
933 return result;
934 }
935
rocksdb_multi_get(rocksdb_t * db,const rocksdb_readoptions_t * options,size_t num_keys,const char * const * keys_list,const size_t * keys_list_sizes,char ** values_list,size_t * values_list_sizes,char ** errs)936 void rocksdb_multi_get(
937 rocksdb_t* db,
938 const rocksdb_readoptions_t* options,
939 size_t num_keys, const char* const* keys_list,
940 const size_t* keys_list_sizes,
941 char** values_list, size_t* values_list_sizes,
942 char** errs) {
943 std::vector<Slice> keys(num_keys);
944 for (size_t i = 0; i < num_keys; i++) {
945 keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
946 }
947 std::vector<std::string> values(num_keys);
948 std::vector<Status> statuses = db->rep->MultiGet(options->rep, keys, &values);
949 for (size_t i = 0; i < num_keys; i++) {
950 if (statuses[i].ok()) {
951 values_list[i] = CopyString(values[i]);
952 values_list_sizes[i] = values[i].size();
953 errs[i] = nullptr;
954 } else {
955 values_list[i] = nullptr;
956 values_list_sizes[i] = 0;
957 if (!statuses[i].IsNotFound()) {
958 errs[i] = strdup(statuses[i].ToString().c_str());
959 } else {
960 errs[i] = nullptr;
961 }
962 }
963 }
964 }
965
rocksdb_multi_get_cf(rocksdb_t * db,const rocksdb_readoptions_t * options,const rocksdb_column_family_handle_t * const * column_families,size_t num_keys,const char * const * keys_list,const size_t * keys_list_sizes,char ** values_list,size_t * values_list_sizes,char ** errs)966 void rocksdb_multi_get_cf(
967 rocksdb_t* db,
968 const rocksdb_readoptions_t* options,
969 const rocksdb_column_family_handle_t* const* column_families,
970 size_t num_keys, const char* const* keys_list,
971 const size_t* keys_list_sizes,
972 char** values_list, size_t* values_list_sizes,
973 char** errs) {
974 std::vector<Slice> keys(num_keys);
975 std::vector<ColumnFamilyHandle*> cfs(num_keys);
976 for (size_t i = 0; i < num_keys; i++) {
977 keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
978 cfs[i] = column_families[i]->rep;
979 }
980 std::vector<std::string> values(num_keys);
981 std::vector<Status> statuses = db->rep->MultiGet(options->rep, cfs, keys, &values);
982 for (size_t i = 0; i < num_keys; i++) {
983 if (statuses[i].ok()) {
984 values_list[i] = CopyString(values[i]);
985 values_list_sizes[i] = values[i].size();
986 errs[i] = nullptr;
987 } else {
988 values_list[i] = nullptr;
989 values_list_sizes[i] = 0;
990 if (!statuses[i].IsNotFound()) {
991 errs[i] = strdup(statuses[i].ToString().c_str());
992 } else {
993 errs[i] = nullptr;
994 }
995 }
996 }
997 }
998
rocksdb_create_iterator(rocksdb_t * db,const rocksdb_readoptions_t * options)999 rocksdb_iterator_t* rocksdb_create_iterator(
1000 rocksdb_t* db,
1001 const rocksdb_readoptions_t* options) {
1002 rocksdb_iterator_t* result = new rocksdb_iterator_t;
1003 result->rep = db->rep->NewIterator(options->rep);
1004 return result;
1005 }
1006
rocksdb_get_updates_since(rocksdb_t * db,uint64_t seq_number,const rocksdb_wal_readoptions_t * options,char ** errptr)1007 rocksdb_wal_iterator_t* rocksdb_get_updates_since(
1008 rocksdb_t* db, uint64_t seq_number,
1009 const rocksdb_wal_readoptions_t* options,
1010 char** errptr) {
1011 std::unique_ptr<TransactionLogIterator> iter;
1012 TransactionLogIterator::ReadOptions ro;
1013 if (options!=nullptr) {
1014 ro = options->rep;
1015 }
1016 if (SaveError(errptr, db->rep->GetUpdatesSince(seq_number, &iter, ro))) {
1017 return nullptr;
1018 }
1019 rocksdb_wal_iterator_t* result = new rocksdb_wal_iterator_t;
1020 result->rep = iter.release();
1021 return result;
1022 }
1023
rocksdb_wal_iter_next(rocksdb_wal_iterator_t * iter)1024 void rocksdb_wal_iter_next(rocksdb_wal_iterator_t* iter) {
1025 iter->rep->Next();
1026 }
1027
rocksdb_wal_iter_valid(const rocksdb_wal_iterator_t * iter)1028 unsigned char rocksdb_wal_iter_valid(const rocksdb_wal_iterator_t* iter) {
1029 return iter->rep->Valid();
1030 }
1031
rocksdb_wal_iter_status(const rocksdb_wal_iterator_t * iter,char ** errptr)1032 void rocksdb_wal_iter_status (const rocksdb_wal_iterator_t* iter, char** errptr) {
1033 SaveError(errptr, iter->rep->status());
1034 }
1035
rocksdb_wal_iter_destroy(const rocksdb_wal_iterator_t * iter)1036 void rocksdb_wal_iter_destroy (const rocksdb_wal_iterator_t* iter) {
1037 delete iter->rep;
1038 delete iter;
1039 }
1040
rocksdb_wal_iter_get_batch(const rocksdb_wal_iterator_t * iter,uint64_t * seq)1041 rocksdb_writebatch_t* rocksdb_wal_iter_get_batch (const rocksdb_wal_iterator_t* iter, uint64_t* seq) {
1042 rocksdb_writebatch_t* result = rocksdb_writebatch_create();
1043 BatchResult wal_batch = iter->rep->GetBatch();
1044 result->rep = std::move(*wal_batch.writeBatchPtr);
1045 if (seq != nullptr) {
1046 *seq = wal_batch.sequence;
1047 }
1048 return result;
1049 }
1050
rocksdb_get_latest_sequence_number(rocksdb_t * db)1051 uint64_t rocksdb_get_latest_sequence_number (rocksdb_t *db) {
1052 return db->rep->GetLatestSequenceNumber();
1053 }
1054
rocksdb_create_iterator_cf(rocksdb_t * db,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family)1055 rocksdb_iterator_t* rocksdb_create_iterator_cf(
1056 rocksdb_t* db,
1057 const rocksdb_readoptions_t* options,
1058 rocksdb_column_family_handle_t* column_family) {
1059 rocksdb_iterator_t* result = new rocksdb_iterator_t;
1060 result->rep = db->rep->NewIterator(options->rep, column_family->rep);
1061 return result;
1062 }
1063
rocksdb_create_iterators(rocksdb_t * db,rocksdb_readoptions_t * opts,rocksdb_column_family_handle_t ** column_families,rocksdb_iterator_t ** iterators,size_t size,char ** errptr)1064 void rocksdb_create_iterators(
1065 rocksdb_t *db,
1066 rocksdb_readoptions_t* opts,
1067 rocksdb_column_family_handle_t** column_families,
1068 rocksdb_iterator_t** iterators,
1069 size_t size,
1070 char** errptr) {
1071 std::vector<ColumnFamilyHandle*> column_families_vec;
1072 for (size_t i = 0; i < size; i++) {
1073 column_families_vec.push_back(column_families[i]->rep);
1074 }
1075
1076 std::vector<Iterator*> res;
1077 Status status = db->rep->NewIterators(opts->rep, column_families_vec, &res);
1078 assert(res.size() == size);
1079 if (SaveError(errptr, status)) {
1080 return;
1081 }
1082
1083 for (size_t i = 0; i < size; i++) {
1084 iterators[i] = new rocksdb_iterator_t;
1085 iterators[i]->rep = res[i];
1086 }
1087 }
1088
rocksdb_create_snapshot(rocksdb_t * db)1089 const rocksdb_snapshot_t* rocksdb_create_snapshot(
1090 rocksdb_t* db) {
1091 rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
1092 result->rep = db->rep->GetSnapshot();
1093 return result;
1094 }
1095
rocksdb_release_snapshot(rocksdb_t * db,const rocksdb_snapshot_t * snapshot)1096 void rocksdb_release_snapshot(
1097 rocksdb_t* db,
1098 const rocksdb_snapshot_t* snapshot) {
1099 db->rep->ReleaseSnapshot(snapshot->rep);
1100 delete snapshot;
1101 }
1102
rocksdb_property_value(rocksdb_t * db,const char * propname)1103 char* rocksdb_property_value(
1104 rocksdb_t* db,
1105 const char* propname) {
1106 std::string tmp;
1107 if (db->rep->GetProperty(Slice(propname), &tmp)) {
1108 // We use strdup() since we expect human readable output.
1109 return strdup(tmp.c_str());
1110 } else {
1111 return nullptr;
1112 }
1113 }
1114
rocksdb_property_int(rocksdb_t * db,const char * propname,uint64_t * out_val)1115 int rocksdb_property_int(
1116 rocksdb_t* db,
1117 const char* propname,
1118 uint64_t *out_val) {
1119 if (db->rep->GetIntProperty(Slice(propname), out_val)) {
1120 return 0;
1121 } else {
1122 return -1;
1123 }
1124 }
1125
rocksdb_property_int_cf(rocksdb_t * db,rocksdb_column_family_handle_t * column_family,const char * propname,uint64_t * out_val)1126 int rocksdb_property_int_cf(
1127 rocksdb_t* db,
1128 rocksdb_column_family_handle_t* column_family,
1129 const char* propname,
1130 uint64_t *out_val) {
1131 if (db->rep->GetIntProperty(column_family->rep, Slice(propname), out_val)) {
1132 return 0;
1133 } else {
1134 return -1;
1135 }
1136 }
1137
rocksdb_property_value_cf(rocksdb_t * db,rocksdb_column_family_handle_t * column_family,const char * propname)1138 char* rocksdb_property_value_cf(
1139 rocksdb_t* db,
1140 rocksdb_column_family_handle_t* column_family,
1141 const char* propname) {
1142 std::string tmp;
1143 if (db->rep->GetProperty(column_family->rep, Slice(propname), &tmp)) {
1144 // We use strdup() since we expect human readable output.
1145 return strdup(tmp.c_str());
1146 } else {
1147 return nullptr;
1148 }
1149 }
1150
rocksdb_approximate_sizes(rocksdb_t * db,int num_ranges,const char * const * range_start_key,const size_t * range_start_key_len,const char * const * range_limit_key,const size_t * range_limit_key_len,uint64_t * sizes)1151 void rocksdb_approximate_sizes(
1152 rocksdb_t* db,
1153 int num_ranges,
1154 const char* const* range_start_key, const size_t* range_start_key_len,
1155 const char* const* range_limit_key, const size_t* range_limit_key_len,
1156 uint64_t* sizes) {
1157 Range* ranges = new Range[num_ranges];
1158 for (int i = 0; i < num_ranges; i++) {
1159 ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
1160 ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
1161 }
1162 db->rep->GetApproximateSizes(ranges, num_ranges, sizes);
1163 delete[] ranges;
1164 }
1165
rocksdb_approximate_sizes_cf(rocksdb_t * db,rocksdb_column_family_handle_t * column_family,int num_ranges,const char * const * range_start_key,const size_t * range_start_key_len,const char * const * range_limit_key,const size_t * range_limit_key_len,uint64_t * sizes)1166 void rocksdb_approximate_sizes_cf(
1167 rocksdb_t* db,
1168 rocksdb_column_family_handle_t* column_family,
1169 int num_ranges,
1170 const char* const* range_start_key, const size_t* range_start_key_len,
1171 const char* const* range_limit_key, const size_t* range_limit_key_len,
1172 uint64_t* sizes) {
1173 Range* ranges = new Range[num_ranges];
1174 for (int i = 0; i < num_ranges; i++) {
1175 ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
1176 ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
1177 }
1178 db->rep->GetApproximateSizes(column_family->rep, ranges, num_ranges, sizes);
1179 delete[] ranges;
1180 }
1181
rocksdb_delete_file(rocksdb_t * db,const char * name)1182 void rocksdb_delete_file(
1183 rocksdb_t* db,
1184 const char* name) {
1185 db->rep->DeleteFile(name);
1186 }
1187
rocksdb_livefiles(rocksdb_t * db)1188 const rocksdb_livefiles_t* rocksdb_livefiles(
1189 rocksdb_t* db) {
1190 rocksdb_livefiles_t* result = new rocksdb_livefiles_t;
1191 db->rep->GetLiveFilesMetaData(&result->rep);
1192 return result;
1193 }
1194
rocksdb_compact_range(rocksdb_t * db,const char * start_key,size_t start_key_len,const char * limit_key,size_t limit_key_len)1195 void rocksdb_compact_range(
1196 rocksdb_t* db,
1197 const char* start_key, size_t start_key_len,
1198 const char* limit_key, size_t limit_key_len) {
1199 Slice a, b;
1200 db->rep->CompactRange(
1201 CompactRangeOptions(),
1202 // Pass nullptr Slice if corresponding "const char*" is nullptr
1203 (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
1204 (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
1205 }
1206
rocksdb_compact_range_cf(rocksdb_t * db,rocksdb_column_family_handle_t * column_family,const char * start_key,size_t start_key_len,const char * limit_key,size_t limit_key_len)1207 void rocksdb_compact_range_cf(
1208 rocksdb_t* db,
1209 rocksdb_column_family_handle_t* column_family,
1210 const char* start_key, size_t start_key_len,
1211 const char* limit_key, size_t limit_key_len) {
1212 Slice a, b;
1213 db->rep->CompactRange(
1214 CompactRangeOptions(), column_family->rep,
1215 // Pass nullptr Slice if corresponding "const char*" is nullptr
1216 (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
1217 (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
1218 }
1219
rocksdb_compact_range_opt(rocksdb_t * db,rocksdb_compactoptions_t * opt,const char * start_key,size_t start_key_len,const char * limit_key,size_t limit_key_len)1220 void rocksdb_compact_range_opt(rocksdb_t* db, rocksdb_compactoptions_t* opt,
1221 const char* start_key, size_t start_key_len,
1222 const char* limit_key, size_t limit_key_len) {
1223 Slice a, b;
1224 db->rep->CompactRange(
1225 opt->rep,
1226 // Pass nullptr Slice if corresponding "const char*" is nullptr
1227 (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
1228 (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
1229 }
1230
rocksdb_compact_range_cf_opt(rocksdb_t * db,rocksdb_column_family_handle_t * column_family,rocksdb_compactoptions_t * opt,const char * start_key,size_t start_key_len,const char * limit_key,size_t limit_key_len)1231 void rocksdb_compact_range_cf_opt(rocksdb_t* db,
1232 rocksdb_column_family_handle_t* column_family,
1233 rocksdb_compactoptions_t* opt,
1234 const char* start_key, size_t start_key_len,
1235 const char* limit_key, size_t limit_key_len) {
1236 Slice a, b;
1237 db->rep->CompactRange(
1238 opt->rep, column_family->rep,
1239 // Pass nullptr Slice if corresponding "const char*" is nullptr
1240 (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
1241 (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
1242 }
1243
rocksdb_flush(rocksdb_t * db,const rocksdb_flushoptions_t * options,char ** errptr)1244 void rocksdb_flush(
1245 rocksdb_t* db,
1246 const rocksdb_flushoptions_t* options,
1247 char** errptr) {
1248 SaveError(errptr, db->rep->Flush(options->rep));
1249 }
1250
rocksdb_flush_cf(rocksdb_t * db,const rocksdb_flushoptions_t * options,rocksdb_column_family_handle_t * column_family,char ** errptr)1251 void rocksdb_flush_cf(
1252 rocksdb_t* db,
1253 const rocksdb_flushoptions_t* options,
1254 rocksdb_column_family_handle_t* column_family,
1255 char** errptr) {
1256 SaveError(errptr, db->rep->Flush(options->rep, column_family->rep));
1257 }
1258
rocksdb_disable_file_deletions(rocksdb_t * db,char ** errptr)1259 void rocksdb_disable_file_deletions(
1260 rocksdb_t* db,
1261 char** errptr) {
1262 SaveError(errptr, db->rep->DisableFileDeletions());
1263 }
1264
rocksdb_enable_file_deletions(rocksdb_t * db,unsigned char force,char ** errptr)1265 void rocksdb_enable_file_deletions(
1266 rocksdb_t* db,
1267 unsigned char force,
1268 char** errptr) {
1269 SaveError(errptr, db->rep->EnableFileDeletions(force));
1270 }
1271
rocksdb_destroy_db(const rocksdb_options_t * options,const char * name,char ** errptr)1272 void rocksdb_destroy_db(
1273 const rocksdb_options_t* options,
1274 const char* name,
1275 char** errptr) {
1276 SaveError(errptr, DestroyDB(name, options->rep));
1277 }
1278
rocksdb_repair_db(const rocksdb_options_t * options,const char * name,char ** errptr)1279 void rocksdb_repair_db(
1280 const rocksdb_options_t* options,
1281 const char* name,
1282 char** errptr) {
1283 SaveError(errptr, RepairDB(name, options->rep));
1284 }
1285
rocksdb_iter_destroy(rocksdb_iterator_t * iter)1286 void rocksdb_iter_destroy(rocksdb_iterator_t* iter) {
1287 delete iter->rep;
1288 delete iter;
1289 }
1290
rocksdb_iter_valid(const rocksdb_iterator_t * iter)1291 unsigned char rocksdb_iter_valid(const rocksdb_iterator_t* iter) {
1292 return iter->rep->Valid();
1293 }
1294
rocksdb_iter_seek_to_first(rocksdb_iterator_t * iter)1295 void rocksdb_iter_seek_to_first(rocksdb_iterator_t* iter) {
1296 iter->rep->SeekToFirst();
1297 }
1298
rocksdb_iter_seek_to_last(rocksdb_iterator_t * iter)1299 void rocksdb_iter_seek_to_last(rocksdb_iterator_t* iter) {
1300 iter->rep->SeekToLast();
1301 }
1302
rocksdb_iter_seek(rocksdb_iterator_t * iter,const char * k,size_t klen)1303 void rocksdb_iter_seek(rocksdb_iterator_t* iter, const char* k, size_t klen) {
1304 iter->rep->Seek(Slice(k, klen));
1305 }
1306
rocksdb_iter_seek_for_prev(rocksdb_iterator_t * iter,const char * k,size_t klen)1307 void rocksdb_iter_seek_for_prev(rocksdb_iterator_t* iter, const char* k,
1308 size_t klen) {
1309 iter->rep->SeekForPrev(Slice(k, klen));
1310 }
1311
rocksdb_iter_next(rocksdb_iterator_t * iter)1312 void rocksdb_iter_next(rocksdb_iterator_t* iter) {
1313 iter->rep->Next();
1314 }
1315
rocksdb_iter_prev(rocksdb_iterator_t * iter)1316 void rocksdb_iter_prev(rocksdb_iterator_t* iter) {
1317 iter->rep->Prev();
1318 }
1319
rocksdb_iter_key(const rocksdb_iterator_t * iter,size_t * klen)1320 const char* rocksdb_iter_key(const rocksdb_iterator_t* iter, size_t* klen) {
1321 Slice s = iter->rep->key();
1322 *klen = s.size();
1323 return s.data();
1324 }
1325
rocksdb_iter_value(const rocksdb_iterator_t * iter,size_t * vlen)1326 const char* rocksdb_iter_value(const rocksdb_iterator_t* iter, size_t* vlen) {
1327 Slice s = iter->rep->value();
1328 *vlen = s.size();
1329 return s.data();
1330 }
1331
rocksdb_iter_get_error(const rocksdb_iterator_t * iter,char ** errptr)1332 void rocksdb_iter_get_error(const rocksdb_iterator_t* iter, char** errptr) {
1333 SaveError(errptr, iter->rep->status());
1334 }
1335
rocksdb_writebatch_create()1336 rocksdb_writebatch_t* rocksdb_writebatch_create() {
1337 return new rocksdb_writebatch_t;
1338 }
1339
rocksdb_writebatch_create_from(const char * rep,size_t size)1340 rocksdb_writebatch_t* rocksdb_writebatch_create_from(const char* rep,
1341 size_t size) {
1342 rocksdb_writebatch_t* b = new rocksdb_writebatch_t;
1343 b->rep = WriteBatch(std::string(rep, size));
1344 return b;
1345 }
1346
rocksdb_writebatch_destroy(rocksdb_writebatch_t * b)1347 void rocksdb_writebatch_destroy(rocksdb_writebatch_t* b) {
1348 delete b;
1349 }
1350
rocksdb_writebatch_clear(rocksdb_writebatch_t * b)1351 void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) {
1352 b->rep.Clear();
1353 }
1354
rocksdb_writebatch_count(rocksdb_writebatch_t * b)1355 int rocksdb_writebatch_count(rocksdb_writebatch_t* b) {
1356 return b->rep.Count();
1357 }
1358
rocksdb_writebatch_put(rocksdb_writebatch_t * b,const char * key,size_t klen,const char * val,size_t vlen)1359 void rocksdb_writebatch_put(
1360 rocksdb_writebatch_t* b,
1361 const char* key, size_t klen,
1362 const char* val, size_t vlen) {
1363 b->rep.Put(Slice(key, klen), Slice(val, vlen));
1364 }
1365
rocksdb_writebatch_put_cf(rocksdb_writebatch_t * b,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,const char * val,size_t vlen)1366 void rocksdb_writebatch_put_cf(
1367 rocksdb_writebatch_t* b,
1368 rocksdb_column_family_handle_t* column_family,
1369 const char* key, size_t klen,
1370 const char* val, size_t vlen) {
1371 b->rep.Put(column_family->rep, Slice(key, klen), Slice(val, vlen));
1372 }
1373
rocksdb_writebatch_putv(rocksdb_writebatch_t * b,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes,int num_values,const char * const * values_list,const size_t * values_list_sizes)1374 void rocksdb_writebatch_putv(
1375 rocksdb_writebatch_t* b,
1376 int num_keys, const char* const* keys_list,
1377 const size_t* keys_list_sizes,
1378 int num_values, const char* const* values_list,
1379 const size_t* values_list_sizes) {
1380 std::vector<Slice> key_slices(num_keys);
1381 for (int i = 0; i < num_keys; i++) {
1382 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1383 }
1384 std::vector<Slice> value_slices(num_values);
1385 for (int i = 0; i < num_values; i++) {
1386 value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
1387 }
1388 b->rep.Put(SliceParts(key_slices.data(), num_keys),
1389 SliceParts(value_slices.data(), num_values));
1390 }
1391
rocksdb_writebatch_putv_cf(rocksdb_writebatch_t * b,rocksdb_column_family_handle_t * column_family,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes,int num_values,const char * const * values_list,const size_t * values_list_sizes)1392 void rocksdb_writebatch_putv_cf(
1393 rocksdb_writebatch_t* b,
1394 rocksdb_column_family_handle_t* column_family,
1395 int num_keys, const char* const* keys_list,
1396 const size_t* keys_list_sizes,
1397 int num_values, const char* const* values_list,
1398 const size_t* values_list_sizes) {
1399 std::vector<Slice> key_slices(num_keys);
1400 for (int i = 0; i < num_keys; i++) {
1401 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1402 }
1403 std::vector<Slice> value_slices(num_values);
1404 for (int i = 0; i < num_values; i++) {
1405 value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
1406 }
1407 b->rep.Put(column_family->rep, SliceParts(key_slices.data(), num_keys),
1408 SliceParts(value_slices.data(), num_values));
1409 }
1410
rocksdb_writebatch_merge(rocksdb_writebatch_t * b,const char * key,size_t klen,const char * val,size_t vlen)1411 void rocksdb_writebatch_merge(
1412 rocksdb_writebatch_t* b,
1413 const char* key, size_t klen,
1414 const char* val, size_t vlen) {
1415 b->rep.Merge(Slice(key, klen), Slice(val, vlen));
1416 }
1417
rocksdb_writebatch_merge_cf(rocksdb_writebatch_t * b,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,const char * val,size_t vlen)1418 void rocksdb_writebatch_merge_cf(
1419 rocksdb_writebatch_t* b,
1420 rocksdb_column_family_handle_t* column_family,
1421 const char* key, size_t klen,
1422 const char* val, size_t vlen) {
1423 b->rep.Merge(column_family->rep, Slice(key, klen), Slice(val, vlen));
1424 }
1425
rocksdb_writebatch_mergev(rocksdb_writebatch_t * b,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes,int num_values,const char * const * values_list,const size_t * values_list_sizes)1426 void rocksdb_writebatch_mergev(
1427 rocksdb_writebatch_t* b,
1428 int num_keys, const char* const* keys_list,
1429 const size_t* keys_list_sizes,
1430 int num_values, const char* const* values_list,
1431 const size_t* values_list_sizes) {
1432 std::vector<Slice> key_slices(num_keys);
1433 for (int i = 0; i < num_keys; i++) {
1434 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1435 }
1436 std::vector<Slice> value_slices(num_values);
1437 for (int i = 0; i < num_values; i++) {
1438 value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
1439 }
1440 b->rep.Merge(SliceParts(key_slices.data(), num_keys),
1441 SliceParts(value_slices.data(), num_values));
1442 }
1443
rocksdb_writebatch_mergev_cf(rocksdb_writebatch_t * b,rocksdb_column_family_handle_t * column_family,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes,int num_values,const char * const * values_list,const size_t * values_list_sizes)1444 void rocksdb_writebatch_mergev_cf(
1445 rocksdb_writebatch_t* b,
1446 rocksdb_column_family_handle_t* column_family,
1447 int num_keys, const char* const* keys_list,
1448 const size_t* keys_list_sizes,
1449 int num_values, const char* const* values_list,
1450 const size_t* values_list_sizes) {
1451 std::vector<Slice> key_slices(num_keys);
1452 for (int i = 0; i < num_keys; i++) {
1453 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1454 }
1455 std::vector<Slice> value_slices(num_values);
1456 for (int i = 0; i < num_values; i++) {
1457 value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
1458 }
1459 b->rep.Merge(column_family->rep, SliceParts(key_slices.data(), num_keys),
1460 SliceParts(value_slices.data(), num_values));
1461 }
1462
rocksdb_writebatch_delete(rocksdb_writebatch_t * b,const char * key,size_t klen)1463 void rocksdb_writebatch_delete(
1464 rocksdb_writebatch_t* b,
1465 const char* key, size_t klen) {
1466 b->rep.Delete(Slice(key, klen));
1467 }
1468
rocksdb_writebatch_delete_cf(rocksdb_writebatch_t * b,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen)1469 void rocksdb_writebatch_delete_cf(
1470 rocksdb_writebatch_t* b,
1471 rocksdb_column_family_handle_t* column_family,
1472 const char* key, size_t klen) {
1473 b->rep.Delete(column_family->rep, Slice(key, klen));
1474 }
1475
rocksdb_writebatch_deletev(rocksdb_writebatch_t * b,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes)1476 void rocksdb_writebatch_deletev(
1477 rocksdb_writebatch_t* b,
1478 int num_keys, const char* const* keys_list,
1479 const size_t* keys_list_sizes) {
1480 std::vector<Slice> key_slices(num_keys);
1481 for (int i = 0; i < num_keys; i++) {
1482 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1483 }
1484 b->rep.Delete(SliceParts(key_slices.data(), num_keys));
1485 }
1486
rocksdb_writebatch_deletev_cf(rocksdb_writebatch_t * b,rocksdb_column_family_handle_t * column_family,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes)1487 void rocksdb_writebatch_deletev_cf(
1488 rocksdb_writebatch_t* b,
1489 rocksdb_column_family_handle_t* column_family,
1490 int num_keys, const char* const* keys_list,
1491 const size_t* keys_list_sizes) {
1492 std::vector<Slice> key_slices(num_keys);
1493 for (int i = 0; i < num_keys; i++) {
1494 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1495 }
1496 b->rep.Delete(column_family->rep, SliceParts(key_slices.data(), num_keys));
1497 }
1498
rocksdb_writebatch_delete_range(rocksdb_writebatch_t * b,const char * start_key,size_t start_key_len,const char * end_key,size_t end_key_len)1499 void rocksdb_writebatch_delete_range(rocksdb_writebatch_t* b,
1500 const char* start_key,
1501 size_t start_key_len, const char* end_key,
1502 size_t end_key_len) {
1503 b->rep.DeleteRange(Slice(start_key, start_key_len),
1504 Slice(end_key, end_key_len));
1505 }
1506
rocksdb_writebatch_delete_range_cf(rocksdb_writebatch_t * b,rocksdb_column_family_handle_t * column_family,const char * start_key,size_t start_key_len,const char * end_key,size_t end_key_len)1507 void rocksdb_writebatch_delete_range_cf(
1508 rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
1509 const char* start_key, size_t start_key_len, const char* end_key,
1510 size_t end_key_len) {
1511 b->rep.DeleteRange(column_family->rep, Slice(start_key, start_key_len),
1512 Slice(end_key, end_key_len));
1513 }
1514
rocksdb_writebatch_delete_rangev(rocksdb_writebatch_t * b,int num_keys,const char * const * start_keys_list,const size_t * start_keys_list_sizes,const char * const * end_keys_list,const size_t * end_keys_list_sizes)1515 void rocksdb_writebatch_delete_rangev(rocksdb_writebatch_t* b, int num_keys,
1516 const char* const* start_keys_list,
1517 const size_t* start_keys_list_sizes,
1518 const char* const* end_keys_list,
1519 const size_t* end_keys_list_sizes) {
1520 std::vector<Slice> start_key_slices(num_keys);
1521 std::vector<Slice> end_key_slices(num_keys);
1522 for (int i = 0; i < num_keys; i++) {
1523 start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
1524 end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
1525 }
1526 b->rep.DeleteRange(SliceParts(start_key_slices.data(), num_keys),
1527 SliceParts(end_key_slices.data(), num_keys));
1528 }
1529
rocksdb_writebatch_delete_rangev_cf(rocksdb_writebatch_t * b,rocksdb_column_family_handle_t * column_family,int num_keys,const char * const * start_keys_list,const size_t * start_keys_list_sizes,const char * const * end_keys_list,const size_t * end_keys_list_sizes)1530 void rocksdb_writebatch_delete_rangev_cf(
1531 rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
1532 int num_keys, const char* const* start_keys_list,
1533 const size_t* start_keys_list_sizes, const char* const* end_keys_list,
1534 const size_t* end_keys_list_sizes) {
1535 std::vector<Slice> start_key_slices(num_keys);
1536 std::vector<Slice> end_key_slices(num_keys);
1537 for (int i = 0; i < num_keys; i++) {
1538 start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
1539 end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
1540 }
1541 b->rep.DeleteRange(column_family->rep,
1542 SliceParts(start_key_slices.data(), num_keys),
1543 SliceParts(end_key_slices.data(), num_keys));
1544 }
1545
rocksdb_writebatch_put_log_data(rocksdb_writebatch_t * b,const char * blob,size_t len)1546 void rocksdb_writebatch_put_log_data(
1547 rocksdb_writebatch_t* b,
1548 const char* blob, size_t len) {
1549 b->rep.PutLogData(Slice(blob, len));
1550 }
1551
1552 class H : public WriteBatch::Handler {
1553 public:
1554 void* state_;
1555 void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen);
1556 void (*deleted_)(void*, const char* k, size_t klen);
Put(const Slice & key,const Slice & value)1557 void Put(const Slice& key, const Slice& value) override {
1558 (*put_)(state_, key.data(), key.size(), value.data(), value.size());
1559 }
Delete(const Slice & key)1560 void Delete(const Slice& key) override {
1561 (*deleted_)(state_, key.data(), key.size());
1562 }
1563 };
1564
rocksdb_writebatch_iterate(rocksdb_writebatch_t * b,void * state,void (* put)(void *,const char * k,size_t klen,const char * v,size_t vlen),void (* deleted)(void *,const char * k,size_t klen))1565 void rocksdb_writebatch_iterate(
1566 rocksdb_writebatch_t* b,
1567 void* state,
1568 void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
1569 void (*deleted)(void*, const char* k, size_t klen)) {
1570 H handler;
1571 handler.state_ = state;
1572 handler.put_ = put;
1573 handler.deleted_ = deleted;
1574 b->rep.Iterate(&handler);
1575 }
1576
rocksdb_writebatch_data(rocksdb_writebatch_t * b,size_t * size)1577 const char* rocksdb_writebatch_data(rocksdb_writebatch_t* b, size_t* size) {
1578 *size = b->rep.GetDataSize();
1579 return b->rep.Data().c_str();
1580 }
1581
rocksdb_writebatch_set_save_point(rocksdb_writebatch_t * b)1582 void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) {
1583 b->rep.SetSavePoint();
1584 }
1585
rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t * b,char ** errptr)1586 void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b,
1587 char** errptr) {
1588 SaveError(errptr, b->rep.RollbackToSavePoint());
1589 }
1590
rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t * b,char ** errptr)1591 void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) {
1592 SaveError(errptr, b->rep.PopSavePoint());
1593 }
1594
rocksdb_writebatch_wi_create(size_t reserved_bytes,unsigned char overwrite_key)1595 rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create(size_t reserved_bytes, unsigned char overwrite_key) {
1596 rocksdb_writebatch_wi_t* b = new rocksdb_writebatch_wi_t;
1597 b->rep = new WriteBatchWithIndex(BytewiseComparator(), reserved_bytes, overwrite_key);
1598 return b;
1599 }
1600
rocksdb_writebatch_wi_destroy(rocksdb_writebatch_wi_t * b)1601 void rocksdb_writebatch_wi_destroy(rocksdb_writebatch_wi_t* b) {
1602 if (b->rep) {
1603 delete b->rep;
1604 }
1605 delete b;
1606 }
1607
rocksdb_writebatch_wi_clear(rocksdb_writebatch_wi_t * b)1608 void rocksdb_writebatch_wi_clear(rocksdb_writebatch_wi_t* b) {
1609 b->rep->Clear();
1610 }
1611
rocksdb_writebatch_wi_count(rocksdb_writebatch_wi_t * b)1612 int rocksdb_writebatch_wi_count(rocksdb_writebatch_wi_t* b) {
1613 return b->rep->GetWriteBatch()->Count();
1614 }
1615
rocksdb_writebatch_wi_put(rocksdb_writebatch_wi_t * b,const char * key,size_t klen,const char * val,size_t vlen)1616 void rocksdb_writebatch_wi_put(
1617 rocksdb_writebatch_wi_t* b,
1618 const char* key, size_t klen,
1619 const char* val, size_t vlen) {
1620 b->rep->Put(Slice(key, klen), Slice(val, vlen));
1621 }
1622
rocksdb_writebatch_wi_put_cf(rocksdb_writebatch_wi_t * b,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,const char * val,size_t vlen)1623 void rocksdb_writebatch_wi_put_cf(
1624 rocksdb_writebatch_wi_t* b,
1625 rocksdb_column_family_handle_t* column_family,
1626 const char* key, size_t klen,
1627 const char* val, size_t vlen) {
1628 b->rep->Put(column_family->rep, Slice(key, klen), Slice(val, vlen));
1629 }
1630
rocksdb_writebatch_wi_putv(rocksdb_writebatch_wi_t * b,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes,int num_values,const char * const * values_list,const size_t * values_list_sizes)1631 void rocksdb_writebatch_wi_putv(
1632 rocksdb_writebatch_wi_t* b,
1633 int num_keys, const char* const* keys_list,
1634 const size_t* keys_list_sizes,
1635 int num_values, const char* const* values_list,
1636 const size_t* values_list_sizes) {
1637 std::vector<Slice> key_slices(num_keys);
1638 for (int i = 0; i < num_keys; i++) {
1639 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1640 }
1641 std::vector<Slice> value_slices(num_values);
1642 for (int i = 0; i < num_values; i++) {
1643 value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
1644 }
1645 b->rep->Put(SliceParts(key_slices.data(), num_keys),
1646 SliceParts(value_slices.data(), num_values));
1647 }
1648
rocksdb_writebatch_wi_putv_cf(rocksdb_writebatch_wi_t * b,rocksdb_column_family_handle_t * column_family,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes,int num_values,const char * const * values_list,const size_t * values_list_sizes)1649 void rocksdb_writebatch_wi_putv_cf(
1650 rocksdb_writebatch_wi_t* b,
1651 rocksdb_column_family_handle_t* column_family,
1652 int num_keys, const char* const* keys_list,
1653 const size_t* keys_list_sizes,
1654 int num_values, const char* const* values_list,
1655 const size_t* values_list_sizes) {
1656 std::vector<Slice> key_slices(num_keys);
1657 for (int i = 0; i < num_keys; i++) {
1658 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1659 }
1660 std::vector<Slice> value_slices(num_values);
1661 for (int i = 0; i < num_values; i++) {
1662 value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
1663 }
1664 b->rep->Put(column_family->rep, SliceParts(key_slices.data(), num_keys),
1665 SliceParts(value_slices.data(), num_values));
1666 }
1667
rocksdb_writebatch_wi_merge(rocksdb_writebatch_wi_t * b,const char * key,size_t klen,const char * val,size_t vlen)1668 void rocksdb_writebatch_wi_merge(
1669 rocksdb_writebatch_wi_t* b,
1670 const char* key, size_t klen,
1671 const char* val, size_t vlen) {
1672 b->rep->Merge(Slice(key, klen), Slice(val, vlen));
1673 }
1674
rocksdb_writebatch_wi_merge_cf(rocksdb_writebatch_wi_t * b,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,const char * val,size_t vlen)1675 void rocksdb_writebatch_wi_merge_cf(
1676 rocksdb_writebatch_wi_t* b,
1677 rocksdb_column_family_handle_t* column_family,
1678 const char* key, size_t klen,
1679 const char* val, size_t vlen) {
1680 b->rep->Merge(column_family->rep, Slice(key, klen), Slice(val, vlen));
1681 }
1682
rocksdb_writebatch_wi_mergev(rocksdb_writebatch_wi_t * b,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes,int num_values,const char * const * values_list,const size_t * values_list_sizes)1683 void rocksdb_writebatch_wi_mergev(
1684 rocksdb_writebatch_wi_t* b,
1685 int num_keys, const char* const* keys_list,
1686 const size_t* keys_list_sizes,
1687 int num_values, const char* const* values_list,
1688 const size_t* values_list_sizes) {
1689 std::vector<Slice> key_slices(num_keys);
1690 for (int i = 0; i < num_keys; i++) {
1691 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1692 }
1693 std::vector<Slice> value_slices(num_values);
1694 for (int i = 0; i < num_values; i++) {
1695 value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
1696 }
1697 b->rep->Merge(SliceParts(key_slices.data(), num_keys),
1698 SliceParts(value_slices.data(), num_values));
1699 }
1700
rocksdb_writebatch_wi_mergev_cf(rocksdb_writebatch_wi_t * b,rocksdb_column_family_handle_t * column_family,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes,int num_values,const char * const * values_list,const size_t * values_list_sizes)1701 void rocksdb_writebatch_wi_mergev_cf(
1702 rocksdb_writebatch_wi_t* b,
1703 rocksdb_column_family_handle_t* column_family,
1704 int num_keys, const char* const* keys_list,
1705 const size_t* keys_list_sizes,
1706 int num_values, const char* const* values_list,
1707 const size_t* values_list_sizes) {
1708 std::vector<Slice> key_slices(num_keys);
1709 for (int i = 0; i < num_keys; i++) {
1710 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1711 }
1712 std::vector<Slice> value_slices(num_values);
1713 for (int i = 0; i < num_values; i++) {
1714 value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
1715 }
1716 b->rep->Merge(column_family->rep, SliceParts(key_slices.data(), num_keys),
1717 SliceParts(value_slices.data(), num_values));
1718 }
1719
rocksdb_writebatch_wi_delete(rocksdb_writebatch_wi_t * b,const char * key,size_t klen)1720 void rocksdb_writebatch_wi_delete(
1721 rocksdb_writebatch_wi_t* b,
1722 const char* key, size_t klen) {
1723 b->rep->Delete(Slice(key, klen));
1724 }
1725
rocksdb_writebatch_wi_delete_cf(rocksdb_writebatch_wi_t * b,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen)1726 void rocksdb_writebatch_wi_delete_cf(
1727 rocksdb_writebatch_wi_t* b,
1728 rocksdb_column_family_handle_t* column_family,
1729 const char* key, size_t klen) {
1730 b->rep->Delete(column_family->rep, Slice(key, klen));
1731 }
1732
rocksdb_writebatch_wi_deletev(rocksdb_writebatch_wi_t * b,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes)1733 void rocksdb_writebatch_wi_deletev(
1734 rocksdb_writebatch_wi_t* b,
1735 int num_keys, const char* const* keys_list,
1736 const size_t* keys_list_sizes) {
1737 std::vector<Slice> key_slices(num_keys);
1738 for (int i = 0; i < num_keys; i++) {
1739 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1740 }
1741 b->rep->Delete(SliceParts(key_slices.data(), num_keys));
1742 }
1743
rocksdb_writebatch_wi_deletev_cf(rocksdb_writebatch_wi_t * b,rocksdb_column_family_handle_t * column_family,int num_keys,const char * const * keys_list,const size_t * keys_list_sizes)1744 void rocksdb_writebatch_wi_deletev_cf(
1745 rocksdb_writebatch_wi_t* b,
1746 rocksdb_column_family_handle_t* column_family,
1747 int num_keys, const char* const* keys_list,
1748 const size_t* keys_list_sizes) {
1749 std::vector<Slice> key_slices(num_keys);
1750 for (int i = 0; i < num_keys; i++) {
1751 key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
1752 }
1753 b->rep->Delete(column_family->rep, SliceParts(key_slices.data(), num_keys));
1754 }
1755
rocksdb_writebatch_wi_delete_range(rocksdb_writebatch_wi_t * b,const char * start_key,size_t start_key_len,const char * end_key,size_t end_key_len)1756 void rocksdb_writebatch_wi_delete_range(rocksdb_writebatch_wi_t* b,
1757 const char* start_key,
1758 size_t start_key_len, const char* end_key,
1759 size_t end_key_len) {
1760 b->rep->DeleteRange(Slice(start_key, start_key_len),
1761 Slice(end_key, end_key_len));
1762 }
1763
rocksdb_writebatch_wi_delete_range_cf(rocksdb_writebatch_wi_t * b,rocksdb_column_family_handle_t * column_family,const char * start_key,size_t start_key_len,const char * end_key,size_t end_key_len)1764 void rocksdb_writebatch_wi_delete_range_cf(
1765 rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
1766 const char* start_key, size_t start_key_len, const char* end_key,
1767 size_t end_key_len) {
1768 b->rep->DeleteRange(column_family->rep, Slice(start_key, start_key_len),
1769 Slice(end_key, end_key_len));
1770 }
1771
rocksdb_writebatch_wi_delete_rangev(rocksdb_writebatch_wi_t * b,int num_keys,const char * const * start_keys_list,const size_t * start_keys_list_sizes,const char * const * end_keys_list,const size_t * end_keys_list_sizes)1772 void rocksdb_writebatch_wi_delete_rangev(rocksdb_writebatch_wi_t* b, int num_keys,
1773 const char* const* start_keys_list,
1774 const size_t* start_keys_list_sizes,
1775 const char* const* end_keys_list,
1776 const size_t* end_keys_list_sizes) {
1777 std::vector<Slice> start_key_slices(num_keys);
1778 std::vector<Slice> end_key_slices(num_keys);
1779 for (int i = 0; i < num_keys; i++) {
1780 start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
1781 end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
1782 }
1783 b->rep->DeleteRange(SliceParts(start_key_slices.data(), num_keys),
1784 SliceParts(end_key_slices.data(), num_keys));
1785 }
1786
rocksdb_writebatch_wi_delete_rangev_cf(rocksdb_writebatch_wi_t * b,rocksdb_column_family_handle_t * column_family,int num_keys,const char * const * start_keys_list,const size_t * start_keys_list_sizes,const char * const * end_keys_list,const size_t * end_keys_list_sizes)1787 void rocksdb_writebatch_wi_delete_rangev_cf(
1788 rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
1789 int num_keys, const char* const* start_keys_list,
1790 const size_t* start_keys_list_sizes, const char* const* end_keys_list,
1791 const size_t* end_keys_list_sizes) {
1792 std::vector<Slice> start_key_slices(num_keys);
1793 std::vector<Slice> end_key_slices(num_keys);
1794 for (int i = 0; i < num_keys; i++) {
1795 start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
1796 end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
1797 }
1798 b->rep->DeleteRange(column_family->rep,
1799 SliceParts(start_key_slices.data(), num_keys),
1800 SliceParts(end_key_slices.data(), num_keys));
1801 }
1802
rocksdb_writebatch_wi_put_log_data(rocksdb_writebatch_wi_t * b,const char * blob,size_t len)1803 void rocksdb_writebatch_wi_put_log_data(
1804 rocksdb_writebatch_wi_t* b,
1805 const char* blob, size_t len) {
1806 b->rep->PutLogData(Slice(blob, len));
1807 }
1808
rocksdb_writebatch_wi_iterate(rocksdb_writebatch_wi_t * b,void * state,void (* put)(void *,const char * k,size_t klen,const char * v,size_t vlen),void (* deleted)(void *,const char * k,size_t klen))1809 void rocksdb_writebatch_wi_iterate(
1810 rocksdb_writebatch_wi_t* b,
1811 void* state,
1812 void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
1813 void (*deleted)(void*, const char* k, size_t klen)) {
1814 H handler;
1815 handler.state_ = state;
1816 handler.put_ = put;
1817 handler.deleted_ = deleted;
1818 b->rep->GetWriteBatch()->Iterate(&handler);
1819 }
1820
rocksdb_writebatch_wi_data(rocksdb_writebatch_wi_t * b,size_t * size)1821 const char* rocksdb_writebatch_wi_data(rocksdb_writebatch_wi_t* b, size_t* size) {
1822 WriteBatch* wb = b->rep->GetWriteBatch();
1823 *size = wb->GetDataSize();
1824 return wb->Data().c_str();
1825 }
1826
rocksdb_writebatch_wi_set_save_point(rocksdb_writebatch_wi_t * b)1827 void rocksdb_writebatch_wi_set_save_point(rocksdb_writebatch_wi_t* b) {
1828 b->rep->SetSavePoint();
1829 }
1830
rocksdb_writebatch_wi_rollback_to_save_point(rocksdb_writebatch_wi_t * b,char ** errptr)1831 void rocksdb_writebatch_wi_rollback_to_save_point(rocksdb_writebatch_wi_t* b,
1832 char** errptr) {
1833 SaveError(errptr, b->rep->RollbackToSavePoint());
1834 }
1835
rocksdb_writebatch_wi_create_iterator_with_base(rocksdb_writebatch_wi_t * wbwi,rocksdb_iterator_t * base_iterator)1836 rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base(
1837 rocksdb_writebatch_wi_t* wbwi,
1838 rocksdb_iterator_t* base_iterator) {
1839 rocksdb_iterator_t* result = new rocksdb_iterator_t;
1840 result->rep = wbwi->rep->NewIteratorWithBase(base_iterator->rep);
1841 delete base_iterator;
1842 return result;
1843 }
1844
rocksdb_writebatch_wi_create_iterator_with_base_cf(rocksdb_writebatch_wi_t * wbwi,rocksdb_iterator_t * base_iterator,rocksdb_column_family_handle_t * column_family)1845 rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf(
1846 rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator,
1847 rocksdb_column_family_handle_t* column_family) {
1848 rocksdb_iterator_t* result = new rocksdb_iterator_t;
1849 result->rep =
1850 wbwi->rep->NewIteratorWithBase(column_family->rep, base_iterator->rep);
1851 delete base_iterator;
1852 return result;
1853 }
1854
rocksdb_writebatch_wi_get_from_batch(rocksdb_writebatch_wi_t * wbwi,const rocksdb_options_t * options,const char * key,size_t keylen,size_t * vallen,char ** errptr)1855 char* rocksdb_writebatch_wi_get_from_batch(
1856 rocksdb_writebatch_wi_t* wbwi,
1857 const rocksdb_options_t* options,
1858 const char* key, size_t keylen,
1859 size_t* vallen,
1860 char** errptr) {
1861 char* result = nullptr;
1862 std::string tmp;
1863 Status s = wbwi->rep->GetFromBatch(options->rep, Slice(key, keylen), &tmp);
1864 if (s.ok()) {
1865 *vallen = tmp.size();
1866 result = CopyString(tmp);
1867 } else {
1868 *vallen = 0;
1869 if (!s.IsNotFound()) {
1870 SaveError(errptr, s);
1871 }
1872 }
1873 return result;
1874 }
1875
rocksdb_writebatch_wi_get_from_batch_cf(rocksdb_writebatch_wi_t * wbwi,const rocksdb_options_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,size_t * vallen,char ** errptr)1876 char* rocksdb_writebatch_wi_get_from_batch_cf(
1877 rocksdb_writebatch_wi_t* wbwi,
1878 const rocksdb_options_t* options,
1879 rocksdb_column_family_handle_t* column_family,
1880 const char* key, size_t keylen,
1881 size_t* vallen,
1882 char** errptr) {
1883 char* result = nullptr;
1884 std::string tmp;
1885 Status s = wbwi->rep->GetFromBatch(column_family->rep, options->rep,
1886 Slice(key, keylen), &tmp);
1887 if (s.ok()) {
1888 *vallen = tmp.size();
1889 result = CopyString(tmp);
1890 } else {
1891 *vallen = 0;
1892 if (!s.IsNotFound()) {
1893 SaveError(errptr, s);
1894 }
1895 }
1896 return result;
1897 }
1898
rocksdb_writebatch_wi_get_from_batch_and_db(rocksdb_writebatch_wi_t * wbwi,rocksdb_t * db,const rocksdb_readoptions_t * options,const char * key,size_t keylen,size_t * vallen,char ** errptr)1899 char* rocksdb_writebatch_wi_get_from_batch_and_db(
1900 rocksdb_writebatch_wi_t* wbwi,
1901 rocksdb_t* db,
1902 const rocksdb_readoptions_t* options,
1903 const char* key, size_t keylen,
1904 size_t* vallen,
1905 char** errptr) {
1906 char* result = nullptr;
1907 std::string tmp;
1908 Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep, Slice(key, keylen), &tmp);
1909 if (s.ok()) {
1910 *vallen = tmp.size();
1911 result = CopyString(tmp);
1912 } else {
1913 *vallen = 0;
1914 if (!s.IsNotFound()) {
1915 SaveError(errptr, s);
1916 }
1917 }
1918 return result;
1919 }
1920
rocksdb_writebatch_wi_get_from_batch_and_db_cf(rocksdb_writebatch_wi_t * wbwi,rocksdb_t * db,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,size_t * vallen,char ** errptr)1921 char* rocksdb_writebatch_wi_get_from_batch_and_db_cf(
1922 rocksdb_writebatch_wi_t* wbwi,
1923 rocksdb_t* db,
1924 const rocksdb_readoptions_t* options,
1925 rocksdb_column_family_handle_t* column_family,
1926 const char* key, size_t keylen,
1927 size_t* vallen,
1928 char** errptr) {
1929 char* result = nullptr;
1930 std::string tmp;
1931 Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep, column_family->rep,
1932 Slice(key, keylen), &tmp);
1933 if (s.ok()) {
1934 *vallen = tmp.size();
1935 result = CopyString(tmp);
1936 } else {
1937 *vallen = 0;
1938 if (!s.IsNotFound()) {
1939 SaveError(errptr, s);
1940 }
1941 }
1942 return result;
1943 }
1944
rocksdb_write_writebatch_wi(rocksdb_t * db,const rocksdb_writeoptions_t * options,rocksdb_writebatch_wi_t * wbwi,char ** errptr)1945 void rocksdb_write_writebatch_wi(
1946 rocksdb_t* db,
1947 const rocksdb_writeoptions_t* options,
1948 rocksdb_writebatch_wi_t* wbwi,
1949 char** errptr) {
1950 WriteBatch* wb = wbwi->rep->GetWriteBatch();
1951 SaveError(errptr, db->rep->Write(options->rep, wb));
1952 }
1953
1954 rocksdb_block_based_table_options_t*
rocksdb_block_based_options_create()1955 rocksdb_block_based_options_create() {
1956 return new rocksdb_block_based_table_options_t;
1957 }
1958
rocksdb_block_based_options_destroy(rocksdb_block_based_table_options_t * options)1959 void rocksdb_block_based_options_destroy(
1960 rocksdb_block_based_table_options_t* options) {
1961 delete options;
1962 }
1963
rocksdb_block_based_options_set_block_size(rocksdb_block_based_table_options_t * options,size_t block_size)1964 void rocksdb_block_based_options_set_block_size(
1965 rocksdb_block_based_table_options_t* options, size_t block_size) {
1966 options->rep.block_size = block_size;
1967 }
1968
rocksdb_block_based_options_set_block_size_deviation(rocksdb_block_based_table_options_t * options,int block_size_deviation)1969 void rocksdb_block_based_options_set_block_size_deviation(
1970 rocksdb_block_based_table_options_t* options, int block_size_deviation) {
1971 options->rep.block_size_deviation = block_size_deviation;
1972 }
1973
rocksdb_block_based_options_set_block_restart_interval(rocksdb_block_based_table_options_t * options,int block_restart_interval)1974 void rocksdb_block_based_options_set_block_restart_interval(
1975 rocksdb_block_based_table_options_t* options, int block_restart_interval) {
1976 options->rep.block_restart_interval = block_restart_interval;
1977 }
1978
rocksdb_block_based_options_set_index_block_restart_interval(rocksdb_block_based_table_options_t * options,int index_block_restart_interval)1979 void rocksdb_block_based_options_set_index_block_restart_interval(
1980 rocksdb_block_based_table_options_t* options, int index_block_restart_interval) {
1981 options->rep.index_block_restart_interval = index_block_restart_interval;
1982 }
1983
rocksdb_block_based_options_set_metadata_block_size(rocksdb_block_based_table_options_t * options,uint64_t metadata_block_size)1984 void rocksdb_block_based_options_set_metadata_block_size(
1985 rocksdb_block_based_table_options_t* options, uint64_t metadata_block_size) {
1986 options->rep.metadata_block_size = metadata_block_size;
1987 }
1988
rocksdb_block_based_options_set_partition_filters(rocksdb_block_based_table_options_t * options,unsigned char partition_filters)1989 void rocksdb_block_based_options_set_partition_filters(
1990 rocksdb_block_based_table_options_t* options, unsigned char partition_filters) {
1991 options->rep.partition_filters = partition_filters;
1992 }
1993
rocksdb_block_based_options_set_use_delta_encoding(rocksdb_block_based_table_options_t * options,unsigned char use_delta_encoding)1994 void rocksdb_block_based_options_set_use_delta_encoding(
1995 rocksdb_block_based_table_options_t* options, unsigned char use_delta_encoding) {
1996 options->rep.use_delta_encoding = use_delta_encoding;
1997 }
1998
rocksdb_block_based_options_set_filter_policy(rocksdb_block_based_table_options_t * options,rocksdb_filterpolicy_t * filter_policy)1999 void rocksdb_block_based_options_set_filter_policy(
2000 rocksdb_block_based_table_options_t* options,
2001 rocksdb_filterpolicy_t* filter_policy) {
2002 options->rep.filter_policy.reset(filter_policy);
2003 }
2004
rocksdb_block_based_options_set_no_block_cache(rocksdb_block_based_table_options_t * options,unsigned char no_block_cache)2005 void rocksdb_block_based_options_set_no_block_cache(
2006 rocksdb_block_based_table_options_t* options,
2007 unsigned char no_block_cache) {
2008 options->rep.no_block_cache = no_block_cache;
2009 }
2010
rocksdb_block_based_options_set_block_cache(rocksdb_block_based_table_options_t * options,rocksdb_cache_t * block_cache)2011 void rocksdb_block_based_options_set_block_cache(
2012 rocksdb_block_based_table_options_t* options,
2013 rocksdb_cache_t* block_cache) {
2014 if (block_cache) {
2015 options->rep.block_cache = block_cache->rep;
2016 }
2017 }
2018
rocksdb_block_based_options_set_block_cache_compressed(rocksdb_block_based_table_options_t * options,rocksdb_cache_t * block_cache_compressed)2019 void rocksdb_block_based_options_set_block_cache_compressed(
2020 rocksdb_block_based_table_options_t* options,
2021 rocksdb_cache_t* block_cache_compressed) {
2022 if (block_cache_compressed) {
2023 options->rep.block_cache_compressed = block_cache_compressed->rep;
2024 }
2025 }
2026
rocksdb_block_based_options_set_whole_key_filtering(rocksdb_block_based_table_options_t * options,unsigned char v)2027 void rocksdb_block_based_options_set_whole_key_filtering(
2028 rocksdb_block_based_table_options_t* options, unsigned char v) {
2029 options->rep.whole_key_filtering = v;
2030 }
2031
rocksdb_block_based_options_set_format_version(rocksdb_block_based_table_options_t * options,int v)2032 void rocksdb_block_based_options_set_format_version(
2033 rocksdb_block_based_table_options_t* options, int v) {
2034 options->rep.format_version = v;
2035 }
2036
rocksdb_block_based_options_set_index_type(rocksdb_block_based_table_options_t * options,int v)2037 void rocksdb_block_based_options_set_index_type(
2038 rocksdb_block_based_table_options_t* options, int v) {
2039 options->rep.index_type = static_cast<BlockBasedTableOptions::IndexType>(v);
2040 }
2041
rocksdb_block_based_options_set_data_block_index_type(rocksdb_block_based_table_options_t * options,int v)2042 void rocksdb_block_based_options_set_data_block_index_type(
2043 rocksdb_block_based_table_options_t* options, int v) {
2044 options->rep.data_block_index_type =
2045 static_cast<BlockBasedTableOptions::DataBlockIndexType>(v);
2046 }
2047
rocksdb_block_based_options_set_data_block_hash_ratio(rocksdb_block_based_table_options_t * options,double v)2048 void rocksdb_block_based_options_set_data_block_hash_ratio(
2049 rocksdb_block_based_table_options_t* options, double v) {
2050 options->rep.data_block_hash_table_util_ratio = v;
2051 }
2052
rocksdb_block_based_options_set_hash_index_allow_collision(rocksdb_block_based_table_options_t * options,unsigned char v)2053 void rocksdb_block_based_options_set_hash_index_allow_collision(
2054 rocksdb_block_based_table_options_t* options, unsigned char v) {
2055 options->rep.hash_index_allow_collision = v;
2056 }
2057
rocksdb_block_based_options_set_cache_index_and_filter_blocks(rocksdb_block_based_table_options_t * options,unsigned char v)2058 void rocksdb_block_based_options_set_cache_index_and_filter_blocks(
2059 rocksdb_block_based_table_options_t* options, unsigned char v) {
2060 options->rep.cache_index_and_filter_blocks = v;
2061 }
2062
rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority(rocksdb_block_based_table_options_t * options,unsigned char v)2063 void rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority(
2064 rocksdb_block_based_table_options_t* options, unsigned char v) {
2065 options->rep.cache_index_and_filter_blocks_with_high_priority = v;
2066 }
2067
rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(rocksdb_block_based_table_options_t * options,unsigned char v)2068 void rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(
2069 rocksdb_block_based_table_options_t* options, unsigned char v) {
2070 options->rep.pin_l0_filter_and_index_blocks_in_cache = v;
2071 }
2072
rocksdb_block_based_options_set_pin_top_level_index_and_filter(rocksdb_block_based_table_options_t * options,unsigned char v)2073 void rocksdb_block_based_options_set_pin_top_level_index_and_filter(
2074 rocksdb_block_based_table_options_t* options, unsigned char v) {
2075 options->rep.pin_top_level_index_and_filter = v;
2076 }
2077
rocksdb_options_set_block_based_table_factory(rocksdb_options_t * opt,rocksdb_block_based_table_options_t * table_options)2078 void rocksdb_options_set_block_based_table_factory(
2079 rocksdb_options_t *opt,
2080 rocksdb_block_based_table_options_t* table_options) {
2081 if (table_options) {
2082 opt->rep.table_factory.reset(
2083 ROCKSDB_NAMESPACE::NewBlockBasedTableFactory(table_options->rep));
2084 }
2085 }
2086
2087 rocksdb_cuckoo_table_options_t*
rocksdb_cuckoo_options_create()2088 rocksdb_cuckoo_options_create() {
2089 return new rocksdb_cuckoo_table_options_t;
2090 }
2091
rocksdb_cuckoo_options_destroy(rocksdb_cuckoo_table_options_t * options)2092 void rocksdb_cuckoo_options_destroy(
2093 rocksdb_cuckoo_table_options_t* options) {
2094 delete options;
2095 }
2096
rocksdb_cuckoo_options_set_hash_ratio(rocksdb_cuckoo_table_options_t * options,double v)2097 void rocksdb_cuckoo_options_set_hash_ratio(
2098 rocksdb_cuckoo_table_options_t* options, double v) {
2099 options->rep.hash_table_ratio = v;
2100 }
2101
rocksdb_cuckoo_options_set_max_search_depth(rocksdb_cuckoo_table_options_t * options,uint32_t v)2102 void rocksdb_cuckoo_options_set_max_search_depth(
2103 rocksdb_cuckoo_table_options_t* options, uint32_t v) {
2104 options->rep.max_search_depth = v;
2105 }
2106
rocksdb_cuckoo_options_set_cuckoo_block_size(rocksdb_cuckoo_table_options_t * options,uint32_t v)2107 void rocksdb_cuckoo_options_set_cuckoo_block_size(
2108 rocksdb_cuckoo_table_options_t* options, uint32_t v) {
2109 options->rep.cuckoo_block_size = v;
2110 }
2111
rocksdb_cuckoo_options_set_identity_as_first_hash(rocksdb_cuckoo_table_options_t * options,unsigned char v)2112 void rocksdb_cuckoo_options_set_identity_as_first_hash(
2113 rocksdb_cuckoo_table_options_t* options, unsigned char v) {
2114 options->rep.identity_as_first_hash = v;
2115 }
2116
rocksdb_cuckoo_options_set_use_module_hash(rocksdb_cuckoo_table_options_t * options,unsigned char v)2117 void rocksdb_cuckoo_options_set_use_module_hash(
2118 rocksdb_cuckoo_table_options_t* options, unsigned char v) {
2119 options->rep.use_module_hash = v;
2120 }
2121
rocksdb_options_set_cuckoo_table_factory(rocksdb_options_t * opt,rocksdb_cuckoo_table_options_t * table_options)2122 void rocksdb_options_set_cuckoo_table_factory(
2123 rocksdb_options_t *opt,
2124 rocksdb_cuckoo_table_options_t* table_options) {
2125 if (table_options) {
2126 opt->rep.table_factory.reset(
2127 ROCKSDB_NAMESPACE::NewCuckooTableFactory(table_options->rep));
2128 }
2129 }
2130
rocksdb_set_options(rocksdb_t * db,int count,const char * const keys[],const char * const values[],char ** errptr)2131 void rocksdb_set_options(
2132 rocksdb_t* db, int count, const char* const keys[], const char* const values[], char** errptr) {
2133 std::unordered_map<std::string, std::string> options_map;
2134 for (int i=0; i<count; i++)
2135 options_map[keys[i]] = values[i];
2136 SaveError(errptr,
2137 db->rep->SetOptions(options_map));
2138 }
2139
rocksdb_set_options_cf(rocksdb_t * db,rocksdb_column_family_handle_t * handle,int count,const char * const keys[],const char * const values[],char ** errptr)2140 void rocksdb_set_options_cf(
2141 rocksdb_t* db, rocksdb_column_family_handle_t* handle, int count, const char* const keys[], const char* const values[], char** errptr) {
2142 std::unordered_map<std::string, std::string> options_map;
2143 for (int i=0; i<count; i++)
2144 options_map[keys[i]] = values[i];
2145 SaveError(errptr,
2146 db->rep->SetOptions(handle->rep, options_map));
2147 }
2148
rocksdb_options_create()2149 rocksdb_options_t* rocksdb_options_create() {
2150 return new rocksdb_options_t;
2151 }
2152
rocksdb_options_destroy(rocksdb_options_t * options)2153 void rocksdb_options_destroy(rocksdb_options_t* options) {
2154 delete options;
2155 }
2156
rocksdb_options_increase_parallelism(rocksdb_options_t * opt,int total_threads)2157 void rocksdb_options_increase_parallelism(
2158 rocksdb_options_t* opt, int total_threads) {
2159 opt->rep.IncreaseParallelism(total_threads);
2160 }
2161
rocksdb_options_optimize_for_point_lookup(rocksdb_options_t * opt,uint64_t block_cache_size_mb)2162 void rocksdb_options_optimize_for_point_lookup(
2163 rocksdb_options_t* opt, uint64_t block_cache_size_mb) {
2164 opt->rep.OptimizeForPointLookup(block_cache_size_mb);
2165 }
2166
rocksdb_options_optimize_level_style_compaction(rocksdb_options_t * opt,uint64_t memtable_memory_budget)2167 void rocksdb_options_optimize_level_style_compaction(
2168 rocksdb_options_t* opt, uint64_t memtable_memory_budget) {
2169 opt->rep.OptimizeLevelStyleCompaction(memtable_memory_budget);
2170 }
2171
rocksdb_options_optimize_universal_style_compaction(rocksdb_options_t * opt,uint64_t memtable_memory_budget)2172 void rocksdb_options_optimize_universal_style_compaction(
2173 rocksdb_options_t* opt, uint64_t memtable_memory_budget) {
2174 opt->rep.OptimizeUniversalStyleCompaction(memtable_memory_budget);
2175 }
2176
rocksdb_options_set_allow_ingest_behind(rocksdb_options_t * opt,unsigned char v)2177 void rocksdb_options_set_allow_ingest_behind(
2178 rocksdb_options_t* opt, unsigned char v) {
2179 opt->rep.allow_ingest_behind = v;
2180 }
2181
rocksdb_options_set_compaction_filter(rocksdb_options_t * opt,rocksdb_compactionfilter_t * filter)2182 void rocksdb_options_set_compaction_filter(
2183 rocksdb_options_t* opt,
2184 rocksdb_compactionfilter_t* filter) {
2185 opt->rep.compaction_filter = filter;
2186 }
2187
rocksdb_options_set_compaction_filter_factory(rocksdb_options_t * opt,rocksdb_compactionfilterfactory_t * factory)2188 void rocksdb_options_set_compaction_filter_factory(
2189 rocksdb_options_t* opt, rocksdb_compactionfilterfactory_t* factory) {
2190 opt->rep.compaction_filter_factory =
2191 std::shared_ptr<CompactionFilterFactory>(factory);
2192 }
2193
rocksdb_options_compaction_readahead_size(rocksdb_options_t * opt,size_t s)2194 void rocksdb_options_compaction_readahead_size(
2195 rocksdb_options_t* opt, size_t s) {
2196 opt->rep.compaction_readahead_size = s;
2197 }
2198
rocksdb_options_set_comparator(rocksdb_options_t * opt,rocksdb_comparator_t * cmp)2199 void rocksdb_options_set_comparator(
2200 rocksdb_options_t* opt,
2201 rocksdb_comparator_t* cmp) {
2202 opt->rep.comparator = cmp;
2203 }
2204
rocksdb_options_set_merge_operator(rocksdb_options_t * opt,rocksdb_mergeoperator_t * merge_operator)2205 void rocksdb_options_set_merge_operator(
2206 rocksdb_options_t* opt,
2207 rocksdb_mergeoperator_t* merge_operator) {
2208 opt->rep.merge_operator = std::shared_ptr<MergeOperator>(merge_operator);
2209 }
2210
2211
rocksdb_options_set_create_if_missing(rocksdb_options_t * opt,unsigned char v)2212 void rocksdb_options_set_create_if_missing(
2213 rocksdb_options_t* opt, unsigned char v) {
2214 opt->rep.create_if_missing = v;
2215 }
2216
rocksdb_options_set_create_missing_column_families(rocksdb_options_t * opt,unsigned char v)2217 void rocksdb_options_set_create_missing_column_families(
2218 rocksdb_options_t* opt, unsigned char v) {
2219 opt->rep.create_missing_column_families = v;
2220 }
2221
rocksdb_options_set_error_if_exists(rocksdb_options_t * opt,unsigned char v)2222 void rocksdb_options_set_error_if_exists(
2223 rocksdb_options_t* opt, unsigned char v) {
2224 opt->rep.error_if_exists = v;
2225 }
2226
rocksdb_options_set_paranoid_checks(rocksdb_options_t * opt,unsigned char v)2227 void rocksdb_options_set_paranoid_checks(
2228 rocksdb_options_t* opt, unsigned char v) {
2229 opt->rep.paranoid_checks = v;
2230 }
2231
rocksdb_options_set_db_paths(rocksdb_options_t * opt,const rocksdb_dbpath_t ** dbpath_values,size_t num_paths)2232 void rocksdb_options_set_db_paths(rocksdb_options_t* opt,
2233 const rocksdb_dbpath_t** dbpath_values,
2234 size_t num_paths) {
2235 std::vector<DbPath> db_paths(num_paths);
2236 for (size_t i = 0; i < num_paths; ++i) {
2237 db_paths[i] = dbpath_values[i]->rep;
2238 }
2239 opt->rep.db_paths = db_paths;
2240 }
2241
rocksdb_options_set_env(rocksdb_options_t * opt,rocksdb_env_t * env)2242 void rocksdb_options_set_env(rocksdb_options_t* opt, rocksdb_env_t* env) {
2243 opt->rep.env = (env ? env->rep : nullptr);
2244 }
2245
rocksdb_options_set_info_log(rocksdb_options_t * opt,rocksdb_logger_t * l)2246 void rocksdb_options_set_info_log(rocksdb_options_t* opt, rocksdb_logger_t* l) {
2247 if (l) {
2248 opt->rep.info_log = l->rep;
2249 }
2250 }
2251
rocksdb_options_set_info_log_level(rocksdb_options_t * opt,int v)2252 void rocksdb_options_set_info_log_level(
2253 rocksdb_options_t* opt, int v) {
2254 opt->rep.info_log_level = static_cast<InfoLogLevel>(v);
2255 }
2256
rocksdb_options_set_db_write_buffer_size(rocksdb_options_t * opt,size_t s)2257 void rocksdb_options_set_db_write_buffer_size(rocksdb_options_t* opt,
2258 size_t s) {
2259 opt->rep.db_write_buffer_size = s;
2260 }
2261
rocksdb_options_set_write_buffer_size(rocksdb_options_t * opt,size_t s)2262 void rocksdb_options_set_write_buffer_size(rocksdb_options_t* opt, size_t s) {
2263 opt->rep.write_buffer_size = s;
2264 }
2265
rocksdb_options_set_max_open_files(rocksdb_options_t * opt,int n)2266 void rocksdb_options_set_max_open_files(rocksdb_options_t* opt, int n) {
2267 opt->rep.max_open_files = n;
2268 }
2269
rocksdb_options_set_max_file_opening_threads(rocksdb_options_t * opt,int n)2270 void rocksdb_options_set_max_file_opening_threads(rocksdb_options_t* opt, int n) {
2271 opt->rep.max_file_opening_threads = n;
2272 }
2273
rocksdb_options_set_max_total_wal_size(rocksdb_options_t * opt,uint64_t n)2274 void rocksdb_options_set_max_total_wal_size(rocksdb_options_t* opt, uint64_t n) {
2275 opt->rep.max_total_wal_size = n;
2276 }
2277
rocksdb_options_set_target_file_size_base(rocksdb_options_t * opt,uint64_t n)2278 void rocksdb_options_set_target_file_size_base(
2279 rocksdb_options_t* opt, uint64_t n) {
2280 opt->rep.target_file_size_base = n;
2281 }
2282
rocksdb_options_set_target_file_size_multiplier(rocksdb_options_t * opt,int n)2283 void rocksdb_options_set_target_file_size_multiplier(
2284 rocksdb_options_t* opt, int n) {
2285 opt->rep.target_file_size_multiplier = n;
2286 }
2287
rocksdb_options_set_max_bytes_for_level_base(rocksdb_options_t * opt,uint64_t n)2288 void rocksdb_options_set_max_bytes_for_level_base(
2289 rocksdb_options_t* opt, uint64_t n) {
2290 opt->rep.max_bytes_for_level_base = n;
2291 }
2292
rocksdb_options_set_level_compaction_dynamic_level_bytes(rocksdb_options_t * opt,unsigned char v)2293 void rocksdb_options_set_level_compaction_dynamic_level_bytes(
2294 rocksdb_options_t* opt, unsigned char v) {
2295 opt->rep.level_compaction_dynamic_level_bytes = v;
2296 }
2297
rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t * opt,double n)2298 void rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t* opt,
2299 double n) {
2300 opt->rep.max_bytes_for_level_multiplier = n;
2301 }
2302
rocksdb_options_set_max_compaction_bytes(rocksdb_options_t * opt,uint64_t n)2303 void rocksdb_options_set_max_compaction_bytes(rocksdb_options_t* opt,
2304 uint64_t n) {
2305 opt->rep.max_compaction_bytes = n;
2306 }
2307
rocksdb_options_set_max_bytes_for_level_multiplier_additional(rocksdb_options_t * opt,int * level_values,size_t num_levels)2308 void rocksdb_options_set_max_bytes_for_level_multiplier_additional(
2309 rocksdb_options_t* opt, int* level_values, size_t num_levels) {
2310 opt->rep.max_bytes_for_level_multiplier_additional.resize(num_levels);
2311 for (size_t i = 0; i < num_levels; ++i) {
2312 opt->rep.max_bytes_for_level_multiplier_additional[i] = level_values[i];
2313 }
2314 }
2315
rocksdb_options_enable_statistics(rocksdb_options_t * opt)2316 void rocksdb_options_enable_statistics(rocksdb_options_t* opt) {
2317 opt->rep.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
2318 }
2319
rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t * opt,unsigned char val)2320 void rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt,
2321 unsigned char val) {
2322 opt->rep.skip_stats_update_on_db_open = val;
2323 }
2324
rocksdb_options_set_skip_checking_sst_file_sizes_on_db_open(rocksdb_options_t * opt,unsigned char val)2325 void rocksdb_options_set_skip_checking_sst_file_sizes_on_db_open(
2326 rocksdb_options_t* opt, unsigned char val) {
2327 opt->rep.skip_checking_sst_file_sizes_on_db_open = val;
2328 }
2329
rocksdb_options_set_num_levels(rocksdb_options_t * opt,int n)2330 void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int n) {
2331 opt->rep.num_levels = n;
2332 }
2333
rocksdb_options_set_level0_file_num_compaction_trigger(rocksdb_options_t * opt,int n)2334 void rocksdb_options_set_level0_file_num_compaction_trigger(
2335 rocksdb_options_t* opt, int n) {
2336 opt->rep.level0_file_num_compaction_trigger = n;
2337 }
2338
rocksdb_options_set_level0_slowdown_writes_trigger(rocksdb_options_t * opt,int n)2339 void rocksdb_options_set_level0_slowdown_writes_trigger(
2340 rocksdb_options_t* opt, int n) {
2341 opt->rep.level0_slowdown_writes_trigger = n;
2342 }
2343
rocksdb_options_set_level0_stop_writes_trigger(rocksdb_options_t * opt,int n)2344 void rocksdb_options_set_level0_stop_writes_trigger(
2345 rocksdb_options_t* opt, int n) {
2346 opt->rep.level0_stop_writes_trigger = n;
2347 }
2348
rocksdb_options_set_max_mem_compaction_level(rocksdb_options_t *,int)2349 void rocksdb_options_set_max_mem_compaction_level(rocksdb_options_t* /*opt*/,
2350 int /*n*/) {}
2351
rocksdb_options_set_wal_recovery_mode(rocksdb_options_t * opt,int mode)2352 void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt,int mode) {
2353 opt->rep.wal_recovery_mode = static_cast<WALRecoveryMode>(mode);
2354 }
2355
rocksdb_options_set_compression(rocksdb_options_t * opt,int t)2356 void rocksdb_options_set_compression(rocksdb_options_t* opt, int t) {
2357 opt->rep.compression = static_cast<CompressionType>(t);
2358 }
2359
rocksdb_options_set_compression_per_level(rocksdb_options_t * opt,int * level_values,size_t num_levels)2360 void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt,
2361 int* level_values,
2362 size_t num_levels) {
2363 opt->rep.compression_per_level.resize(num_levels);
2364 for (size_t i = 0; i < num_levels; ++i) {
2365 opt->rep.compression_per_level[i] =
2366 static_cast<CompressionType>(level_values[i]);
2367 }
2368 }
2369
rocksdb_options_set_bottommost_compression_options(rocksdb_options_t * opt,int w_bits,int level,int strategy,int max_dict_bytes,bool enabled)2370 void rocksdb_options_set_bottommost_compression_options(rocksdb_options_t* opt,
2371 int w_bits, int level,
2372 int strategy,
2373 int max_dict_bytes,
2374 bool enabled) {
2375 opt->rep.bottommost_compression_opts.window_bits = w_bits;
2376 opt->rep.bottommost_compression_opts.level = level;
2377 opt->rep.bottommost_compression_opts.strategy = strategy;
2378 opt->rep.bottommost_compression_opts.max_dict_bytes = max_dict_bytes;
2379 opt->rep.bottommost_compression_opts.enabled = enabled;
2380 }
2381
rocksdb_options_set_compression_options(rocksdb_options_t * opt,int w_bits,int level,int strategy,int max_dict_bytes)2382 void rocksdb_options_set_compression_options(rocksdb_options_t* opt, int w_bits,
2383 int level, int strategy,
2384 int max_dict_bytes) {
2385 opt->rep.compression_opts.window_bits = w_bits;
2386 opt->rep.compression_opts.level = level;
2387 opt->rep.compression_opts.strategy = strategy;
2388 opt->rep.compression_opts.max_dict_bytes = max_dict_bytes;
2389 }
2390
rocksdb_options_set_prefix_extractor(rocksdb_options_t * opt,rocksdb_slicetransform_t * prefix_extractor)2391 void rocksdb_options_set_prefix_extractor(
2392 rocksdb_options_t* opt, rocksdb_slicetransform_t* prefix_extractor) {
2393 opt->rep.prefix_extractor.reset(prefix_extractor);
2394 }
2395
rocksdb_options_set_use_fsync(rocksdb_options_t * opt,int use_fsync)2396 void rocksdb_options_set_use_fsync(
2397 rocksdb_options_t* opt, int use_fsync) {
2398 opt->rep.use_fsync = use_fsync;
2399 }
2400
rocksdb_options_set_db_log_dir(rocksdb_options_t * opt,const char * db_log_dir)2401 void rocksdb_options_set_db_log_dir(
2402 rocksdb_options_t* opt, const char* db_log_dir) {
2403 opt->rep.db_log_dir = db_log_dir;
2404 }
2405
rocksdb_options_set_wal_dir(rocksdb_options_t * opt,const char * v)2406 void rocksdb_options_set_wal_dir(
2407 rocksdb_options_t* opt, const char* v) {
2408 opt->rep.wal_dir = v;
2409 }
2410
rocksdb_options_set_WAL_ttl_seconds(rocksdb_options_t * opt,uint64_t ttl)2411 void rocksdb_options_set_WAL_ttl_seconds(rocksdb_options_t* opt, uint64_t ttl) {
2412 opt->rep.WAL_ttl_seconds = ttl;
2413 }
2414
rocksdb_options_set_WAL_size_limit_MB(rocksdb_options_t * opt,uint64_t limit)2415 void rocksdb_options_set_WAL_size_limit_MB(
2416 rocksdb_options_t* opt, uint64_t limit) {
2417 opt->rep.WAL_size_limit_MB = limit;
2418 }
2419
rocksdb_options_set_manifest_preallocation_size(rocksdb_options_t * opt,size_t v)2420 void rocksdb_options_set_manifest_preallocation_size(
2421 rocksdb_options_t* opt, size_t v) {
2422 opt->rep.manifest_preallocation_size = v;
2423 }
2424
2425 // noop
rocksdb_options_set_purge_redundant_kvs_while_flush(rocksdb_options_t *,unsigned char)2426 void rocksdb_options_set_purge_redundant_kvs_while_flush(
2427 rocksdb_options_t* /*opt*/, unsigned char /*v*/) {}
2428
rocksdb_options_set_use_direct_reads(rocksdb_options_t * opt,unsigned char v)2429 void rocksdb_options_set_use_direct_reads(rocksdb_options_t* opt,
2430 unsigned char v) {
2431 opt->rep.use_direct_reads = v;
2432 }
2433
rocksdb_options_set_use_direct_io_for_flush_and_compaction(rocksdb_options_t * opt,unsigned char v)2434 void rocksdb_options_set_use_direct_io_for_flush_and_compaction(
2435 rocksdb_options_t* opt, unsigned char v) {
2436 opt->rep.use_direct_io_for_flush_and_compaction = v;
2437 }
2438
rocksdb_options_set_allow_mmap_reads(rocksdb_options_t * opt,unsigned char v)2439 void rocksdb_options_set_allow_mmap_reads(
2440 rocksdb_options_t* opt, unsigned char v) {
2441 opt->rep.allow_mmap_reads = v;
2442 }
2443
rocksdb_options_set_allow_mmap_writes(rocksdb_options_t * opt,unsigned char v)2444 void rocksdb_options_set_allow_mmap_writes(
2445 rocksdb_options_t* opt, unsigned char v) {
2446 opt->rep.allow_mmap_writes = v;
2447 }
2448
rocksdb_options_set_is_fd_close_on_exec(rocksdb_options_t * opt,unsigned char v)2449 void rocksdb_options_set_is_fd_close_on_exec(
2450 rocksdb_options_t* opt, unsigned char v) {
2451 opt->rep.is_fd_close_on_exec = v;
2452 }
2453
rocksdb_options_set_skip_log_error_on_recovery(rocksdb_options_t * opt,unsigned char v)2454 void rocksdb_options_set_skip_log_error_on_recovery(
2455 rocksdb_options_t* opt, unsigned char v) {
2456 opt->rep.skip_log_error_on_recovery = v;
2457 }
2458
rocksdb_options_set_stats_dump_period_sec(rocksdb_options_t * opt,unsigned int v)2459 void rocksdb_options_set_stats_dump_period_sec(
2460 rocksdb_options_t* opt, unsigned int v) {
2461 opt->rep.stats_dump_period_sec = v;
2462 }
2463
rocksdb_options_set_advise_random_on_open(rocksdb_options_t * opt,unsigned char v)2464 void rocksdb_options_set_advise_random_on_open(
2465 rocksdb_options_t* opt, unsigned char v) {
2466 opt->rep.advise_random_on_open = v;
2467 }
2468
rocksdb_options_set_access_hint_on_compaction_start(rocksdb_options_t * opt,int v)2469 void rocksdb_options_set_access_hint_on_compaction_start(
2470 rocksdb_options_t* opt, int v) {
2471 switch(v) {
2472 case 0:
2473 opt->rep.access_hint_on_compaction_start =
2474 ROCKSDB_NAMESPACE::Options::NONE;
2475 break;
2476 case 1:
2477 opt->rep.access_hint_on_compaction_start =
2478 ROCKSDB_NAMESPACE::Options::NORMAL;
2479 break;
2480 case 2:
2481 opt->rep.access_hint_on_compaction_start =
2482 ROCKSDB_NAMESPACE::Options::SEQUENTIAL;
2483 break;
2484 case 3:
2485 opt->rep.access_hint_on_compaction_start =
2486 ROCKSDB_NAMESPACE::Options::WILLNEED;
2487 break;
2488 }
2489 }
2490
rocksdb_options_set_use_adaptive_mutex(rocksdb_options_t * opt,unsigned char v)2491 void rocksdb_options_set_use_adaptive_mutex(
2492 rocksdb_options_t* opt, unsigned char v) {
2493 opt->rep.use_adaptive_mutex = v;
2494 }
2495
rocksdb_options_set_wal_bytes_per_sync(rocksdb_options_t * opt,uint64_t v)2496 void rocksdb_options_set_wal_bytes_per_sync(
2497 rocksdb_options_t* opt, uint64_t v) {
2498 opt->rep.wal_bytes_per_sync = v;
2499 }
2500
rocksdb_options_set_bytes_per_sync(rocksdb_options_t * opt,uint64_t v)2501 void rocksdb_options_set_bytes_per_sync(
2502 rocksdb_options_t* opt, uint64_t v) {
2503 opt->rep.bytes_per_sync = v;
2504 }
2505
rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t * opt,uint64_t v)2506 void rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t* opt,
2507 uint64_t v) {
2508 opt->rep.writable_file_max_buffer_size = static_cast<size_t>(v);
2509 }
2510
rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t * opt,unsigned char v)2511 void rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t* opt,
2512 unsigned char v) {
2513 opt->rep.allow_concurrent_memtable_write = v;
2514 }
2515
rocksdb_options_set_enable_write_thread_adaptive_yield(rocksdb_options_t * opt,unsigned char v)2516 void rocksdb_options_set_enable_write_thread_adaptive_yield(
2517 rocksdb_options_t* opt, unsigned char v) {
2518 opt->rep.enable_write_thread_adaptive_yield = v;
2519 }
2520
rocksdb_options_set_max_sequential_skip_in_iterations(rocksdb_options_t * opt,uint64_t v)2521 void rocksdb_options_set_max_sequential_skip_in_iterations(
2522 rocksdb_options_t* opt, uint64_t v) {
2523 opt->rep.max_sequential_skip_in_iterations = v;
2524 }
2525
rocksdb_options_set_max_write_buffer_number(rocksdb_options_t * opt,int n)2526 void rocksdb_options_set_max_write_buffer_number(rocksdb_options_t* opt, int n) {
2527 opt->rep.max_write_buffer_number = n;
2528 }
2529
rocksdb_options_set_min_write_buffer_number_to_merge(rocksdb_options_t * opt,int n)2530 void rocksdb_options_set_min_write_buffer_number_to_merge(rocksdb_options_t* opt, int n) {
2531 opt->rep.min_write_buffer_number_to_merge = n;
2532 }
2533
rocksdb_options_set_max_write_buffer_number_to_maintain(rocksdb_options_t * opt,int n)2534 void rocksdb_options_set_max_write_buffer_number_to_maintain(
2535 rocksdb_options_t* opt, int n) {
2536 opt->rep.max_write_buffer_number_to_maintain = n;
2537 }
2538
rocksdb_options_set_max_write_buffer_size_to_maintain(rocksdb_options_t * opt,int64_t n)2539 void rocksdb_options_set_max_write_buffer_size_to_maintain(
2540 rocksdb_options_t* opt, int64_t n) {
2541 opt->rep.max_write_buffer_size_to_maintain = n;
2542 }
2543
rocksdb_options_set_enable_pipelined_write(rocksdb_options_t * opt,unsigned char v)2544 void rocksdb_options_set_enable_pipelined_write(rocksdb_options_t* opt,
2545 unsigned char v) {
2546 opt->rep.enable_pipelined_write = v;
2547 }
2548
rocksdb_options_set_unordered_write(rocksdb_options_t * opt,unsigned char v)2549 void rocksdb_options_set_unordered_write(rocksdb_options_t* opt,
2550 unsigned char v) {
2551 opt->rep.unordered_write = v;
2552 }
2553
rocksdb_options_set_max_subcompactions(rocksdb_options_t * opt,uint32_t n)2554 void rocksdb_options_set_max_subcompactions(rocksdb_options_t* opt,
2555 uint32_t n) {
2556 opt->rep.max_subcompactions = n;
2557 }
2558
rocksdb_options_set_max_background_jobs(rocksdb_options_t * opt,int n)2559 void rocksdb_options_set_max_background_jobs(rocksdb_options_t* opt, int n) {
2560 opt->rep.max_background_jobs = n;
2561 }
2562
rocksdb_options_set_max_background_compactions(rocksdb_options_t * opt,int n)2563 void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt, int n) {
2564 opt->rep.max_background_compactions = n;
2565 }
2566
rocksdb_options_set_base_background_compactions(rocksdb_options_t * opt,int n)2567 void rocksdb_options_set_base_background_compactions(rocksdb_options_t* opt,
2568 int n) {
2569 opt->rep.base_background_compactions = n;
2570 }
2571
rocksdb_options_set_max_background_flushes(rocksdb_options_t * opt,int n)2572 void rocksdb_options_set_max_background_flushes(rocksdb_options_t* opt, int n) {
2573 opt->rep.max_background_flushes = n;
2574 }
2575
rocksdb_options_set_max_log_file_size(rocksdb_options_t * opt,size_t v)2576 void rocksdb_options_set_max_log_file_size(rocksdb_options_t* opt, size_t v) {
2577 opt->rep.max_log_file_size = v;
2578 }
2579
rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t * opt,size_t v)2580 void rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t* opt, size_t v) {
2581 opt->rep.log_file_time_to_roll = v;
2582 }
2583
rocksdb_options_set_keep_log_file_num(rocksdb_options_t * opt,size_t v)2584 void rocksdb_options_set_keep_log_file_num(rocksdb_options_t* opt, size_t v) {
2585 opt->rep.keep_log_file_num = v;
2586 }
2587
rocksdb_options_set_recycle_log_file_num(rocksdb_options_t * opt,size_t v)2588 void rocksdb_options_set_recycle_log_file_num(rocksdb_options_t* opt,
2589 size_t v) {
2590 opt->rep.recycle_log_file_num = v;
2591 }
2592
rocksdb_options_set_soft_rate_limit(rocksdb_options_t * opt,double v)2593 void rocksdb_options_set_soft_rate_limit(rocksdb_options_t* opt, double v) {
2594 opt->rep.soft_rate_limit = v;
2595 }
2596
rocksdb_options_set_hard_rate_limit(rocksdb_options_t * opt,double v)2597 void rocksdb_options_set_hard_rate_limit(rocksdb_options_t* opt, double v) {
2598 opt->rep.hard_rate_limit = v;
2599 }
2600
rocksdb_options_set_soft_pending_compaction_bytes_limit(rocksdb_options_t * opt,size_t v)2601 void rocksdb_options_set_soft_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v) {
2602 opt->rep.soft_pending_compaction_bytes_limit = v;
2603 }
2604
rocksdb_options_set_hard_pending_compaction_bytes_limit(rocksdb_options_t * opt,size_t v)2605 void rocksdb_options_set_hard_pending_compaction_bytes_limit(rocksdb_options_t* opt, size_t v) {
2606 opt->rep.hard_pending_compaction_bytes_limit = v;
2607 }
2608
rocksdb_options_set_rate_limit_delay_max_milliseconds(rocksdb_options_t * opt,unsigned int v)2609 void rocksdb_options_set_rate_limit_delay_max_milliseconds(
2610 rocksdb_options_t* opt, unsigned int v) {
2611 opt->rep.rate_limit_delay_max_milliseconds = v;
2612 }
2613
rocksdb_options_set_max_manifest_file_size(rocksdb_options_t * opt,size_t v)2614 void rocksdb_options_set_max_manifest_file_size(
2615 rocksdb_options_t* opt, size_t v) {
2616 opt->rep.max_manifest_file_size = v;
2617 }
2618
rocksdb_options_set_table_cache_numshardbits(rocksdb_options_t * opt,int v)2619 void rocksdb_options_set_table_cache_numshardbits(
2620 rocksdb_options_t* opt, int v) {
2621 opt->rep.table_cache_numshardbits = v;
2622 }
2623
rocksdb_options_set_table_cache_remove_scan_count_limit(rocksdb_options_t *,int)2624 void rocksdb_options_set_table_cache_remove_scan_count_limit(
2625 rocksdb_options_t* /*opt*/, int /*v*/) {
2626 // this option is deprecated
2627 }
2628
rocksdb_options_set_arena_block_size(rocksdb_options_t * opt,size_t v)2629 void rocksdb_options_set_arena_block_size(
2630 rocksdb_options_t* opt, size_t v) {
2631 opt->rep.arena_block_size = v;
2632 }
2633
rocksdb_options_set_disable_auto_compactions(rocksdb_options_t * opt,int disable)2634 void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt, int disable) {
2635 opt->rep.disable_auto_compactions = disable;
2636 }
2637
rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t * opt,int v)2638 void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt, int v) {
2639 opt->rep.optimize_filters_for_hits = v;
2640 }
2641
rocksdb_options_set_delete_obsolete_files_period_micros(rocksdb_options_t * opt,uint64_t v)2642 void rocksdb_options_set_delete_obsolete_files_period_micros(
2643 rocksdb_options_t* opt, uint64_t v) {
2644 opt->rep.delete_obsolete_files_period_micros = v;
2645 }
2646
rocksdb_options_prepare_for_bulk_load(rocksdb_options_t * opt)2647 void rocksdb_options_prepare_for_bulk_load(rocksdb_options_t* opt) {
2648 opt->rep.PrepareForBulkLoad();
2649 }
2650
rocksdb_options_set_memtable_vector_rep(rocksdb_options_t * opt)2651 void rocksdb_options_set_memtable_vector_rep(rocksdb_options_t *opt) {
2652 opt->rep.memtable_factory.reset(new ROCKSDB_NAMESPACE::VectorRepFactory);
2653 }
2654
rocksdb_options_set_memtable_prefix_bloom_size_ratio(rocksdb_options_t * opt,double v)2655 void rocksdb_options_set_memtable_prefix_bloom_size_ratio(
2656 rocksdb_options_t* opt, double v) {
2657 opt->rep.memtable_prefix_bloom_size_ratio = v;
2658 }
2659
rocksdb_options_set_memtable_huge_page_size(rocksdb_options_t * opt,size_t v)2660 void rocksdb_options_set_memtable_huge_page_size(rocksdb_options_t* opt,
2661 size_t v) {
2662 opt->rep.memtable_huge_page_size = v;
2663 }
2664
rocksdb_options_set_hash_skip_list_rep(rocksdb_options_t * opt,size_t bucket_count,int32_t skiplist_height,int32_t skiplist_branching_factor)2665 void rocksdb_options_set_hash_skip_list_rep(
2666 rocksdb_options_t *opt, size_t bucket_count,
2667 int32_t skiplist_height, int32_t skiplist_branching_factor) {
2668 ROCKSDB_NAMESPACE::MemTableRepFactory* factory =
2669 ROCKSDB_NAMESPACE::NewHashSkipListRepFactory(
2670 bucket_count, skiplist_height, skiplist_branching_factor);
2671 opt->rep.memtable_factory.reset(factory);
2672 }
2673
rocksdb_options_set_hash_link_list_rep(rocksdb_options_t * opt,size_t bucket_count)2674 void rocksdb_options_set_hash_link_list_rep(
2675 rocksdb_options_t *opt, size_t bucket_count) {
2676 opt->rep.memtable_factory.reset(
2677 ROCKSDB_NAMESPACE::NewHashLinkListRepFactory(bucket_count));
2678 }
2679
rocksdb_options_set_plain_table_factory(rocksdb_options_t * opt,uint32_t user_key_len,int bloom_bits_per_key,double hash_table_ratio,size_t index_sparseness)2680 void rocksdb_options_set_plain_table_factory(
2681 rocksdb_options_t *opt, uint32_t user_key_len, int bloom_bits_per_key,
2682 double hash_table_ratio, size_t index_sparseness) {
2683 ROCKSDB_NAMESPACE::PlainTableOptions options;
2684 options.user_key_len = user_key_len;
2685 options.bloom_bits_per_key = bloom_bits_per_key;
2686 options.hash_table_ratio = hash_table_ratio;
2687 options.index_sparseness = index_sparseness;
2688
2689 ROCKSDB_NAMESPACE::TableFactory* factory =
2690 ROCKSDB_NAMESPACE::NewPlainTableFactory(options);
2691 opt->rep.table_factory.reset(factory);
2692 }
2693
rocksdb_options_set_max_successive_merges(rocksdb_options_t * opt,size_t v)2694 void rocksdb_options_set_max_successive_merges(
2695 rocksdb_options_t* opt, size_t v) {
2696 opt->rep.max_successive_merges = v;
2697 }
2698
rocksdb_options_set_bloom_locality(rocksdb_options_t * opt,uint32_t v)2699 void rocksdb_options_set_bloom_locality(
2700 rocksdb_options_t* opt, uint32_t v) {
2701 opt->rep.bloom_locality = v;
2702 }
2703
rocksdb_options_set_inplace_update_support(rocksdb_options_t * opt,unsigned char v)2704 void rocksdb_options_set_inplace_update_support(
2705 rocksdb_options_t* opt, unsigned char v) {
2706 opt->rep.inplace_update_support = v;
2707 }
2708
rocksdb_options_set_inplace_update_num_locks(rocksdb_options_t * opt,size_t v)2709 void rocksdb_options_set_inplace_update_num_locks(
2710 rocksdb_options_t* opt, size_t v) {
2711 opt->rep.inplace_update_num_locks = v;
2712 }
2713
rocksdb_options_set_report_bg_io_stats(rocksdb_options_t * opt,int v)2714 void rocksdb_options_set_report_bg_io_stats(
2715 rocksdb_options_t* opt, int v) {
2716 opt->rep.report_bg_io_stats = v;
2717 }
2718
rocksdb_options_set_compaction_style(rocksdb_options_t * opt,int style)2719 void rocksdb_options_set_compaction_style(rocksdb_options_t *opt, int style) {
2720 opt->rep.compaction_style =
2721 static_cast<ROCKSDB_NAMESPACE::CompactionStyle>(style);
2722 }
2723
rocksdb_options_set_universal_compaction_options(rocksdb_options_t * opt,rocksdb_universal_compaction_options_t * uco)2724 void rocksdb_options_set_universal_compaction_options(rocksdb_options_t *opt, rocksdb_universal_compaction_options_t *uco) {
2725 opt->rep.compaction_options_universal = *(uco->rep);
2726 }
2727
rocksdb_options_set_fifo_compaction_options(rocksdb_options_t * opt,rocksdb_fifo_compaction_options_t * fifo)2728 void rocksdb_options_set_fifo_compaction_options(
2729 rocksdb_options_t* opt,
2730 rocksdb_fifo_compaction_options_t* fifo) {
2731 opt->rep.compaction_options_fifo = fifo->rep;
2732 }
2733
rocksdb_options_statistics_get_string(rocksdb_options_t * opt)2734 char *rocksdb_options_statistics_get_string(rocksdb_options_t *opt) {
2735 ROCKSDB_NAMESPACE::Statistics* statistics = opt->rep.statistics.get();
2736 if (statistics) {
2737 return strdup(statistics->ToString().c_str());
2738 }
2739 return nullptr;
2740 }
2741
rocksdb_options_set_ratelimiter(rocksdb_options_t * opt,rocksdb_ratelimiter_t * limiter)2742 void rocksdb_options_set_ratelimiter(rocksdb_options_t *opt, rocksdb_ratelimiter_t *limiter) {
2743 if (limiter) {
2744 opt->rep.rate_limiter = limiter->rep;
2745 }
2746 }
2747
rocksdb_options_set_atomic_flush(rocksdb_options_t * opt,unsigned char atomic_flush)2748 void rocksdb_options_set_atomic_flush(rocksdb_options_t* opt,
2749 unsigned char atomic_flush) {
2750 opt->rep.atomic_flush = atomic_flush;
2751 }
2752
rocksdb_ratelimiter_create(int64_t rate_bytes_per_sec,int64_t refill_period_us,int32_t fairness)2753 rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
2754 int64_t rate_bytes_per_sec,
2755 int64_t refill_period_us,
2756 int32_t fairness) {
2757 rocksdb_ratelimiter_t* rate_limiter = new rocksdb_ratelimiter_t;
2758 rate_limiter->rep.reset(
2759 NewGenericRateLimiter(rate_bytes_per_sec,
2760 refill_period_us, fairness));
2761 return rate_limiter;
2762 }
2763
rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t * limiter)2764 void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t *limiter) {
2765 delete limiter;
2766 }
2767
rocksdb_options_set_row_cache(rocksdb_options_t * opt,rocksdb_cache_t * cache)2768 void rocksdb_options_set_row_cache(rocksdb_options_t* opt, rocksdb_cache_t* cache) {
2769 if(cache) {
2770 opt->rep.row_cache = cache->rep;
2771 }
2772 }
2773
rocksdb_set_perf_level(int v)2774 void rocksdb_set_perf_level(int v) {
2775 PerfLevel level = static_cast<PerfLevel>(v);
2776 SetPerfLevel(level);
2777 }
2778
rocksdb_perfcontext_create()2779 rocksdb_perfcontext_t* rocksdb_perfcontext_create() {
2780 rocksdb_perfcontext_t* context = new rocksdb_perfcontext_t;
2781 context->rep = ROCKSDB_NAMESPACE::get_perf_context();
2782 return context;
2783 }
2784
rocksdb_perfcontext_reset(rocksdb_perfcontext_t * context)2785 void rocksdb_perfcontext_reset(rocksdb_perfcontext_t* context) {
2786 context->rep->Reset();
2787 }
2788
rocksdb_perfcontext_report(rocksdb_perfcontext_t * context,unsigned char exclude_zero_counters)2789 char* rocksdb_perfcontext_report(rocksdb_perfcontext_t* context,
2790 unsigned char exclude_zero_counters) {
2791 return strdup(context->rep->ToString(exclude_zero_counters).c_str());
2792 }
2793
rocksdb_perfcontext_metric(rocksdb_perfcontext_t * context,int metric)2794 uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context,
2795 int metric) {
2796 PerfContext* rep = context->rep;
2797 switch (metric) {
2798 case rocksdb_user_key_comparison_count:
2799 return rep->user_key_comparison_count;
2800 case rocksdb_block_cache_hit_count:
2801 return rep->block_cache_hit_count;
2802 case rocksdb_block_read_count:
2803 return rep->block_read_count;
2804 case rocksdb_block_read_byte:
2805 return rep->block_read_byte;
2806 case rocksdb_block_read_time:
2807 return rep->block_read_time;
2808 case rocksdb_block_checksum_time:
2809 return rep->block_checksum_time;
2810 case rocksdb_block_decompress_time:
2811 return rep->block_decompress_time;
2812 case rocksdb_get_read_bytes:
2813 return rep->get_read_bytes;
2814 case rocksdb_multiget_read_bytes:
2815 return rep->multiget_read_bytes;
2816 case rocksdb_iter_read_bytes:
2817 return rep->iter_read_bytes;
2818 case rocksdb_internal_key_skipped_count:
2819 return rep->internal_key_skipped_count;
2820 case rocksdb_internal_delete_skipped_count:
2821 return rep->internal_delete_skipped_count;
2822 case rocksdb_internal_recent_skipped_count:
2823 return rep->internal_recent_skipped_count;
2824 case rocksdb_internal_merge_count:
2825 return rep->internal_merge_count;
2826 case rocksdb_get_snapshot_time:
2827 return rep->get_snapshot_time;
2828 case rocksdb_get_from_memtable_time:
2829 return rep->get_from_memtable_time;
2830 case rocksdb_get_from_memtable_count:
2831 return rep->get_from_memtable_count;
2832 case rocksdb_get_post_process_time:
2833 return rep->get_post_process_time;
2834 case rocksdb_get_from_output_files_time:
2835 return rep->get_from_output_files_time;
2836 case rocksdb_seek_on_memtable_time:
2837 return rep->seek_on_memtable_time;
2838 case rocksdb_seek_on_memtable_count:
2839 return rep->seek_on_memtable_count;
2840 case rocksdb_next_on_memtable_count:
2841 return rep->next_on_memtable_count;
2842 case rocksdb_prev_on_memtable_count:
2843 return rep->prev_on_memtable_count;
2844 case rocksdb_seek_child_seek_time:
2845 return rep->seek_child_seek_time;
2846 case rocksdb_seek_child_seek_count:
2847 return rep->seek_child_seek_count;
2848 case rocksdb_seek_min_heap_time:
2849 return rep->seek_min_heap_time;
2850 case rocksdb_seek_max_heap_time:
2851 return rep->seek_max_heap_time;
2852 case rocksdb_seek_internal_seek_time:
2853 return rep->seek_internal_seek_time;
2854 case rocksdb_find_next_user_entry_time:
2855 return rep->find_next_user_entry_time;
2856 case rocksdb_write_wal_time:
2857 return rep->write_wal_time;
2858 case rocksdb_write_memtable_time:
2859 return rep->write_memtable_time;
2860 case rocksdb_write_delay_time:
2861 return rep->write_delay_time;
2862 case rocksdb_write_pre_and_post_process_time:
2863 return rep->write_pre_and_post_process_time;
2864 case rocksdb_db_mutex_lock_nanos:
2865 return rep->db_mutex_lock_nanos;
2866 case rocksdb_db_condition_wait_nanos:
2867 return rep->db_condition_wait_nanos;
2868 case rocksdb_merge_operator_time_nanos:
2869 return rep->merge_operator_time_nanos;
2870 case rocksdb_read_index_block_nanos:
2871 return rep->read_index_block_nanos;
2872 case rocksdb_read_filter_block_nanos:
2873 return rep->read_filter_block_nanos;
2874 case rocksdb_new_table_block_iter_nanos:
2875 return rep->new_table_block_iter_nanos;
2876 case rocksdb_new_table_iterator_nanos:
2877 return rep->new_table_iterator_nanos;
2878 case rocksdb_block_seek_nanos:
2879 return rep->block_seek_nanos;
2880 case rocksdb_find_table_nanos:
2881 return rep->find_table_nanos;
2882 case rocksdb_bloom_memtable_hit_count:
2883 return rep->bloom_memtable_hit_count;
2884 case rocksdb_bloom_memtable_miss_count:
2885 return rep->bloom_memtable_miss_count;
2886 case rocksdb_bloom_sst_hit_count:
2887 return rep->bloom_sst_hit_count;
2888 case rocksdb_bloom_sst_miss_count:
2889 return rep->bloom_sst_miss_count;
2890 case rocksdb_key_lock_wait_time:
2891 return rep->key_lock_wait_time;
2892 case rocksdb_key_lock_wait_count:
2893 return rep->key_lock_wait_count;
2894 case rocksdb_env_new_sequential_file_nanos:
2895 return rep->env_new_sequential_file_nanos;
2896 case rocksdb_env_new_random_access_file_nanos:
2897 return rep->env_new_random_access_file_nanos;
2898 case rocksdb_env_new_writable_file_nanos:
2899 return rep->env_new_writable_file_nanos;
2900 case rocksdb_env_reuse_writable_file_nanos:
2901 return rep->env_reuse_writable_file_nanos;
2902 case rocksdb_env_new_random_rw_file_nanos:
2903 return rep->env_new_random_rw_file_nanos;
2904 case rocksdb_env_new_directory_nanos:
2905 return rep->env_new_directory_nanos;
2906 case rocksdb_env_file_exists_nanos:
2907 return rep->env_file_exists_nanos;
2908 case rocksdb_env_get_children_nanos:
2909 return rep->env_get_children_nanos;
2910 case rocksdb_env_get_children_file_attributes_nanos:
2911 return rep->env_get_children_file_attributes_nanos;
2912 case rocksdb_env_delete_file_nanos:
2913 return rep->env_delete_file_nanos;
2914 case rocksdb_env_create_dir_nanos:
2915 return rep->env_create_dir_nanos;
2916 case rocksdb_env_create_dir_if_missing_nanos:
2917 return rep->env_create_dir_if_missing_nanos;
2918 case rocksdb_env_delete_dir_nanos:
2919 return rep->env_delete_dir_nanos;
2920 case rocksdb_env_get_file_size_nanos:
2921 return rep->env_get_file_size_nanos;
2922 case rocksdb_env_get_file_modification_time_nanos:
2923 return rep->env_get_file_modification_time_nanos;
2924 case rocksdb_env_rename_file_nanos:
2925 return rep->env_rename_file_nanos;
2926 case rocksdb_env_link_file_nanos:
2927 return rep->env_link_file_nanos;
2928 case rocksdb_env_lock_file_nanos:
2929 return rep->env_lock_file_nanos;
2930 case rocksdb_env_unlock_file_nanos:
2931 return rep->env_unlock_file_nanos;
2932 case rocksdb_env_new_logger_nanos:
2933 return rep->env_new_logger_nanos;
2934 default:
2935 break;
2936 }
2937 return 0;
2938 }
2939
rocksdb_perfcontext_destroy(rocksdb_perfcontext_t * context)2940 void rocksdb_perfcontext_destroy(rocksdb_perfcontext_t* context) {
2941 delete context;
2942 }
2943
2944 /*
2945 TODO:
2946 DB::OpenForReadOnly
2947 DB::KeyMayExist
2948 DB::GetOptions
2949 DB::GetSortedWalFiles
2950 DB::GetLatestSequenceNumber
2951 DB::GetUpdatesSince
2952 DB::GetDbIdentity
2953 DB::RunManualCompaction
2954 custom cache
2955 table_properties_collectors
2956 */
2957
rocksdb_compactionfilter_create(void * state,void (* destructor)(void *),unsigned char (* filter)(void *,int level,const char * key,size_t key_length,const char * existing_value,size_t value_length,char ** new_value,size_t * new_value_length,unsigned char * value_changed),const char * (* name)(void *))2958 rocksdb_compactionfilter_t* rocksdb_compactionfilter_create(
2959 void* state,
2960 void (*destructor)(void*),
2961 unsigned char (*filter)(
2962 void*,
2963 int level,
2964 const char* key, size_t key_length,
2965 const char* existing_value, size_t value_length,
2966 char** new_value, size_t *new_value_length,
2967 unsigned char* value_changed),
2968 const char* (*name)(void*)) {
2969 rocksdb_compactionfilter_t* result = new rocksdb_compactionfilter_t;
2970 result->state_ = state;
2971 result->destructor_ = destructor;
2972 result->filter_ = filter;
2973 result->ignore_snapshots_ = true;
2974 result->name_ = name;
2975 return result;
2976 }
2977
rocksdb_compactionfilter_set_ignore_snapshots(rocksdb_compactionfilter_t * filter,unsigned char whether_ignore)2978 void rocksdb_compactionfilter_set_ignore_snapshots(
2979 rocksdb_compactionfilter_t* filter,
2980 unsigned char whether_ignore) {
2981 filter->ignore_snapshots_ = whether_ignore;
2982 }
2983
rocksdb_compactionfilter_destroy(rocksdb_compactionfilter_t * filter)2984 void rocksdb_compactionfilter_destroy(rocksdb_compactionfilter_t* filter) {
2985 delete filter;
2986 }
2987
rocksdb_compactionfiltercontext_is_full_compaction(rocksdb_compactionfiltercontext_t * context)2988 unsigned char rocksdb_compactionfiltercontext_is_full_compaction(
2989 rocksdb_compactionfiltercontext_t* context) {
2990 return context->rep.is_full_compaction;
2991 }
2992
rocksdb_compactionfiltercontext_is_manual_compaction(rocksdb_compactionfiltercontext_t * context)2993 unsigned char rocksdb_compactionfiltercontext_is_manual_compaction(
2994 rocksdb_compactionfiltercontext_t* context) {
2995 return context->rep.is_manual_compaction;
2996 }
2997
rocksdb_compactionfilterfactory_create(void * state,void (* destructor)(void *),rocksdb_compactionfilter_t * (* create_compaction_filter)(void *,rocksdb_compactionfiltercontext_t * context),const char * (* name)(void *))2998 rocksdb_compactionfilterfactory_t* rocksdb_compactionfilterfactory_create(
2999 void* state, void (*destructor)(void*),
3000 rocksdb_compactionfilter_t* (*create_compaction_filter)(
3001 void*, rocksdb_compactionfiltercontext_t* context),
3002 const char* (*name)(void*)) {
3003 rocksdb_compactionfilterfactory_t* result =
3004 new rocksdb_compactionfilterfactory_t;
3005 result->state_ = state;
3006 result->destructor_ = destructor;
3007 result->create_compaction_filter_ = create_compaction_filter;
3008 result->name_ = name;
3009 return result;
3010 }
3011
rocksdb_compactionfilterfactory_destroy(rocksdb_compactionfilterfactory_t * factory)3012 void rocksdb_compactionfilterfactory_destroy(
3013 rocksdb_compactionfilterfactory_t* factory) {
3014 delete factory;
3015 }
3016
rocksdb_comparator_create(void * state,void (* destructor)(void *),int (* compare)(void *,const char * a,size_t alen,const char * b,size_t blen),const char * (* name)(void *))3017 rocksdb_comparator_t* rocksdb_comparator_create(
3018 void* state,
3019 void (*destructor)(void*),
3020 int (*compare)(
3021 void*,
3022 const char* a, size_t alen,
3023 const char* b, size_t blen),
3024 const char* (*name)(void*)) {
3025 rocksdb_comparator_t* result = new rocksdb_comparator_t;
3026 result->state_ = state;
3027 result->destructor_ = destructor;
3028 result->compare_ = compare;
3029 result->name_ = name;
3030 return result;
3031 }
3032
rocksdb_comparator_destroy(rocksdb_comparator_t * cmp)3033 void rocksdb_comparator_destroy(rocksdb_comparator_t* cmp) {
3034 delete cmp;
3035 }
3036
rocksdb_filterpolicy_create(void * state,void (* destructor)(void *),char * (* create_filter)(void *,const char * const * key_array,const size_t * key_length_array,int num_keys,size_t * filter_length),unsigned char (* key_may_match)(void *,const char * key,size_t length,const char * filter,size_t filter_length),void (* delete_filter)(void *,const char * filter,size_t filter_length),const char * (* name)(void *))3037 rocksdb_filterpolicy_t* rocksdb_filterpolicy_create(
3038 void* state,
3039 void (*destructor)(void*),
3040 char* (*create_filter)(
3041 void*,
3042 const char* const* key_array, const size_t* key_length_array,
3043 int num_keys,
3044 size_t* filter_length),
3045 unsigned char (*key_may_match)(
3046 void*,
3047 const char* key, size_t length,
3048 const char* filter, size_t filter_length),
3049 void (*delete_filter)(
3050 void*,
3051 const char* filter, size_t filter_length),
3052 const char* (*name)(void*)) {
3053 rocksdb_filterpolicy_t* result = new rocksdb_filterpolicy_t;
3054 result->state_ = state;
3055 result->destructor_ = destructor;
3056 result->create_ = create_filter;
3057 result->key_match_ = key_may_match;
3058 result->delete_filter_ = delete_filter;
3059 result->name_ = name;
3060 return result;
3061 }
3062
rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t * filter)3063 void rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t* filter) {
3064 delete filter;
3065 }
3066
rocksdb_filterpolicy_create_bloom_format(int bits_per_key,bool original_format)3067 rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_format(int bits_per_key, bool original_format) {
3068 // Make a rocksdb_filterpolicy_t, but override all of its methods so
3069 // they delegate to a NewBloomFilterPolicy() instead of user
3070 // supplied C functions.
3071 struct Wrapper : public rocksdb_filterpolicy_t {
3072 const FilterPolicy* rep_;
3073 ~Wrapper() override { delete rep_; }
3074 const char* Name() const override { return rep_->Name(); }
3075 void CreateFilter(const Slice* keys, int n,
3076 std::string* dst) const override {
3077 return rep_->CreateFilter(keys, n, dst);
3078 }
3079 bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
3080 return rep_->KeyMayMatch(key, filter);
3081 }
3082 // No need to override GetFilterBitsBuilder if this one is overridden
3083 ROCKSDB_NAMESPACE::FilterBitsBuilder* GetBuilderWithContext(
3084 const ROCKSDB_NAMESPACE::FilterBuildingContext& context)
3085 const override {
3086 return rep_->GetBuilderWithContext(context);
3087 }
3088 ROCKSDB_NAMESPACE::FilterBitsReader* GetFilterBitsReader(
3089 const Slice& contents) const override {
3090 return rep_->GetFilterBitsReader(contents);
3091 }
3092 static void DoNothing(void*) {}
3093 };
3094 Wrapper* wrapper = new Wrapper;
3095 wrapper->rep_ = NewBloomFilterPolicy(bits_per_key, original_format);
3096 wrapper->state_ = nullptr;
3097 wrapper->delete_filter_ = nullptr;
3098 wrapper->destructor_ = &Wrapper::DoNothing;
3099 return wrapper;
3100 }
3101
rocksdb_filterpolicy_create_bloom_full(int bits_per_key)3102 rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_full(int bits_per_key) {
3103 return rocksdb_filterpolicy_create_bloom_format(bits_per_key, false);
3104 }
3105
rocksdb_filterpolicy_create_bloom(int bits_per_key)3106 rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom(int bits_per_key) {
3107 return rocksdb_filterpolicy_create_bloom_format(bits_per_key, true);
3108 }
3109
rocksdb_mergeoperator_create(void * state,void (* destructor)(void *),char * (* full_merge)(void *,const char * key,size_t key_length,const char * existing_value,size_t existing_value_length,const char * const * operands_list,const size_t * operands_list_length,int num_operands,unsigned char * success,size_t * new_value_length),char * (* partial_merge)(void *,const char * key,size_t key_length,const char * const * operands_list,const size_t * operands_list_length,int num_operands,unsigned char * success,size_t * new_value_length),void (* delete_value)(void *,const char * value,size_t value_length),const char * (* name)(void *))3110 rocksdb_mergeoperator_t* rocksdb_mergeoperator_create(
3111 void* state, void (*destructor)(void*),
3112 char* (*full_merge)(void*, const char* key, size_t key_length,
3113 const char* existing_value,
3114 size_t existing_value_length,
3115 const char* const* operands_list,
3116 const size_t* operands_list_length, int num_operands,
3117 unsigned char* success, size_t* new_value_length),
3118 char* (*partial_merge)(void*, const char* key, size_t key_length,
3119 const char* const* operands_list,
3120 const size_t* operands_list_length, int num_operands,
3121 unsigned char* success, size_t* new_value_length),
3122 void (*delete_value)(void*, const char* value, size_t value_length),
3123 const char* (*name)(void*)) {
3124 rocksdb_mergeoperator_t* result = new rocksdb_mergeoperator_t;
3125 result->state_ = state;
3126 result->destructor_ = destructor;
3127 result->full_merge_ = full_merge;
3128 result->partial_merge_ = partial_merge;
3129 result->delete_value_ = delete_value;
3130 result->name_ = name;
3131 return result;
3132 }
3133
rocksdb_mergeoperator_destroy(rocksdb_mergeoperator_t * merge_operator)3134 void rocksdb_mergeoperator_destroy(rocksdb_mergeoperator_t* merge_operator) {
3135 delete merge_operator;
3136 }
3137
rocksdb_readoptions_create()3138 rocksdb_readoptions_t* rocksdb_readoptions_create() {
3139 return new rocksdb_readoptions_t;
3140 }
3141
rocksdb_readoptions_destroy(rocksdb_readoptions_t * opt)3142 void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) {
3143 delete opt;
3144 }
3145
rocksdb_readoptions_set_verify_checksums(rocksdb_readoptions_t * opt,unsigned char v)3146 void rocksdb_readoptions_set_verify_checksums(
3147 rocksdb_readoptions_t* opt,
3148 unsigned char v) {
3149 opt->rep.verify_checksums = v;
3150 }
3151
rocksdb_readoptions_set_fill_cache(rocksdb_readoptions_t * opt,unsigned char v)3152 void rocksdb_readoptions_set_fill_cache(
3153 rocksdb_readoptions_t* opt, unsigned char v) {
3154 opt->rep.fill_cache = v;
3155 }
3156
rocksdb_readoptions_set_snapshot(rocksdb_readoptions_t * opt,const rocksdb_snapshot_t * snap)3157 void rocksdb_readoptions_set_snapshot(
3158 rocksdb_readoptions_t* opt,
3159 const rocksdb_snapshot_t* snap) {
3160 opt->rep.snapshot = (snap ? snap->rep : nullptr);
3161 }
3162
rocksdb_readoptions_set_iterate_upper_bound(rocksdb_readoptions_t * opt,const char * key,size_t keylen)3163 void rocksdb_readoptions_set_iterate_upper_bound(
3164 rocksdb_readoptions_t* opt,
3165 const char* key, size_t keylen) {
3166 if (key == nullptr) {
3167 opt->upper_bound = Slice();
3168 opt->rep.iterate_upper_bound = nullptr;
3169
3170 } else {
3171 opt->upper_bound = Slice(key, keylen);
3172 opt->rep.iterate_upper_bound = &opt->upper_bound;
3173 }
3174 }
3175
rocksdb_readoptions_set_iterate_lower_bound(rocksdb_readoptions_t * opt,const char * key,size_t keylen)3176 void rocksdb_readoptions_set_iterate_lower_bound(
3177 rocksdb_readoptions_t *opt,
3178 const char* key, size_t keylen) {
3179 if (key == nullptr) {
3180 opt->lower_bound = Slice();
3181 opt->rep.iterate_lower_bound = nullptr;
3182 } else {
3183 opt->lower_bound = Slice(key, keylen);
3184 opt->rep.iterate_lower_bound = &opt->lower_bound;
3185 }
3186 }
3187
rocksdb_readoptions_set_read_tier(rocksdb_readoptions_t * opt,int v)3188 void rocksdb_readoptions_set_read_tier(
3189 rocksdb_readoptions_t* opt, int v) {
3190 opt->rep.read_tier = static_cast<ROCKSDB_NAMESPACE::ReadTier>(v);
3191 }
3192
rocksdb_readoptions_set_tailing(rocksdb_readoptions_t * opt,unsigned char v)3193 void rocksdb_readoptions_set_tailing(
3194 rocksdb_readoptions_t* opt, unsigned char v) {
3195 opt->rep.tailing = v;
3196 }
3197
rocksdb_readoptions_set_managed(rocksdb_readoptions_t * opt,unsigned char v)3198 void rocksdb_readoptions_set_managed(
3199 rocksdb_readoptions_t* opt, unsigned char v) {
3200 opt->rep.managed = v;
3201 }
3202
rocksdb_readoptions_set_readahead_size(rocksdb_readoptions_t * opt,size_t v)3203 void rocksdb_readoptions_set_readahead_size(
3204 rocksdb_readoptions_t* opt, size_t v) {
3205 opt->rep.readahead_size = v;
3206 }
3207
rocksdb_readoptions_set_prefix_same_as_start(rocksdb_readoptions_t * opt,unsigned char v)3208 void rocksdb_readoptions_set_prefix_same_as_start(
3209 rocksdb_readoptions_t* opt, unsigned char v) {
3210 opt->rep.prefix_same_as_start = v;
3211 }
3212
rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t * opt,unsigned char v)3213 void rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t* opt,
3214 unsigned char v) {
3215 opt->rep.pin_data = v;
3216 }
3217
rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t * opt,unsigned char v)3218 void rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t* opt,
3219 unsigned char v) {
3220 opt->rep.total_order_seek = v;
3221 }
3222
rocksdb_readoptions_set_max_skippable_internal_keys(rocksdb_readoptions_t * opt,uint64_t v)3223 void rocksdb_readoptions_set_max_skippable_internal_keys(
3224 rocksdb_readoptions_t* opt,
3225 uint64_t v) {
3226 opt->rep.max_skippable_internal_keys = v;
3227 }
3228
rocksdb_readoptions_set_background_purge_on_iterator_cleanup(rocksdb_readoptions_t * opt,unsigned char v)3229 void rocksdb_readoptions_set_background_purge_on_iterator_cleanup(
3230 rocksdb_readoptions_t* opt, unsigned char v) {
3231 opt->rep.background_purge_on_iterator_cleanup = v;
3232 }
3233
rocksdb_readoptions_set_ignore_range_deletions(rocksdb_readoptions_t * opt,unsigned char v)3234 void rocksdb_readoptions_set_ignore_range_deletions(
3235 rocksdb_readoptions_t* opt, unsigned char v) {
3236 opt->rep.ignore_range_deletions = v;
3237 }
3238
rocksdb_writeoptions_create()3239 rocksdb_writeoptions_t* rocksdb_writeoptions_create() {
3240 return new rocksdb_writeoptions_t;
3241 }
3242
rocksdb_writeoptions_destroy(rocksdb_writeoptions_t * opt)3243 void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* opt) {
3244 delete opt;
3245 }
3246
rocksdb_writeoptions_set_sync(rocksdb_writeoptions_t * opt,unsigned char v)3247 void rocksdb_writeoptions_set_sync(
3248 rocksdb_writeoptions_t* opt, unsigned char v) {
3249 opt->rep.sync = v;
3250 }
3251
rocksdb_writeoptions_disable_WAL(rocksdb_writeoptions_t * opt,int disable)3252 void rocksdb_writeoptions_disable_WAL(rocksdb_writeoptions_t* opt, int disable) {
3253 opt->rep.disableWAL = disable;
3254 }
3255
rocksdb_writeoptions_set_ignore_missing_column_families(rocksdb_writeoptions_t * opt,unsigned char v)3256 void rocksdb_writeoptions_set_ignore_missing_column_families(
3257 rocksdb_writeoptions_t* opt,
3258 unsigned char v) {
3259 opt->rep.ignore_missing_column_families = v;
3260 }
3261
rocksdb_writeoptions_set_no_slowdown(rocksdb_writeoptions_t * opt,unsigned char v)3262 void rocksdb_writeoptions_set_no_slowdown(
3263 rocksdb_writeoptions_t* opt,
3264 unsigned char v) {
3265 opt->rep.no_slowdown = v;
3266 }
3267
rocksdb_writeoptions_set_low_pri(rocksdb_writeoptions_t * opt,unsigned char v)3268 void rocksdb_writeoptions_set_low_pri(
3269 rocksdb_writeoptions_t* opt,
3270 unsigned char v) {
3271 opt->rep.low_pri = v;
3272 }
3273
rocksdb_writeoptions_set_memtable_insert_hint_per_batch(rocksdb_writeoptions_t * opt,unsigned char v)3274 void rocksdb_writeoptions_set_memtable_insert_hint_per_batch(
3275 rocksdb_writeoptions_t* opt, unsigned char v) {
3276 opt->rep.memtable_insert_hint_per_batch = v;
3277 }
3278
rocksdb_compactoptions_create()3279 rocksdb_compactoptions_t* rocksdb_compactoptions_create() {
3280 return new rocksdb_compactoptions_t;
3281 }
3282
rocksdb_compactoptions_destroy(rocksdb_compactoptions_t * opt)3283 void rocksdb_compactoptions_destroy(rocksdb_compactoptions_t* opt) {
3284 delete opt;
3285 }
3286
rocksdb_compactoptions_set_bottommost_level_compaction(rocksdb_compactoptions_t * opt,unsigned char v)3287 void rocksdb_compactoptions_set_bottommost_level_compaction(
3288 rocksdb_compactoptions_t* opt, unsigned char v) {
3289 opt->rep.bottommost_level_compaction = static_cast<BottommostLevelCompaction>(v);
3290 }
3291
rocksdb_compactoptions_set_exclusive_manual_compaction(rocksdb_compactoptions_t * opt,unsigned char v)3292 void rocksdb_compactoptions_set_exclusive_manual_compaction(
3293 rocksdb_compactoptions_t* opt, unsigned char v) {
3294 opt->rep.exclusive_manual_compaction = v;
3295 }
3296
rocksdb_compactoptions_set_change_level(rocksdb_compactoptions_t * opt,unsigned char v)3297 void rocksdb_compactoptions_set_change_level(rocksdb_compactoptions_t* opt,
3298 unsigned char v) {
3299 opt->rep.change_level = v;
3300 }
3301
rocksdb_compactoptions_set_target_level(rocksdb_compactoptions_t * opt,int n)3302 void rocksdb_compactoptions_set_target_level(rocksdb_compactoptions_t* opt,
3303 int n) {
3304 opt->rep.target_level = n;
3305 }
3306
rocksdb_flushoptions_create()3307 rocksdb_flushoptions_t* rocksdb_flushoptions_create() {
3308 return new rocksdb_flushoptions_t;
3309 }
3310
rocksdb_flushoptions_destroy(rocksdb_flushoptions_t * opt)3311 void rocksdb_flushoptions_destroy(rocksdb_flushoptions_t* opt) {
3312 delete opt;
3313 }
3314
rocksdb_flushoptions_set_wait(rocksdb_flushoptions_t * opt,unsigned char v)3315 void rocksdb_flushoptions_set_wait(
3316 rocksdb_flushoptions_t* opt, unsigned char v) {
3317 opt->rep.wait = v;
3318 }
3319
rocksdb_cache_create_lru(size_t capacity)3320 rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity) {
3321 rocksdb_cache_t* c = new rocksdb_cache_t;
3322 c->rep = NewLRUCache(capacity);
3323 return c;
3324 }
3325
rocksdb_cache_destroy(rocksdb_cache_t * cache)3326 void rocksdb_cache_destroy(rocksdb_cache_t* cache) {
3327 delete cache;
3328 }
3329
rocksdb_cache_set_capacity(rocksdb_cache_t * cache,size_t capacity)3330 void rocksdb_cache_set_capacity(rocksdb_cache_t* cache, size_t capacity) {
3331 cache->rep->SetCapacity(capacity);
3332 }
3333
rocksdb_cache_get_usage(rocksdb_cache_t * cache)3334 size_t rocksdb_cache_get_usage(rocksdb_cache_t* cache) {
3335 return cache->rep->GetUsage();
3336 }
3337
rocksdb_cache_get_pinned_usage(rocksdb_cache_t * cache)3338 size_t rocksdb_cache_get_pinned_usage(rocksdb_cache_t* cache) {
3339 return cache->rep->GetPinnedUsage();
3340 }
3341
rocksdb_dbpath_create(const char * path,uint64_t target_size)3342 rocksdb_dbpath_t* rocksdb_dbpath_create(const char* path, uint64_t target_size) {
3343 rocksdb_dbpath_t* result = new rocksdb_dbpath_t;
3344 result->rep.path = std::string(path);
3345 result->rep.target_size = target_size;
3346 return result;
3347 }
3348
rocksdb_dbpath_destroy(rocksdb_dbpath_t * dbpath)3349 void rocksdb_dbpath_destroy(rocksdb_dbpath_t* dbpath) {
3350 delete dbpath;
3351 }
3352
rocksdb_create_default_env()3353 rocksdb_env_t* rocksdb_create_default_env() {
3354 rocksdb_env_t* result = new rocksdb_env_t;
3355 result->rep = Env::Default();
3356 result->is_default = true;
3357 return result;
3358 }
3359
rocksdb_create_mem_env()3360 rocksdb_env_t* rocksdb_create_mem_env() {
3361 rocksdb_env_t* result = new rocksdb_env_t;
3362 result->rep = ROCKSDB_NAMESPACE::NewMemEnv(Env::Default());
3363 result->is_default = false;
3364 return result;
3365 }
3366
rocksdb_env_set_background_threads(rocksdb_env_t * env,int n)3367 void rocksdb_env_set_background_threads(rocksdb_env_t* env, int n) {
3368 env->rep->SetBackgroundThreads(n);
3369 }
3370
rocksdb_env_set_high_priority_background_threads(rocksdb_env_t * env,int n)3371 void rocksdb_env_set_high_priority_background_threads(rocksdb_env_t* env, int n) {
3372 env->rep->SetBackgroundThreads(n, Env::HIGH);
3373 }
3374
rocksdb_env_join_all_threads(rocksdb_env_t * env)3375 void rocksdb_env_join_all_threads(rocksdb_env_t* env) {
3376 env->rep->WaitForJoin();
3377 }
3378
rocksdb_env_lower_thread_pool_io_priority(rocksdb_env_t * env)3379 void rocksdb_env_lower_thread_pool_io_priority(rocksdb_env_t* env) {
3380 env->rep->LowerThreadPoolIOPriority();
3381 }
3382
rocksdb_env_lower_high_priority_thread_pool_io_priority(rocksdb_env_t * env)3383 void rocksdb_env_lower_high_priority_thread_pool_io_priority(rocksdb_env_t* env) {
3384 env->rep->LowerThreadPoolIOPriority(Env::HIGH);
3385 }
3386
rocksdb_env_lower_thread_pool_cpu_priority(rocksdb_env_t * env)3387 void rocksdb_env_lower_thread_pool_cpu_priority(rocksdb_env_t* env) {
3388 env->rep->LowerThreadPoolCPUPriority();
3389 }
3390
rocksdb_env_lower_high_priority_thread_pool_cpu_priority(rocksdb_env_t * env)3391 void rocksdb_env_lower_high_priority_thread_pool_cpu_priority(rocksdb_env_t* env) {
3392 env->rep->LowerThreadPoolCPUPriority(Env::HIGH);
3393 }
3394
rocksdb_env_destroy(rocksdb_env_t * env)3395 void rocksdb_env_destroy(rocksdb_env_t* env) {
3396 if (!env->is_default) delete env->rep;
3397 delete env;
3398 }
3399
rocksdb_envoptions_create()3400 rocksdb_envoptions_t* rocksdb_envoptions_create() {
3401 rocksdb_envoptions_t* opt = new rocksdb_envoptions_t;
3402 return opt;
3403 }
3404
rocksdb_envoptions_destroy(rocksdb_envoptions_t * opt)3405 void rocksdb_envoptions_destroy(rocksdb_envoptions_t* opt) { delete opt; }
3406
rocksdb_sstfilewriter_create(const rocksdb_envoptions_t * env,const rocksdb_options_t * io_options)3407 rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create(
3408 const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options) {
3409 rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t;
3410 writer->rep = new SstFileWriter(env->rep, io_options->rep);
3411 return writer;
3412 }
3413
rocksdb_sstfilewriter_create_with_comparator(const rocksdb_envoptions_t * env,const rocksdb_options_t * io_options,const rocksdb_comparator_t *)3414 rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create_with_comparator(
3415 const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options,
3416 const rocksdb_comparator_t* /*comparator*/) {
3417 rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t;
3418 writer->rep = new SstFileWriter(env->rep, io_options->rep);
3419 return writer;
3420 }
3421
rocksdb_sstfilewriter_open(rocksdb_sstfilewriter_t * writer,const char * name,char ** errptr)3422 void rocksdb_sstfilewriter_open(rocksdb_sstfilewriter_t* writer,
3423 const char* name, char** errptr) {
3424 SaveError(errptr, writer->rep->Open(std::string(name)));
3425 }
3426
rocksdb_sstfilewriter_add(rocksdb_sstfilewriter_t * writer,const char * key,size_t keylen,const char * val,size_t vallen,char ** errptr)3427 void rocksdb_sstfilewriter_add(rocksdb_sstfilewriter_t* writer, const char* key,
3428 size_t keylen, const char* val, size_t vallen,
3429 char** errptr) {
3430 SaveError(errptr, writer->rep->Put(Slice(key, keylen), Slice(val, vallen)));
3431 }
3432
rocksdb_sstfilewriter_put(rocksdb_sstfilewriter_t * writer,const char * key,size_t keylen,const char * val,size_t vallen,char ** errptr)3433 void rocksdb_sstfilewriter_put(rocksdb_sstfilewriter_t* writer, const char* key,
3434 size_t keylen, const char* val, size_t vallen,
3435 char** errptr) {
3436 SaveError(errptr, writer->rep->Put(Slice(key, keylen), Slice(val, vallen)));
3437 }
3438
rocksdb_sstfilewriter_merge(rocksdb_sstfilewriter_t * writer,const char * key,size_t keylen,const char * val,size_t vallen,char ** errptr)3439 void rocksdb_sstfilewriter_merge(rocksdb_sstfilewriter_t* writer,
3440 const char* key, size_t keylen,
3441 const char* val, size_t vallen,
3442 char** errptr) {
3443 SaveError(errptr, writer->rep->Merge(Slice(key, keylen), Slice(val, vallen)));
3444 }
3445
rocksdb_sstfilewriter_delete(rocksdb_sstfilewriter_t * writer,const char * key,size_t keylen,char ** errptr)3446 void rocksdb_sstfilewriter_delete(rocksdb_sstfilewriter_t* writer,
3447 const char* key, size_t keylen,
3448 char** errptr) {
3449 SaveError(errptr, writer->rep->Delete(Slice(key, keylen)));
3450 }
3451
rocksdb_sstfilewriter_finish(rocksdb_sstfilewriter_t * writer,char ** errptr)3452 void rocksdb_sstfilewriter_finish(rocksdb_sstfilewriter_t* writer,
3453 char** errptr) {
3454 SaveError(errptr, writer->rep->Finish(nullptr));
3455 }
3456
rocksdb_sstfilewriter_file_size(rocksdb_sstfilewriter_t * writer,uint64_t * file_size)3457 void rocksdb_sstfilewriter_file_size(rocksdb_sstfilewriter_t* writer,
3458 uint64_t* file_size) {
3459 *file_size = writer->rep->FileSize();
3460 }
3461
rocksdb_sstfilewriter_destroy(rocksdb_sstfilewriter_t * writer)3462 void rocksdb_sstfilewriter_destroy(rocksdb_sstfilewriter_t* writer) {
3463 delete writer->rep;
3464 delete writer;
3465 }
3466
3467 rocksdb_ingestexternalfileoptions_t*
rocksdb_ingestexternalfileoptions_create()3468 rocksdb_ingestexternalfileoptions_create() {
3469 rocksdb_ingestexternalfileoptions_t* opt =
3470 new rocksdb_ingestexternalfileoptions_t;
3471 return opt;
3472 }
3473
rocksdb_ingestexternalfileoptions_set_move_files(rocksdb_ingestexternalfileoptions_t * opt,unsigned char move_files)3474 void rocksdb_ingestexternalfileoptions_set_move_files(
3475 rocksdb_ingestexternalfileoptions_t* opt, unsigned char move_files) {
3476 opt->rep.move_files = move_files;
3477 }
3478
rocksdb_ingestexternalfileoptions_set_snapshot_consistency(rocksdb_ingestexternalfileoptions_t * opt,unsigned char snapshot_consistency)3479 void rocksdb_ingestexternalfileoptions_set_snapshot_consistency(
3480 rocksdb_ingestexternalfileoptions_t* opt,
3481 unsigned char snapshot_consistency) {
3482 opt->rep.snapshot_consistency = snapshot_consistency;
3483 }
3484
rocksdb_ingestexternalfileoptions_set_allow_global_seqno(rocksdb_ingestexternalfileoptions_t * opt,unsigned char allow_global_seqno)3485 void rocksdb_ingestexternalfileoptions_set_allow_global_seqno(
3486 rocksdb_ingestexternalfileoptions_t* opt,
3487 unsigned char allow_global_seqno) {
3488 opt->rep.allow_global_seqno = allow_global_seqno;
3489 }
3490
rocksdb_ingestexternalfileoptions_set_allow_blocking_flush(rocksdb_ingestexternalfileoptions_t * opt,unsigned char allow_blocking_flush)3491 void rocksdb_ingestexternalfileoptions_set_allow_blocking_flush(
3492 rocksdb_ingestexternalfileoptions_t* opt,
3493 unsigned char allow_blocking_flush) {
3494 opt->rep.allow_blocking_flush = allow_blocking_flush;
3495 }
3496
rocksdb_ingestexternalfileoptions_set_ingest_behind(rocksdb_ingestexternalfileoptions_t * opt,unsigned char ingest_behind)3497 void rocksdb_ingestexternalfileoptions_set_ingest_behind(
3498 rocksdb_ingestexternalfileoptions_t* opt,
3499 unsigned char ingest_behind) {
3500 opt->rep.ingest_behind = ingest_behind;
3501 }
3502
rocksdb_ingestexternalfileoptions_destroy(rocksdb_ingestexternalfileoptions_t * opt)3503 void rocksdb_ingestexternalfileoptions_destroy(
3504 rocksdb_ingestexternalfileoptions_t* opt) {
3505 delete opt;
3506 }
3507
rocksdb_ingest_external_file(rocksdb_t * db,const char * const * file_list,const size_t list_len,const rocksdb_ingestexternalfileoptions_t * opt,char ** errptr)3508 void rocksdb_ingest_external_file(
3509 rocksdb_t* db, const char* const* file_list, const size_t list_len,
3510 const rocksdb_ingestexternalfileoptions_t* opt, char** errptr) {
3511 std::vector<std::string> files(list_len);
3512 for (size_t i = 0; i < list_len; ++i) {
3513 files[i] = std::string(file_list[i]);
3514 }
3515 SaveError(errptr, db->rep->IngestExternalFile(files, opt->rep));
3516 }
3517
rocksdb_ingest_external_file_cf(rocksdb_t * db,rocksdb_column_family_handle_t * handle,const char * const * file_list,const size_t list_len,const rocksdb_ingestexternalfileoptions_t * opt,char ** errptr)3518 void rocksdb_ingest_external_file_cf(
3519 rocksdb_t* db, rocksdb_column_family_handle_t* handle,
3520 const char* const* file_list, const size_t list_len,
3521 const rocksdb_ingestexternalfileoptions_t* opt, char** errptr) {
3522 std::vector<std::string> files(list_len);
3523 for (size_t i = 0; i < list_len; ++i) {
3524 files[i] = std::string(file_list[i]);
3525 }
3526 SaveError(errptr, db->rep->IngestExternalFile(handle->rep, files, opt->rep));
3527 }
3528
rocksdb_try_catch_up_with_primary(rocksdb_t * db,char ** errptr)3529 void rocksdb_try_catch_up_with_primary(rocksdb_t* db, char** errptr) {
3530 SaveError(errptr, db->rep->TryCatchUpWithPrimary());
3531 }
3532
rocksdb_slicetransform_create(void * state,void (* destructor)(void *),char * (* transform)(void *,const char * key,size_t length,size_t * dst_length),unsigned char (* in_domain)(void *,const char * key,size_t length),unsigned char (* in_range)(void *,const char * key,size_t length),const char * (* name)(void *))3533 rocksdb_slicetransform_t* rocksdb_slicetransform_create(
3534 void* state,
3535 void (*destructor)(void*),
3536 char* (*transform)(
3537 void*,
3538 const char* key, size_t length,
3539 size_t* dst_length),
3540 unsigned char (*in_domain)(
3541 void*,
3542 const char* key, size_t length),
3543 unsigned char (*in_range)(
3544 void*,
3545 const char* key, size_t length),
3546 const char* (*name)(void*)) {
3547 rocksdb_slicetransform_t* result = new rocksdb_slicetransform_t;
3548 result->state_ = state;
3549 result->destructor_ = destructor;
3550 result->transform_ = transform;
3551 result->in_domain_ = in_domain;
3552 result->in_range_ = in_range;
3553 result->name_ = name;
3554 return result;
3555 }
3556
rocksdb_slicetransform_destroy(rocksdb_slicetransform_t * st)3557 void rocksdb_slicetransform_destroy(rocksdb_slicetransform_t* st) {
3558 delete st;
3559 }
3560
3561 struct Wrapper : public rocksdb_slicetransform_t {
3562 const SliceTransform* rep_;
~WrapperWrapper3563 ~Wrapper() override { delete rep_; }
NameWrapper3564 const char* Name() const override { return rep_->Name(); }
TransformWrapper3565 Slice Transform(const Slice& src) const override {
3566 return rep_->Transform(src);
3567 }
InDomainWrapper3568 bool InDomain(const Slice& src) const override {
3569 return rep_->InDomain(src);
3570 }
InRangeWrapper3571 bool InRange(const Slice& src) const override { return rep_->InRange(src); }
DoNothingWrapper3572 static void DoNothing(void*) { }
3573 };
3574
rocksdb_slicetransform_create_fixed_prefix(size_t prefixLen)3575 rocksdb_slicetransform_t* rocksdb_slicetransform_create_fixed_prefix(size_t prefixLen) {
3576 Wrapper* wrapper = new Wrapper;
3577 wrapper->rep_ = ROCKSDB_NAMESPACE::NewFixedPrefixTransform(prefixLen);
3578 wrapper->state_ = nullptr;
3579 wrapper->destructor_ = &Wrapper::DoNothing;
3580 return wrapper;
3581 }
3582
rocksdb_slicetransform_create_noop()3583 rocksdb_slicetransform_t* rocksdb_slicetransform_create_noop() {
3584 Wrapper* wrapper = new Wrapper;
3585 wrapper->rep_ = ROCKSDB_NAMESPACE::NewNoopTransform();
3586 wrapper->state_ = nullptr;
3587 wrapper->destructor_ = &Wrapper::DoNothing;
3588 return wrapper;
3589 }
3590
rocksdb_universal_compaction_options_create()3591 rocksdb_universal_compaction_options_t* rocksdb_universal_compaction_options_create() {
3592 rocksdb_universal_compaction_options_t* result = new rocksdb_universal_compaction_options_t;
3593 result->rep = new ROCKSDB_NAMESPACE::CompactionOptionsUniversal;
3594 return result;
3595 }
3596
rocksdb_universal_compaction_options_set_size_ratio(rocksdb_universal_compaction_options_t * uco,int ratio)3597 void rocksdb_universal_compaction_options_set_size_ratio(
3598 rocksdb_universal_compaction_options_t* uco, int ratio) {
3599 uco->rep->size_ratio = ratio;
3600 }
3601
rocksdb_universal_compaction_options_set_min_merge_width(rocksdb_universal_compaction_options_t * uco,int w)3602 void rocksdb_universal_compaction_options_set_min_merge_width(
3603 rocksdb_universal_compaction_options_t* uco, int w) {
3604 uco->rep->min_merge_width = w;
3605 }
3606
rocksdb_universal_compaction_options_set_max_merge_width(rocksdb_universal_compaction_options_t * uco,int w)3607 void rocksdb_universal_compaction_options_set_max_merge_width(
3608 rocksdb_universal_compaction_options_t* uco, int w) {
3609 uco->rep->max_merge_width = w;
3610 }
3611
rocksdb_universal_compaction_options_set_max_size_amplification_percent(rocksdb_universal_compaction_options_t * uco,int p)3612 void rocksdb_universal_compaction_options_set_max_size_amplification_percent(
3613 rocksdb_universal_compaction_options_t* uco, int p) {
3614 uco->rep->max_size_amplification_percent = p;
3615 }
3616
rocksdb_universal_compaction_options_set_compression_size_percent(rocksdb_universal_compaction_options_t * uco,int p)3617 void rocksdb_universal_compaction_options_set_compression_size_percent(
3618 rocksdb_universal_compaction_options_t* uco, int p) {
3619 uco->rep->compression_size_percent = p;
3620 }
3621
rocksdb_universal_compaction_options_set_stop_style(rocksdb_universal_compaction_options_t * uco,int style)3622 void rocksdb_universal_compaction_options_set_stop_style(
3623 rocksdb_universal_compaction_options_t* uco, int style) {
3624 uco->rep->stop_style =
3625 static_cast<ROCKSDB_NAMESPACE::CompactionStopStyle>(style);
3626 }
3627
rocksdb_universal_compaction_options_destroy(rocksdb_universal_compaction_options_t * uco)3628 void rocksdb_universal_compaction_options_destroy(
3629 rocksdb_universal_compaction_options_t* uco) {
3630 delete uco->rep;
3631 delete uco;
3632 }
3633
rocksdb_fifo_compaction_options_create()3634 rocksdb_fifo_compaction_options_t* rocksdb_fifo_compaction_options_create() {
3635 rocksdb_fifo_compaction_options_t* result = new rocksdb_fifo_compaction_options_t;
3636 result->rep = CompactionOptionsFIFO();
3637 return result;
3638 }
3639
rocksdb_fifo_compaction_options_set_max_table_files_size(rocksdb_fifo_compaction_options_t * fifo_opts,uint64_t size)3640 void rocksdb_fifo_compaction_options_set_max_table_files_size(
3641 rocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size) {
3642 fifo_opts->rep.max_table_files_size = size;
3643 }
3644
rocksdb_fifo_compaction_options_destroy(rocksdb_fifo_compaction_options_t * fifo_opts)3645 void rocksdb_fifo_compaction_options_destroy(
3646 rocksdb_fifo_compaction_options_t* fifo_opts) {
3647 delete fifo_opts;
3648 }
3649
rocksdb_options_set_min_level_to_compress(rocksdb_options_t * opt,int level)3650 void rocksdb_options_set_min_level_to_compress(rocksdb_options_t* opt, int level) {
3651 if (level >= 0) {
3652 assert(level <= opt->rep.num_levels);
3653 opt->rep.compression_per_level.resize(opt->rep.num_levels);
3654 for (int i = 0; i < level; i++) {
3655 opt->rep.compression_per_level[i] = ROCKSDB_NAMESPACE::kNoCompression;
3656 }
3657 for (int i = level; i < opt->rep.num_levels; i++) {
3658 opt->rep.compression_per_level[i] = opt->rep.compression;
3659 }
3660 }
3661 }
3662
rocksdb_livefiles_count(const rocksdb_livefiles_t * lf)3663 int rocksdb_livefiles_count(
3664 const rocksdb_livefiles_t* lf) {
3665 return static_cast<int>(lf->rep.size());
3666 }
3667
rocksdb_livefiles_name(const rocksdb_livefiles_t * lf,int index)3668 const char* rocksdb_livefiles_name(
3669 const rocksdb_livefiles_t* lf,
3670 int index) {
3671 return lf->rep[index].name.c_str();
3672 }
3673
rocksdb_livefiles_level(const rocksdb_livefiles_t * lf,int index)3674 int rocksdb_livefiles_level(
3675 const rocksdb_livefiles_t* lf,
3676 int index) {
3677 return lf->rep[index].level;
3678 }
3679
rocksdb_livefiles_size(const rocksdb_livefiles_t * lf,int index)3680 size_t rocksdb_livefiles_size(
3681 const rocksdb_livefiles_t* lf,
3682 int index) {
3683 return lf->rep[index].size;
3684 }
3685
rocksdb_livefiles_smallestkey(const rocksdb_livefiles_t * lf,int index,size_t * size)3686 const char* rocksdb_livefiles_smallestkey(
3687 const rocksdb_livefiles_t* lf,
3688 int index,
3689 size_t* size) {
3690 *size = lf->rep[index].smallestkey.size();
3691 return lf->rep[index].smallestkey.data();
3692 }
3693
rocksdb_livefiles_largestkey(const rocksdb_livefiles_t * lf,int index,size_t * size)3694 const char* rocksdb_livefiles_largestkey(
3695 const rocksdb_livefiles_t* lf,
3696 int index,
3697 size_t* size) {
3698 *size = lf->rep[index].largestkey.size();
3699 return lf->rep[index].largestkey.data();
3700 }
3701
rocksdb_livefiles_entries(const rocksdb_livefiles_t * lf,int index)3702 uint64_t rocksdb_livefiles_entries(
3703 const rocksdb_livefiles_t* lf,
3704 int index) {
3705 return lf->rep[index].num_entries;
3706 }
3707
rocksdb_livefiles_deletions(const rocksdb_livefiles_t * lf,int index)3708 uint64_t rocksdb_livefiles_deletions(
3709 const rocksdb_livefiles_t* lf,
3710 int index) {
3711 return lf->rep[index].num_deletions;
3712 }
3713
rocksdb_livefiles_destroy(const rocksdb_livefiles_t * lf)3714 extern void rocksdb_livefiles_destroy(
3715 const rocksdb_livefiles_t* lf) {
3716 delete lf;
3717 }
3718
rocksdb_get_options_from_string(const rocksdb_options_t * base_options,const char * opts_str,rocksdb_options_t * new_options,char ** errptr)3719 void rocksdb_get_options_from_string(const rocksdb_options_t* base_options,
3720 const char* opts_str,
3721 rocksdb_options_t* new_options,
3722 char** errptr) {
3723 SaveError(errptr,
3724 GetOptionsFromString(base_options->rep, std::string(opts_str),
3725 &new_options->rep));
3726 }
3727
rocksdb_delete_file_in_range(rocksdb_t * db,const char * start_key,size_t start_key_len,const char * limit_key,size_t limit_key_len,char ** errptr)3728 void rocksdb_delete_file_in_range(rocksdb_t* db, const char* start_key,
3729 size_t start_key_len, const char* limit_key,
3730 size_t limit_key_len, char** errptr) {
3731 Slice a, b;
3732 SaveError(
3733 errptr,
3734 DeleteFilesInRange(
3735 db->rep, db->rep->DefaultColumnFamily(),
3736 (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
3737 (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)));
3738 }
3739
rocksdb_delete_file_in_range_cf(rocksdb_t * db,rocksdb_column_family_handle_t * column_family,const char * start_key,size_t start_key_len,const char * limit_key,size_t limit_key_len,char ** errptr)3740 void rocksdb_delete_file_in_range_cf(
3741 rocksdb_t* db, rocksdb_column_family_handle_t* column_family,
3742 const char* start_key, size_t start_key_len, const char* limit_key,
3743 size_t limit_key_len, char** errptr) {
3744 Slice a, b;
3745 SaveError(
3746 errptr,
3747 DeleteFilesInRange(
3748 db->rep, column_family->rep,
3749 (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
3750 (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)));
3751 }
3752
rocksdb_transactiondb_options_create()3753 rocksdb_transactiondb_options_t* rocksdb_transactiondb_options_create() {
3754 return new rocksdb_transactiondb_options_t;
3755 }
3756
rocksdb_transactiondb_options_destroy(rocksdb_transactiondb_options_t * opt)3757 void rocksdb_transactiondb_options_destroy(rocksdb_transactiondb_options_t* opt){
3758 delete opt;
3759 }
3760
rocksdb_transactiondb_options_set_max_num_locks(rocksdb_transactiondb_options_t * opt,int64_t max_num_locks)3761 void rocksdb_transactiondb_options_set_max_num_locks(
3762 rocksdb_transactiondb_options_t* opt, int64_t max_num_locks) {
3763 opt->rep.max_num_locks = max_num_locks;
3764 }
3765
rocksdb_transactiondb_options_set_num_stripes(rocksdb_transactiondb_options_t * opt,size_t num_stripes)3766 void rocksdb_transactiondb_options_set_num_stripes(
3767 rocksdb_transactiondb_options_t* opt, size_t num_stripes) {
3768 opt->rep.num_stripes = num_stripes;
3769 }
3770
rocksdb_transactiondb_options_set_transaction_lock_timeout(rocksdb_transactiondb_options_t * opt,int64_t txn_lock_timeout)3771 void rocksdb_transactiondb_options_set_transaction_lock_timeout(
3772 rocksdb_transactiondb_options_t* opt, int64_t txn_lock_timeout) {
3773 opt->rep.transaction_lock_timeout = txn_lock_timeout;
3774 }
3775
rocksdb_transactiondb_options_set_default_lock_timeout(rocksdb_transactiondb_options_t * opt,int64_t default_lock_timeout)3776 void rocksdb_transactiondb_options_set_default_lock_timeout(
3777 rocksdb_transactiondb_options_t* opt, int64_t default_lock_timeout) {
3778 opt->rep.default_lock_timeout = default_lock_timeout;
3779 }
3780
rocksdb_transaction_options_create()3781 rocksdb_transaction_options_t* rocksdb_transaction_options_create() {
3782 return new rocksdb_transaction_options_t;
3783 }
3784
rocksdb_transaction_options_destroy(rocksdb_transaction_options_t * opt)3785 void rocksdb_transaction_options_destroy(rocksdb_transaction_options_t* opt) {
3786 delete opt;
3787 }
3788
rocksdb_transaction_options_set_set_snapshot(rocksdb_transaction_options_t * opt,unsigned char v)3789 void rocksdb_transaction_options_set_set_snapshot(
3790 rocksdb_transaction_options_t* opt, unsigned char v) {
3791 opt->rep.set_snapshot = v;
3792 }
3793
rocksdb_transaction_options_set_deadlock_detect(rocksdb_transaction_options_t * opt,unsigned char v)3794 void rocksdb_transaction_options_set_deadlock_detect(
3795 rocksdb_transaction_options_t* opt, unsigned char v) {
3796 opt->rep.deadlock_detect = v;
3797 }
3798
rocksdb_transaction_options_set_lock_timeout(rocksdb_transaction_options_t * opt,int64_t lock_timeout)3799 void rocksdb_transaction_options_set_lock_timeout(
3800 rocksdb_transaction_options_t* opt, int64_t lock_timeout) {
3801 opt->rep.lock_timeout = lock_timeout;
3802 }
3803
rocksdb_transaction_options_set_expiration(rocksdb_transaction_options_t * opt,int64_t expiration)3804 void rocksdb_transaction_options_set_expiration(
3805 rocksdb_transaction_options_t* opt, int64_t expiration) {
3806 opt->rep.expiration = expiration;
3807 }
3808
rocksdb_transaction_options_set_deadlock_detect_depth(rocksdb_transaction_options_t * opt,int64_t depth)3809 void rocksdb_transaction_options_set_deadlock_detect_depth(
3810 rocksdb_transaction_options_t* opt, int64_t depth) {
3811 opt->rep.deadlock_detect_depth = depth;
3812 }
3813
rocksdb_transaction_options_set_max_write_batch_size(rocksdb_transaction_options_t * opt,size_t size)3814 void rocksdb_transaction_options_set_max_write_batch_size(
3815 rocksdb_transaction_options_t* opt, size_t size) {
3816 opt->rep.max_write_batch_size = size;
3817 }
3818
3819 rocksdb_optimistictransaction_options_t*
rocksdb_optimistictransaction_options_create()3820 rocksdb_optimistictransaction_options_create() {
3821 return new rocksdb_optimistictransaction_options_t;
3822 }
3823
rocksdb_optimistictransaction_options_destroy(rocksdb_optimistictransaction_options_t * opt)3824 void rocksdb_optimistictransaction_options_destroy(
3825 rocksdb_optimistictransaction_options_t* opt) {
3826 delete opt;
3827 }
3828
rocksdb_optimistictransaction_options_set_set_snapshot(rocksdb_optimistictransaction_options_t * opt,unsigned char v)3829 void rocksdb_optimistictransaction_options_set_set_snapshot(
3830 rocksdb_optimistictransaction_options_t* opt, unsigned char v) {
3831 opt->rep.set_snapshot = v;
3832 }
3833
rocksdb_transactiondb_create_column_family(rocksdb_transactiondb_t * txn_db,const rocksdb_options_t * column_family_options,const char * column_family_name,char ** errptr)3834 rocksdb_column_family_handle_t* rocksdb_transactiondb_create_column_family(
3835 rocksdb_transactiondb_t* txn_db,
3836 const rocksdb_options_t* column_family_options,
3837 const char* column_family_name, char** errptr) {
3838 rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t;
3839 SaveError(errptr, txn_db->rep->CreateColumnFamily(
3840 ColumnFamilyOptions(column_family_options->rep),
3841 std::string(column_family_name), &(handle->rep)));
3842 return handle;
3843 }
3844
rocksdb_transactiondb_open(const rocksdb_options_t * options,const rocksdb_transactiondb_options_t * txn_db_options,const char * name,char ** errptr)3845 rocksdb_transactiondb_t* rocksdb_transactiondb_open(
3846 const rocksdb_options_t* options,
3847 const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
3848 char** errptr) {
3849 TransactionDB* txn_db;
3850 if (SaveError(errptr, TransactionDB::Open(options->rep, txn_db_options->rep,
3851 std::string(name), &txn_db))) {
3852 return nullptr;
3853 }
3854 rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t;
3855 result->rep = txn_db;
3856 return result;
3857 }
3858
rocksdb_transactiondb_open_column_families(const rocksdb_options_t * options,const rocksdb_transactiondb_options_t * txn_db_options,const char * name,int num_column_families,const char * const * column_family_names,const rocksdb_options_t * const * column_family_options,rocksdb_column_family_handle_t ** column_family_handles,char ** errptr)3859 rocksdb_transactiondb_t* rocksdb_transactiondb_open_column_families(
3860 const rocksdb_options_t* options,
3861 const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
3862 int num_column_families, const char* const* column_family_names,
3863 const rocksdb_options_t* const* column_family_options,
3864 rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
3865 std::vector<ColumnFamilyDescriptor> column_families;
3866 for (int i = 0; i < num_column_families; i++) {
3867 column_families.push_back(ColumnFamilyDescriptor(
3868 std::string(column_family_names[i]),
3869 ColumnFamilyOptions(column_family_options[i]->rep)));
3870 }
3871
3872 TransactionDB* txn_db;
3873 std::vector<ColumnFamilyHandle*> handles;
3874 if (SaveError(errptr, TransactionDB::Open(options->rep, txn_db_options->rep,
3875 std::string(name), column_families,
3876 &handles, &txn_db))) {
3877 return nullptr;
3878 }
3879
3880 for (size_t i = 0; i < handles.size(); i++) {
3881 rocksdb_column_family_handle_t* c_handle =
3882 new rocksdb_column_family_handle_t;
3883 c_handle->rep = handles[i];
3884 column_family_handles[i] = c_handle;
3885 }
3886 rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t;
3887 result->rep = txn_db;
3888 return result;
3889 }
3890
rocksdb_transactiondb_create_snapshot(rocksdb_transactiondb_t * txn_db)3891 const rocksdb_snapshot_t* rocksdb_transactiondb_create_snapshot(
3892 rocksdb_transactiondb_t* txn_db) {
3893 rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
3894 result->rep = txn_db->rep->GetSnapshot();
3895 return result;
3896 }
3897
rocksdb_transactiondb_release_snapshot(rocksdb_transactiondb_t * txn_db,const rocksdb_snapshot_t * snapshot)3898 void rocksdb_transactiondb_release_snapshot(
3899 rocksdb_transactiondb_t* txn_db, const rocksdb_snapshot_t* snapshot) {
3900 txn_db->rep->ReleaseSnapshot(snapshot->rep);
3901 delete snapshot;
3902 }
3903
rocksdb_transaction_begin(rocksdb_transactiondb_t * txn_db,const rocksdb_writeoptions_t * write_options,const rocksdb_transaction_options_t * txn_options,rocksdb_transaction_t * old_txn)3904 rocksdb_transaction_t* rocksdb_transaction_begin(
3905 rocksdb_transactiondb_t* txn_db,
3906 const rocksdb_writeoptions_t* write_options,
3907 const rocksdb_transaction_options_t* txn_options,
3908 rocksdb_transaction_t* old_txn) {
3909 if (old_txn == nullptr) {
3910 rocksdb_transaction_t* result = new rocksdb_transaction_t;
3911 result->rep = txn_db->rep->BeginTransaction(write_options->rep,
3912 txn_options->rep, nullptr);
3913 return result;
3914 }
3915 old_txn->rep = txn_db->rep->BeginTransaction(write_options->rep,
3916 txn_options->rep, old_txn->rep);
3917 return old_txn;
3918 }
3919
rocksdb_transaction_commit(rocksdb_transaction_t * txn,char ** errptr)3920 void rocksdb_transaction_commit(rocksdb_transaction_t* txn, char** errptr) {
3921 SaveError(errptr, txn->rep->Commit());
3922 }
3923
rocksdb_transaction_rollback(rocksdb_transaction_t * txn,char ** errptr)3924 void rocksdb_transaction_rollback(rocksdb_transaction_t* txn, char** errptr) {
3925 SaveError(errptr, txn->rep->Rollback());
3926 }
3927
rocksdb_transaction_set_savepoint(rocksdb_transaction_t * txn)3928 void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) {
3929 txn->rep->SetSavePoint();
3930 }
3931
rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t * txn,char ** errptr)3932 void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn, char** errptr) {
3933 SaveError(errptr, txn->rep->RollbackToSavePoint());
3934 }
3935
rocksdb_transaction_destroy(rocksdb_transaction_t * txn)3936 void rocksdb_transaction_destroy(rocksdb_transaction_t* txn) {
3937 delete txn->rep;
3938 delete txn;
3939 }
3940
rocksdb_transaction_get_snapshot(rocksdb_transaction_t * txn)3941 const rocksdb_snapshot_t* rocksdb_transaction_get_snapshot(
3942 rocksdb_transaction_t* txn) {
3943 rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
3944 result->rep = txn->rep->GetSnapshot();
3945 return result;
3946 }
3947
3948 // Read a key inside a transaction
rocksdb_transaction_get(rocksdb_transaction_t * txn,const rocksdb_readoptions_t * options,const char * key,size_t klen,size_t * vlen,char ** errptr)3949 char* rocksdb_transaction_get(rocksdb_transaction_t* txn,
3950 const rocksdb_readoptions_t* options,
3951 const char* key, size_t klen, size_t* vlen,
3952 char** errptr) {
3953 char* result = nullptr;
3954 std::string tmp;
3955 Status s = txn->rep->Get(options->rep, Slice(key, klen), &tmp);
3956 if (s.ok()) {
3957 *vlen = tmp.size();
3958 result = CopyString(tmp);
3959 } else {
3960 *vlen = 0;
3961 if (!s.IsNotFound()) {
3962 SaveError(errptr, s);
3963 }
3964 }
3965 return result;
3966 }
3967
rocksdb_transaction_get_cf(rocksdb_transaction_t * txn,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,size_t * vlen,char ** errptr)3968 char* rocksdb_transaction_get_cf(rocksdb_transaction_t* txn,
3969 const rocksdb_readoptions_t* options,
3970 rocksdb_column_family_handle_t* column_family,
3971 const char* key, size_t klen, size_t* vlen,
3972 char** errptr) {
3973 char* result = nullptr;
3974 std::string tmp;
3975 Status s =
3976 txn->rep->Get(options->rep, column_family->rep, Slice(key, klen), &tmp);
3977 if (s.ok()) {
3978 *vlen = tmp.size();
3979 result = CopyString(tmp);
3980 } else {
3981 *vlen = 0;
3982 if (!s.IsNotFound()) {
3983 SaveError(errptr, s);
3984 }
3985 }
3986 return result;
3987 }
3988
3989 // Read a key inside a transaction
rocksdb_transaction_get_for_update(rocksdb_transaction_t * txn,const rocksdb_readoptions_t * options,const char * key,size_t klen,size_t * vlen,unsigned char exclusive,char ** errptr)3990 char* rocksdb_transaction_get_for_update(rocksdb_transaction_t* txn,
3991 const rocksdb_readoptions_t* options,
3992 const char* key, size_t klen,
3993 size_t* vlen, unsigned char exclusive,
3994 char** errptr) {
3995 char* result = nullptr;
3996 std::string tmp;
3997 Status s =
3998 txn->rep->GetForUpdate(options->rep, Slice(key, klen), &tmp, exclusive);
3999 if (s.ok()) {
4000 *vlen = tmp.size();
4001 result = CopyString(tmp);
4002 } else {
4003 *vlen = 0;
4004 if (!s.IsNotFound()) {
4005 SaveError(errptr, s);
4006 }
4007 }
4008 return result;
4009 }
4010
rocksdb_transaction_get_for_update_cf(rocksdb_transaction_t * txn,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,size_t * vlen,unsigned char exclusive,char ** errptr)4011 char* rocksdb_transaction_get_for_update_cf(
4012 rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
4013 rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
4014 size_t* vlen, unsigned char exclusive, char** errptr) {
4015 char* result = nullptr;
4016 std::string tmp;
4017 Status s = txn->rep->GetForUpdate(options->rep, column_family->rep,
4018 Slice(key, klen), &tmp, exclusive);
4019 if (s.ok()) {
4020 *vlen = tmp.size();
4021 result = CopyString(tmp);
4022 } else {
4023 *vlen = 0;
4024 if (!s.IsNotFound()) {
4025 SaveError(errptr, s);
4026 }
4027 }
4028 return result;
4029 }
4030
4031 // Read a key outside a transaction
rocksdb_transactiondb_get(rocksdb_transactiondb_t * txn_db,const rocksdb_readoptions_t * options,const char * key,size_t klen,size_t * vlen,char ** errptr)4032 char* rocksdb_transactiondb_get(
4033 rocksdb_transactiondb_t* txn_db,
4034 const rocksdb_readoptions_t* options,
4035 const char* key, size_t klen,
4036 size_t* vlen,
4037 char** errptr){
4038 char* result = nullptr;
4039 std::string tmp;
4040 Status s = txn_db->rep->Get(options->rep, Slice(key, klen), &tmp);
4041 if (s.ok()) {
4042 *vlen = tmp.size();
4043 result = CopyString(tmp);
4044 } else {
4045 *vlen = 0;
4046 if (!s.IsNotFound()) {
4047 SaveError(errptr, s);
4048 }
4049 }
4050 return result;
4051 }
4052
rocksdb_transactiondb_get_cf(rocksdb_transactiondb_t * txn_db,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,size_t * vallen,char ** errptr)4053 char* rocksdb_transactiondb_get_cf(
4054 rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
4055 rocksdb_column_family_handle_t* column_family, const char* key,
4056 size_t keylen, size_t* vallen, char** errptr) {
4057 char* result = nullptr;
4058 std::string tmp;
4059 Status s = txn_db->rep->Get(options->rep, column_family->rep,
4060 Slice(key, keylen), &tmp);
4061 if (s.ok()) {
4062 *vallen = tmp.size();
4063 result = CopyString(tmp);
4064 } else {
4065 *vallen = 0;
4066 if (!s.IsNotFound()) {
4067 SaveError(errptr, s);
4068 }
4069 }
4070 return result;
4071 }
4072
4073 // Put a key inside a transaction
rocksdb_transaction_put(rocksdb_transaction_t * txn,const char * key,size_t klen,const char * val,size_t vlen,char ** errptr)4074 void rocksdb_transaction_put(rocksdb_transaction_t* txn, const char* key,
4075 size_t klen, const char* val, size_t vlen,
4076 char** errptr) {
4077 SaveError(errptr, txn->rep->Put(Slice(key, klen), Slice(val, vlen)));
4078 }
4079
rocksdb_transaction_put_cf(rocksdb_transaction_t * txn,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,const char * val,size_t vlen,char ** errptr)4080 void rocksdb_transaction_put_cf(rocksdb_transaction_t* txn,
4081 rocksdb_column_family_handle_t* column_family,
4082 const char* key, size_t klen, const char* val,
4083 size_t vlen, char** errptr) {
4084 SaveError(errptr, txn->rep->Put(column_family->rep, Slice(key, klen),
4085 Slice(val, vlen)));
4086 }
4087
4088 // Put a key outside a transaction
rocksdb_transactiondb_put(rocksdb_transactiondb_t * txn_db,const rocksdb_writeoptions_t * options,const char * key,size_t klen,const char * val,size_t vlen,char ** errptr)4089 void rocksdb_transactiondb_put(rocksdb_transactiondb_t* txn_db,
4090 const rocksdb_writeoptions_t* options,
4091 const char* key, size_t klen, const char* val,
4092 size_t vlen, char** errptr) {
4093 SaveError(errptr,
4094 txn_db->rep->Put(options->rep, Slice(key, klen), Slice(val, vlen)));
4095 }
4096
rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t * txn_db,const rocksdb_writeoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,const char * val,size_t vallen,char ** errptr)4097 void rocksdb_transactiondb_put_cf(rocksdb_transactiondb_t* txn_db,
4098 const rocksdb_writeoptions_t* options,
4099 rocksdb_column_family_handle_t* column_family,
4100 const char* key, size_t keylen,
4101 const char* val, size_t vallen,
4102 char** errptr) {
4103 SaveError(errptr, txn_db->rep->Put(options->rep, column_family->rep,
4104 Slice(key, keylen), Slice(val, vallen)));
4105 }
4106
4107 // Write batch into transaction db
rocksdb_transactiondb_write(rocksdb_transactiondb_t * db,const rocksdb_writeoptions_t * options,rocksdb_writebatch_t * batch,char ** errptr)4108 void rocksdb_transactiondb_write(
4109 rocksdb_transactiondb_t* db,
4110 const rocksdb_writeoptions_t* options,
4111 rocksdb_writebatch_t* batch,
4112 char** errptr) {
4113 SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
4114 }
4115
4116 // Merge a key inside a transaction
rocksdb_transaction_merge(rocksdb_transaction_t * txn,const char * key,size_t klen,const char * val,size_t vlen,char ** errptr)4117 void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key,
4118 size_t klen, const char* val, size_t vlen,
4119 char** errptr) {
4120 SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen)));
4121 }
4122
rocksdb_transaction_merge_cf(rocksdb_transaction_t * txn,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,const char * val,size_t vlen,char ** errptr)4123 void rocksdb_transaction_merge_cf(rocksdb_transaction_t* txn,
4124 rocksdb_column_family_handle_t* column_family,
4125 const char* key, size_t klen, const char* val,
4126 size_t vlen, char** errptr) {
4127 SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen),
4128 Slice(val, vlen)));
4129 }
4130
4131 // Merge a key outside a transaction
rocksdb_transactiondb_merge(rocksdb_transactiondb_t * txn_db,const rocksdb_writeoptions_t * options,const char * key,size_t klen,const char * val,size_t vlen,char ** errptr)4132 void rocksdb_transactiondb_merge(rocksdb_transactiondb_t* txn_db,
4133 const rocksdb_writeoptions_t* options,
4134 const char* key, size_t klen, const char* val,
4135 size_t vlen, char** errptr) {
4136 SaveError(errptr, txn_db->rep->Merge(options->rep, Slice(key, klen),
4137 Slice(val, vlen)));
4138 }
4139
rocksdb_transactiondb_merge_cf(rocksdb_transactiondb_t * txn_db,const rocksdb_writeoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,const char * val,size_t vlen,char ** errptr)4140 void rocksdb_transactiondb_merge_cf(
4141 rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
4142 rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
4143 const char* val, size_t vlen, char** errptr) {
4144 SaveError(errptr, txn_db->rep->Merge(options->rep, column_family->rep,
4145 Slice(key, klen), Slice(val, vlen)));
4146 }
4147
4148 // Delete a key inside a transaction
rocksdb_transaction_delete(rocksdb_transaction_t * txn,const char * key,size_t klen,char ** errptr)4149 void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key,
4150 size_t klen, char** errptr) {
4151 SaveError(errptr, txn->rep->Delete(Slice(key, klen)));
4152 }
4153
rocksdb_transaction_delete_cf(rocksdb_transaction_t * txn,rocksdb_column_family_handle_t * column_family,const char * key,size_t klen,char ** errptr)4154 void rocksdb_transaction_delete_cf(
4155 rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
4156 const char* key, size_t klen, char** errptr) {
4157 SaveError(errptr, txn->rep->Delete(column_family->rep, Slice(key, klen)));
4158 }
4159
4160 // Delete a key outside a transaction
rocksdb_transactiondb_delete(rocksdb_transactiondb_t * txn_db,const rocksdb_writeoptions_t * options,const char * key,size_t klen,char ** errptr)4161 void rocksdb_transactiondb_delete(rocksdb_transactiondb_t* txn_db,
4162 const rocksdb_writeoptions_t* options,
4163 const char* key, size_t klen, char** errptr) {
4164 SaveError(errptr, txn_db->rep->Delete(options->rep, Slice(key, klen)));
4165 }
4166
rocksdb_transactiondb_delete_cf(rocksdb_transactiondb_t * txn_db,const rocksdb_writeoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,char ** errptr)4167 void rocksdb_transactiondb_delete_cf(
4168 rocksdb_transactiondb_t* txn_db, const rocksdb_writeoptions_t* options,
4169 rocksdb_column_family_handle_t* column_family, const char* key,
4170 size_t keylen, char** errptr) {
4171 SaveError(errptr, txn_db->rep->Delete(options->rep, column_family->rep,
4172 Slice(key, keylen)));
4173 }
4174
4175 // Create an iterator inside a transaction
rocksdb_transaction_create_iterator(rocksdb_transaction_t * txn,const rocksdb_readoptions_t * options)4176 rocksdb_iterator_t* rocksdb_transaction_create_iterator(
4177 rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options) {
4178 rocksdb_iterator_t* result = new rocksdb_iterator_t;
4179 result->rep = txn->rep->GetIterator(options->rep);
4180 return result;
4181 }
4182
4183 // Create an iterator inside a transaction with column family
rocksdb_transaction_create_iterator_cf(rocksdb_transaction_t * txn,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family)4184 rocksdb_iterator_t* rocksdb_transaction_create_iterator_cf(
4185 rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
4186 rocksdb_column_family_handle_t* column_family) {
4187 rocksdb_iterator_t* result = new rocksdb_iterator_t;
4188 result->rep = txn->rep->GetIterator(options->rep, column_family->rep);
4189 return result;
4190 }
4191
4192 // Create an iterator outside a transaction
rocksdb_transactiondb_create_iterator(rocksdb_transactiondb_t * txn_db,const rocksdb_readoptions_t * options)4193 rocksdb_iterator_t* rocksdb_transactiondb_create_iterator(
4194 rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options) {
4195 rocksdb_iterator_t* result = new rocksdb_iterator_t;
4196 result->rep = txn_db->rep->NewIterator(options->rep);
4197 return result;
4198 }
4199
rocksdb_transactiondb_create_iterator_cf(rocksdb_transactiondb_t * txn_db,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family)4200 rocksdb_iterator_t* rocksdb_transactiondb_create_iterator_cf(
4201 rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
4202 rocksdb_column_family_handle_t* column_family) {
4203 rocksdb_iterator_t* result = new rocksdb_iterator_t;
4204 result->rep = txn_db->rep->NewIterator(options->rep, column_family->rep);
4205 return result;
4206 }
4207
rocksdb_transactiondb_close(rocksdb_transactiondb_t * txn_db)4208 void rocksdb_transactiondb_close(rocksdb_transactiondb_t* txn_db) {
4209 delete txn_db->rep;
4210 delete txn_db;
4211 }
4212
rocksdb_transactiondb_checkpoint_object_create(rocksdb_transactiondb_t * txn_db,char ** errptr)4213 rocksdb_checkpoint_t* rocksdb_transactiondb_checkpoint_object_create(
4214 rocksdb_transactiondb_t* txn_db, char** errptr) {
4215 Checkpoint* checkpoint;
4216 if (SaveError(errptr, Checkpoint::Create(txn_db->rep, &checkpoint))) {
4217 return nullptr;
4218 }
4219 rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t;
4220 result->rep = checkpoint;
4221 return result;
4222 }
4223
rocksdb_optimistictransactiondb_open(const rocksdb_options_t * options,const char * name,char ** errptr)4224 rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open(
4225 const rocksdb_options_t* options, const char* name, char** errptr) {
4226 OptimisticTransactionDB* otxn_db;
4227 if (SaveError(errptr, OptimisticTransactionDB::Open(
4228 options->rep, std::string(name), &otxn_db))) {
4229 return nullptr;
4230 }
4231 rocksdb_optimistictransactiondb_t* result =
4232 new rocksdb_optimistictransactiondb_t;
4233 result->rep = otxn_db;
4234 return result;
4235 }
4236
4237 rocksdb_optimistictransactiondb_t*
rocksdb_optimistictransactiondb_open_column_families(const rocksdb_options_t * db_options,const char * name,int num_column_families,const char * const * column_family_names,const rocksdb_options_t * const * column_family_options,rocksdb_column_family_handle_t ** column_family_handles,char ** errptr)4238 rocksdb_optimistictransactiondb_open_column_families(
4239 const rocksdb_options_t* db_options, const char* name,
4240 int num_column_families, const char* const* column_family_names,
4241 const rocksdb_options_t* const* column_family_options,
4242 rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
4243 std::vector<ColumnFamilyDescriptor> column_families;
4244 for (int i = 0; i < num_column_families; i++) {
4245 column_families.push_back(ColumnFamilyDescriptor(
4246 std::string(column_family_names[i]),
4247 ColumnFamilyOptions(column_family_options[i]->rep)));
4248 }
4249
4250 OptimisticTransactionDB* otxn_db;
4251 std::vector<ColumnFamilyHandle*> handles;
4252 if (SaveError(errptr, OptimisticTransactionDB::Open(
4253 DBOptions(db_options->rep), std::string(name),
4254 column_families, &handles, &otxn_db))) {
4255 return nullptr;
4256 }
4257
4258 for (size_t i = 0; i < handles.size(); i++) {
4259 rocksdb_column_family_handle_t* c_handle =
4260 new rocksdb_column_family_handle_t;
4261 c_handle->rep = handles[i];
4262 column_family_handles[i] = c_handle;
4263 }
4264 rocksdb_optimistictransactiondb_t* result =
4265 new rocksdb_optimistictransactiondb_t;
4266 result->rep = otxn_db;
4267 return result;
4268 }
4269
rocksdb_optimistictransactiondb_get_base_db(rocksdb_optimistictransactiondb_t * otxn_db)4270 rocksdb_t* rocksdb_optimistictransactiondb_get_base_db(
4271 rocksdb_optimistictransactiondb_t* otxn_db) {
4272 DB* base_db = otxn_db->rep->GetBaseDB();
4273
4274 if (base_db != nullptr) {
4275 rocksdb_t* result = new rocksdb_t;
4276 result->rep = base_db;
4277 return result;
4278 }
4279
4280 return nullptr;
4281 }
4282
rocksdb_optimistictransactiondb_close_base_db(rocksdb_t * base_db)4283 void rocksdb_optimistictransactiondb_close_base_db(rocksdb_t* base_db) {
4284 delete base_db;
4285 }
4286
rocksdb_optimistictransaction_begin(rocksdb_optimistictransactiondb_t * otxn_db,const rocksdb_writeoptions_t * write_options,const rocksdb_optimistictransaction_options_t * otxn_options,rocksdb_transaction_t * old_txn)4287 rocksdb_transaction_t* rocksdb_optimistictransaction_begin(
4288 rocksdb_optimistictransactiondb_t* otxn_db,
4289 const rocksdb_writeoptions_t* write_options,
4290 const rocksdb_optimistictransaction_options_t* otxn_options,
4291 rocksdb_transaction_t* old_txn) {
4292 if (old_txn == nullptr) {
4293 rocksdb_transaction_t* result = new rocksdb_transaction_t;
4294 result->rep = otxn_db->rep->BeginTransaction(write_options->rep,
4295 otxn_options->rep, nullptr);
4296 return result;
4297 }
4298 old_txn->rep = otxn_db->rep->BeginTransaction(
4299 write_options->rep, otxn_options->rep, old_txn->rep);
4300 return old_txn;
4301 }
4302
rocksdb_optimistictransactiondb_close(rocksdb_optimistictransactiondb_t * otxn_db)4303 void rocksdb_optimistictransactiondb_close(
4304 rocksdb_optimistictransactiondb_t* otxn_db) {
4305 delete otxn_db->rep;
4306 delete otxn_db;
4307 }
4308
rocksdb_free(void * ptr)4309 void rocksdb_free(void* ptr) { free(ptr); }
4310
rocksdb_get_pinned(rocksdb_t * db,const rocksdb_readoptions_t * options,const char * key,size_t keylen,char ** errptr)4311 rocksdb_pinnableslice_t* rocksdb_get_pinned(
4312 rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key,
4313 size_t keylen, char** errptr) {
4314 rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
4315 Status s = db->rep->Get(options->rep, db->rep->DefaultColumnFamily(),
4316 Slice(key, keylen), &v->rep);
4317 if (!s.ok()) {
4318 delete (v);
4319 if (!s.IsNotFound()) {
4320 SaveError(errptr, s);
4321 }
4322 return nullptr;
4323 }
4324 return v;
4325 }
4326
rocksdb_get_pinned_cf(rocksdb_t * db,const rocksdb_readoptions_t * options,rocksdb_column_family_handle_t * column_family,const char * key,size_t keylen,char ** errptr)4327 rocksdb_pinnableslice_t* rocksdb_get_pinned_cf(
4328 rocksdb_t* db, const rocksdb_readoptions_t* options,
4329 rocksdb_column_family_handle_t* column_family, const char* key,
4330 size_t keylen, char** errptr) {
4331 rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
4332 Status s = db->rep->Get(options->rep, column_family->rep, Slice(key, keylen),
4333 &v->rep);
4334 if (!s.ok()) {
4335 delete v;
4336 if (!s.IsNotFound()) {
4337 SaveError(errptr, s);
4338 }
4339 return nullptr;
4340 }
4341 return v;
4342 }
4343
rocksdb_pinnableslice_destroy(rocksdb_pinnableslice_t * v)4344 void rocksdb_pinnableslice_destroy(rocksdb_pinnableslice_t* v) { delete v; }
4345
rocksdb_pinnableslice_value(const rocksdb_pinnableslice_t * v,size_t * vlen)4346 const char* rocksdb_pinnableslice_value(const rocksdb_pinnableslice_t* v,
4347 size_t* vlen) {
4348 if (!v) {
4349 *vlen = 0;
4350 return nullptr;
4351 }
4352
4353 *vlen = v->rep.size();
4354 return v->rep.data();
4355 }
4356
4357 // container to keep databases and caches in order to use
4358 // ROCKSDB_NAMESPACE::MemoryUtil
4359 struct rocksdb_memory_consumers_t {
4360 std::vector<rocksdb_t*> dbs;
4361 std::unordered_set<rocksdb_cache_t*> caches;
4362 };
4363
4364 // initializes new container of memory consumers
rocksdb_memory_consumers_create()4365 rocksdb_memory_consumers_t* rocksdb_memory_consumers_create() {
4366 return new rocksdb_memory_consumers_t;
4367 }
4368
4369 // adds datatabase to the container of memory consumers
rocksdb_memory_consumers_add_db(rocksdb_memory_consumers_t * consumers,rocksdb_t * db)4370 void rocksdb_memory_consumers_add_db(rocksdb_memory_consumers_t* consumers,
4371 rocksdb_t* db) {
4372 consumers->dbs.push_back(db);
4373 }
4374
4375 // adds cache to the container of memory consumers
rocksdb_memory_consumers_add_cache(rocksdb_memory_consumers_t * consumers,rocksdb_cache_t * cache)4376 void rocksdb_memory_consumers_add_cache(rocksdb_memory_consumers_t* consumers,
4377 rocksdb_cache_t* cache) {
4378 consumers->caches.insert(cache);
4379 }
4380
4381 // deletes container with memory consumers
rocksdb_memory_consumers_destroy(rocksdb_memory_consumers_t * consumers)4382 void rocksdb_memory_consumers_destroy(rocksdb_memory_consumers_t* consumers) {
4383 delete consumers;
4384 }
4385
4386 // contains memory usage statistics provided by ROCKSDB_NAMESPACE::MemoryUtil
4387 struct rocksdb_memory_usage_t {
4388 uint64_t mem_table_total;
4389 uint64_t mem_table_unflushed;
4390 uint64_t mem_table_readers_total;
4391 uint64_t cache_total;
4392 };
4393
4394 // estimates amount of memory occupied by consumers (dbs and caches)
rocksdb_approximate_memory_usage_create(rocksdb_memory_consumers_t * consumers,char ** errptr)4395 rocksdb_memory_usage_t* rocksdb_approximate_memory_usage_create(
4396 rocksdb_memory_consumers_t* consumers, char** errptr) {
4397
4398 vector<DB*> dbs;
4399 for (auto db : consumers->dbs) {
4400 dbs.push_back(db->rep);
4401 }
4402
4403 unordered_set<const Cache*> cache_set;
4404 for (auto cache : consumers->caches) {
4405 cache_set.insert(const_cast<const Cache*>(cache->rep.get()));
4406 }
4407
4408 std::map<ROCKSDB_NAMESPACE::MemoryUtil::UsageType, uint64_t> usage_by_type;
4409
4410 auto status = MemoryUtil::GetApproximateMemoryUsageByType(dbs, cache_set,
4411 &usage_by_type);
4412 if (SaveError(errptr, status)) {
4413 return nullptr;
4414 }
4415
4416 auto result = new rocksdb_memory_usage_t;
4417 result->mem_table_total = usage_by_type[MemoryUtil::kMemTableTotal];
4418 result->mem_table_unflushed = usage_by_type[MemoryUtil::kMemTableUnFlushed];
4419 result->mem_table_readers_total = usage_by_type[MemoryUtil::kTableReadersTotal];
4420 result->cache_total = usage_by_type[MemoryUtil::kCacheTotal];
4421 return result;
4422 }
4423
rocksdb_approximate_memory_usage_get_mem_table_total(rocksdb_memory_usage_t * memory_usage)4424 uint64_t rocksdb_approximate_memory_usage_get_mem_table_total(
4425 rocksdb_memory_usage_t* memory_usage) {
4426 return memory_usage->mem_table_total;
4427 }
4428
rocksdb_approximate_memory_usage_get_mem_table_unflushed(rocksdb_memory_usage_t * memory_usage)4429 uint64_t rocksdb_approximate_memory_usage_get_mem_table_unflushed(
4430 rocksdb_memory_usage_t* memory_usage) {
4431 return memory_usage->mem_table_unflushed;
4432 }
4433
rocksdb_approximate_memory_usage_get_mem_table_readers_total(rocksdb_memory_usage_t * memory_usage)4434 uint64_t rocksdb_approximate_memory_usage_get_mem_table_readers_total(
4435 rocksdb_memory_usage_t* memory_usage) {
4436 return memory_usage->mem_table_readers_total;
4437 }
4438
rocksdb_approximate_memory_usage_get_cache_total(rocksdb_memory_usage_t * memory_usage)4439 uint64_t rocksdb_approximate_memory_usage_get_cache_total(
4440 rocksdb_memory_usage_t* memory_usage) {
4441 return memory_usage->cache_total;
4442 }
4443
4444 // deletes container with memory usage estimates
rocksdb_approximate_memory_usage_destroy(rocksdb_memory_usage_t * usage)4445 void rocksdb_approximate_memory_usage_destroy(rocksdb_memory_usage_t* usage) {
4446 delete usage;
4447 }
4448
4449 } // end extern "C"
4450
4451 #endif // !ROCKSDB_LITE
4452