c.cc 219.3 KB
Newer Older
1
//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
S
Siying Dong 已提交
2 3 4
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).
5
//
6 7 8 9
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

I
Igor Canadi 已提交
10

11
#include "rocksdb/c.h"
12

13 14 15 16 17
#include <cstdlib>
#include <map>
#include <unordered_set>
#include <vector>

D
Dmitri Smirnov 已提交
18
#include "port/port.h"
19
#include "rocksdb/cache.h"
20
#include "rocksdb/compaction_filter.h"
21
#include "rocksdb/comparator.h"
A
agiardullo 已提交
22
#include "rocksdb/convenience.h"
23 24
#include "rocksdb/db.h"
#include "rocksdb/env.h"
25
#include "rocksdb/experimental.h"
26 27
#include "rocksdb/filter_policy.h"
#include "rocksdb/iterator.h"
28
#include "rocksdb/memtablerep.h"
T
Thomas Adam 已提交
29
#include "rocksdb/merge_operator.h"
30
#include "rocksdb/options.h"
31
#include "rocksdb/perf_context.h"
32
#include "rocksdb/rate_limiter.h"
T
Thomas Adam 已提交
33
#include "rocksdb/slice_transform.h"
34 35
#include "rocksdb/statistics.h"
#include "rocksdb/status.h"
36
#include "rocksdb/table.h"
37
#include "rocksdb/universal_compaction.h"
38
#include "rocksdb/utilities/backup_engine.h"
39
#include "rocksdb/utilities/checkpoint.h"
40
#include "rocksdb/utilities/db_ttl.h"
41
#include "rocksdb/utilities/memory_util.h"
42
#include "rocksdb/utilities/optimistic_transaction_db.h"
43
#include "rocksdb/utilities/options_util.h"
44
#include "rocksdb/utilities/table_properties_collectors.h"
45 46
#include "rocksdb/utilities/transaction.h"
#include "rocksdb/utilities/transaction_db.h"
47 48 49
#include "rocksdb/utilities/write_batch_with_index.h"
#include "rocksdb/write_batch.h"
#include "utilities/merge_operators.h"
50

51
using ROCKSDB_NAMESPACE::BackupEngine;
52
using ROCKSDB_NAMESPACE::BackupEngineOptions;
53 54 55 56 57 58 59 60 61 62
using ROCKSDB_NAMESPACE::BackupID;
using ROCKSDB_NAMESPACE::BackupInfo;
using ROCKSDB_NAMESPACE::BatchResult;
using ROCKSDB_NAMESPACE::BlockBasedTableOptions;
using ROCKSDB_NAMESPACE::BottommostLevelCompaction;
using ROCKSDB_NAMESPACE::BytewiseComparator;
using ROCKSDB_NAMESPACE::Cache;
using ROCKSDB_NAMESPACE::Checkpoint;
using ROCKSDB_NAMESPACE::ColumnFamilyDescriptor;
using ROCKSDB_NAMESPACE::ColumnFamilyHandle;
63
using ROCKSDB_NAMESPACE::ColumnFamilyMetaData;
64 65 66 67 68 69 70
using ROCKSDB_NAMESPACE::ColumnFamilyOptions;
using ROCKSDB_NAMESPACE::CompactionFilter;
using ROCKSDB_NAMESPACE::CompactionFilterFactory;
using ROCKSDB_NAMESPACE::CompactionOptionsFIFO;
using ROCKSDB_NAMESPACE::CompactRangeOptions;
using ROCKSDB_NAMESPACE::Comparator;
using ROCKSDB_NAMESPACE::CompressionType;
71
using ROCKSDB_NAMESPACE::ConfigOptions;
72 73 74 75 76 77 78 79 80 81 82 83
using ROCKSDB_NAMESPACE::CuckooTableOptions;
using ROCKSDB_NAMESPACE::DB;
using ROCKSDB_NAMESPACE::DBOptions;
using ROCKSDB_NAMESPACE::DbPath;
using ROCKSDB_NAMESPACE::Env;
using ROCKSDB_NAMESPACE::EnvOptions;
using ROCKSDB_NAMESPACE::FileLock;
using ROCKSDB_NAMESPACE::FilterPolicy;
using ROCKSDB_NAMESPACE::FlushOptions;
using ROCKSDB_NAMESPACE::InfoLogLevel;
using ROCKSDB_NAMESPACE::IngestExternalFileOptions;
using ROCKSDB_NAMESPACE::Iterator;
84
using ROCKSDB_NAMESPACE::LevelMetaData;
85 86
using ROCKSDB_NAMESPACE::LiveFileMetaData;
using ROCKSDB_NAMESPACE::Logger;
87 88
using ROCKSDB_NAMESPACE::LRUCacheOptions;
using ROCKSDB_NAMESPACE::MemoryAllocator;
89 90 91
using ROCKSDB_NAMESPACE::MemoryUtil;
using ROCKSDB_NAMESPACE::MergeOperator;
using ROCKSDB_NAMESPACE::NewBloomFilterPolicy;
92
using ROCKSDB_NAMESPACE::NewCompactOnDeletionCollectorFactory;
93 94
using ROCKSDB_NAMESPACE::NewGenericRateLimiter;
using ROCKSDB_NAMESPACE::NewLRUCache;
Q
qieqieplus 已提交
95
using ROCKSDB_NAMESPACE::NewRibbonFilterPolicy;
96 97 98 99 100 101
using ROCKSDB_NAMESPACE::OptimisticTransactionDB;
using ROCKSDB_NAMESPACE::OptimisticTransactionOptions;
using ROCKSDB_NAMESPACE::Options;
using ROCKSDB_NAMESPACE::PerfContext;
using ROCKSDB_NAMESPACE::PerfLevel;
using ROCKSDB_NAMESPACE::PinnableSlice;
102
using ROCKSDB_NAMESPACE::PrepopulateBlobCache;
103 104 105 106 107 108 109 110 111 112
using ROCKSDB_NAMESPACE::RandomAccessFile;
using ROCKSDB_NAMESPACE::Range;
using ROCKSDB_NAMESPACE::RateLimiter;
using ROCKSDB_NAMESPACE::ReadOptions;
using ROCKSDB_NAMESPACE::RestoreOptions;
using ROCKSDB_NAMESPACE::SequentialFile;
using ROCKSDB_NAMESPACE::Slice;
using ROCKSDB_NAMESPACE::SliceParts;
using ROCKSDB_NAMESPACE::SliceTransform;
using ROCKSDB_NAMESPACE::Snapshot;
113
using ROCKSDB_NAMESPACE::SstFileMetaData;
114 115
using ROCKSDB_NAMESPACE::SstFileWriter;
using ROCKSDB_NAMESPACE::Status;
116
using ROCKSDB_NAMESPACE::TablePropertiesCollectorFactory;
117 118 119 120 121 122 123 124 125 126
using ROCKSDB_NAMESPACE::Transaction;
using ROCKSDB_NAMESPACE::TransactionDB;
using ROCKSDB_NAMESPACE::TransactionDBOptions;
using ROCKSDB_NAMESPACE::TransactionLogIterator;
using ROCKSDB_NAMESPACE::TransactionOptions;
using ROCKSDB_NAMESPACE::WALRecoveryMode;
using ROCKSDB_NAMESPACE::WritableFile;
using ROCKSDB_NAMESPACE::WriteBatch;
using ROCKSDB_NAMESPACE::WriteBatchWithIndex;
using ROCKSDB_NAMESPACE::WriteOptions;
127

128
using std::unordered_set;
129
using std::vector;
130

131 132
extern "C" {

133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
struct rocksdb_t {
  DB* rep;
};
struct rocksdb_backup_engine_t {
  BackupEngine* rep;
};
struct rocksdb_backup_engine_info_t {
  std::vector<BackupInfo> rep;
};
struct rocksdb_restore_options_t {
  RestoreOptions rep;
};
struct rocksdb_iterator_t {
  Iterator* rep;
};
struct rocksdb_writebatch_t {
  WriteBatch rep;
};
struct rocksdb_writebatch_wi_t {
  WriteBatchWithIndex* rep;
};
struct rocksdb_snapshot_t {
  const Snapshot* rep;
};
struct rocksdb_flushoptions_t {
  FlushOptions rep;
};
struct rocksdb_fifo_compaction_options_t {
  CompactionOptionsFIFO rep;
};
163
struct rocksdb_readoptions_t {
164 165 166 167 168 169
  ReadOptions rep;
  // stack variables to set pointers to in ReadOptions
  Slice upper_bound;
  Slice lower_bound;
  Slice timestamp;
  Slice iter_start_ts;
170 171 172 173 174 175
};
struct rocksdb_writeoptions_t {
  WriteOptions rep;
};
struct rocksdb_options_t {
  Options rep;
176
};
Z
zhangjinpeng1987 已提交
177 178
struct rocksdb_compactoptions_t {
  CompactRangeOptions rep;
179 180 181 182 183 184 185
  Slice full_history_ts_low;
};
struct rocksdb_block_based_table_options_t {
  BlockBasedTableOptions rep;
};
struct rocksdb_cuckoo_table_options_t {
  CuckooTableOptions rep;
Z
zhangjinpeng1987 已提交
186
};
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
struct rocksdb_seqfile_t {
  SequentialFile* rep;
};
struct rocksdb_randomfile_t {
  RandomAccessFile* rep;
};
struct rocksdb_writablefile_t {
  WritableFile* rep;
};
struct rocksdb_wal_iterator_t {
  TransactionLogIterator* rep;
};
struct rocksdb_wal_readoptions_t {
  TransactionLogIterator::ReadOptions rep;
};
struct rocksdb_filelock_t {
  FileLock* rep;
};
205 206 207
struct rocksdb_logger_t {
  std::shared_ptr<Logger> rep;
};
208 209 210 211 212 213
struct rocksdb_lru_cache_options_t {
  LRUCacheOptions rep;
};
struct rocksdb_memory_allocator_t {
  std::shared_ptr<MemoryAllocator> rep;
};
214 215 216
struct rocksdb_cache_t {
  std::shared_ptr<Cache> rep;
};
217 218 219 220 221 222
struct rocksdb_livefiles_t {
  std::vector<LiveFileMetaData> rep;
};
struct rocksdb_column_family_handle_t {
  ColumnFamilyHandle* rep;
};
223 224 225 226 227 228 229 230 231
struct rocksdb_column_family_metadata_t {
  ColumnFamilyMetaData rep;
};
struct rocksdb_level_metadata_t {
  const LevelMetaData* rep;
};
struct rocksdb_sst_file_metadata_t {
  const SstFileMetaData* rep;
};
232 233 234 235 236 237 238 239 240
struct rocksdb_envoptions_t {
  EnvOptions rep;
};
struct rocksdb_ingestexternalfileoptions_t {
  IngestExternalFileOptions rep;
};
struct rocksdb_sstfilewriter_t {
  SstFileWriter* rep;
};
241 242 243
struct rocksdb_ratelimiter_t {
  std::shared_ptr<RateLimiter> rep;
};
244 245 246
struct rocksdb_perfcontext_t {
  PerfContext* rep;
};
S
siddontang 已提交
247 248 249
struct rocksdb_pinnableslice_t {
  PinnableSlice rep;
};
250 251 252 253 254 255 256 257 258 259 260 261
struct rocksdb_transactiondb_options_t {
  TransactionDBOptions rep;
};
struct rocksdb_transactiondb_t {
  TransactionDB* rep;
};
struct rocksdb_transaction_options_t {
  TransactionOptions rep;
};
struct rocksdb_transaction_t {
  Transaction* rep;
};
262 263
struct rocksdb_backup_engine_options_t {
  BackupEngineOptions rep;
264
};
265 266 267
struct rocksdb_checkpoint_t {
  Checkpoint* rep;
};
268 269 270 271 272 273
struct rocksdb_optimistictransactiondb_t {
  OptimisticTransactionDB* rep;
};
struct rocksdb_optimistictransaction_options_t {
  OptimisticTransactionOptions rep;
};
274

275 276 277 278
struct rocksdb_compactionfiltercontext_t {
  CompactionFilter::Context rep;
};

279 280 281
struct rocksdb_compactionfilter_t : public CompactionFilter {
  void* state_;
  void (*destructor_)(void*);
282 283 284 285
  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);
286
  const char* (*name_)(void*);
287
  unsigned char ignore_snapshots_;
288

289
  ~rocksdb_compactionfilter_t() override { (*destructor_)(state_); }
290

291 292
  bool Filter(int level, const Slice& key, const Slice& existing_value,
              std::string* new_value, bool* value_changed) const override {
293
    char* c_new_value = nullptr;
294 295
    size_t new_value_length = 0;
    unsigned char c_value_changed = 0;
296 297 298 299
    unsigned char result =
        (*filter_)(state_, level, key.data(), key.size(), existing_value.data(),
                   existing_value.size(), &c_new_value, &new_value_length,
                   &c_value_changed);
300 301 302 303 304 305 306
    if (c_value_changed) {
      new_value->assign(c_new_value, new_value_length);
      *value_changed = true;
    }
    return result;
  }

307
  const char* Name() const override { return (*name_)(state_); }
308

309
  bool IgnoreSnapshots() const override { return ignore_snapshots_; }
310 311
};

312 313 314 315 316 317 318
struct rocksdb_compactionfilterfactory_t : public CompactionFilterFactory {
  void* state_;
  void (*destructor_)(void*);
  rocksdb_compactionfilter_t* (*create_compaction_filter_)(
      void*, rocksdb_compactionfiltercontext_t* context);
  const char* (*name_)(void*);

319
  ~rocksdb_compactionfilterfactory_t() override { (*destructor_)(state_); }
320

321
  std::unique_ptr<CompactionFilter> CreateCompactionFilter(
I
Igor Sugak 已提交
322
      const CompactionFilter::Context& context) override {
323 324 325 326 327 328
    rocksdb_compactionfiltercontext_t ccontext;
    ccontext.rep = context;
    CompactionFilter* cf = (*create_compaction_filter_)(state_, &ccontext);
    return std::unique_ptr<CompactionFilter>(cf);
  }

329
  const char* Name() const override { return (*name_)(state_); }
330 331
};

332
struct rocksdb_comparator_t : public Comparator {
333 334
  void* state_;
  void (*destructor_)(void*);
335 336
  int (*compare_)(void*, const char* a, size_t alen, const char* b,
                  size_t blen);
337
  const char* (*name_)(void*);
338 339 340 341 342 343 344 345 346
  int (*compare_ts_)(void*, const char* a_ts, size_t a_tslen, const char* b_ts,
                     size_t b_tslen);
  int (*compare_without_ts_)(void*, const char* a, size_t alen,
                             unsigned char a_has_ts, const char* b, size_t blen,
                             unsigned char b_has_ts);

  rocksdb_comparator_t() : Comparator() {}

  rocksdb_comparator_t(size_t ts_size) : Comparator(ts_size) {}
347

348
  ~rocksdb_comparator_t() override { (*destructor_)(state_); }
349

350
  int Compare(const Slice& a, const Slice& b) const override {
351 352 353
    return (*compare_)(state_, a.data(), a.size(), b.data(), b.size());
  }

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
  int CompareTimestamp(const Slice& a_ts, const Slice& b_ts) const override {
    if (compare_ts_ == nullptr) {
      return 0;
    }
    return (*compare_ts_)(state_, a_ts.data(), a_ts.size(), b_ts.data(),
                          b_ts.size());
  }

  int CompareWithoutTimestamp(const Slice& a, bool a_has_ts, const Slice& b,
                              bool b_has_ts) const override {
    if (compare_without_ts_ == nullptr) {
      return Compare(a, b);
    }
    return (*compare_without_ts_)(state_, a.data(), a.size(), a_has_ts,
                                  b.data(), b.size(), b_has_ts);
  }

371
  const char* Name() const override { return (*name_)(state_); }
372 373

  // No-ops since the C binding does not support key shortening methods.
374 375
  void FindShortestSeparator(std::string*, const Slice&) const override {}
  void FindShortSuccessor(std::string* /*key*/) const override {}
376 377
};

378
struct rocksdb_filterpolicy_t : public FilterPolicy {
S
Sanjay Ghemawat 已提交
379 380 381 382
  void* state_;
  void (*destructor_)(void*);
  const char* (*name_)(void*);

383
  ~rocksdb_filterpolicy_t() override { (*destructor_)(state_); }
S
Sanjay Ghemawat 已提交
384

385
  const char* Name() const override { return (*name_)(state_); }
S
Sanjay Ghemawat 已提交
386 387
};

T
Thomas Adam 已提交
388 389 390 391
struct rocksdb_mergeoperator_t : public MergeOperator {
  void* state_;
  void (*destructor_)(void*);
  const char* (*name_)(void*);
392 393 394 395 396
  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);
397 398 399 400
  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);
401
  void (*delete_value_)(void*, const char* value, size_t value_length);
T
Thomas Adam 已提交
402

403
  ~rocksdb_mergeoperator_t() override { (*destructor_)(state_); }
T
Thomas Adam 已提交
404

405
  const char* Name() const override { return (*name_)(state_); }
T
Thomas Adam 已提交
406

407 408
  bool FullMergeV2(const MergeOperationInput& merge_in,
                   MergeOperationOutput* merge_out) const override {
409
    size_t n = merge_in.operand_list.size();
T
Thomas Adam 已提交
410 411 412
    std::vector<const char*> operand_pointers(n);
    std::vector<size_t> operand_sizes(n);
    for (size_t i = 0; i < n; i++) {
413
      Slice operand(merge_in.operand_list[i]);
T
Thomas Adam 已提交
414 415 416 417 418 419
      operand_pointers[i] = operand.data();
      operand_sizes[i] = operand.size();
    }

    const char* existing_value_data = nullptr;
    size_t existing_value_len = 0;
420 421 422
    if (merge_in.existing_value != nullptr) {
      existing_value_data = merge_in.existing_value->data();
      existing_value_len = merge_in.existing_value->size();
T
Thomas Adam 已提交
423 424 425 426 427
    }

    unsigned char success;
    size_t new_value_len;
    char* tmp_new_value = (*full_merge_)(
428 429 430 431
        state_, merge_in.key.data(), merge_in.key.size(), existing_value_data,
        existing_value_len, &operand_pointers[0], &operand_sizes[0],
        static_cast<int>(n), &success, &new_value_len);
    merge_out->new_value.assign(tmp_new_value, new_value_len);
T
Thomas Adam 已提交
432

433 434 435 436 437 438
    if (delete_value_ != nullptr) {
      (*delete_value_)(state_, tmp_new_value, new_value_len);
    } else {
      free(tmp_new_value);
    }

T
Thomas Adam 已提交
439 440 441
    return success;
  }

442 443 444 445
  bool PartialMergeMulti(const Slice& key,
                         const std::deque<Slice>& operand_list,
                         std::string* new_value,
                         Logger* /*logger*/) const override {
446 447 448 449 450 451 452 453
    size_t operand_count = operand_list.size();
    std::vector<const char*> operand_pointers(operand_count);
    std::vector<size_t> operand_sizes(operand_count);
    for (size_t i = 0; i < operand_count; ++i) {
      Slice operand(operand_list[i]);
      operand_pointers[i] = operand.data();
      operand_sizes[i] = operand.size();
    }
T
Thomas Adam 已提交
454 455 456 457

    unsigned char success;
    size_t new_value_len;
    char* tmp_new_value = (*partial_merge_)(
458
        state_, key.data(), key.size(), &operand_pointers[0], &operand_sizes[0],
459
        static_cast<int>(operand_count), &success, &new_value_len);
T
Thomas Adam 已提交
460 461
    new_value->assign(tmp_new_value, new_value_len);

462 463 464 465 466 467
    if (delete_value_ != nullptr) {
      (*delete_value_)(state_, tmp_new_value, new_value_len);
    } else {
      free(tmp_new_value);
    }

T
Thomas Adam 已提交
468 469 470 471
    return success;
  }
};

K
kapitan-k 已提交
472 473 474 475
struct rocksdb_dbpath_t {
  DbPath rep;
};

476
struct rocksdb_env_t {
477 478 479 480
  Env* rep;
  bool is_default;
};

T
Thomas Adam 已提交
481 482 483 484
struct rocksdb_slicetransform_t : public SliceTransform {
  void* state_;
  void (*destructor_)(void*);
  const char* (*name_)(void*);
485 486 487 488
  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);
T
Thomas Adam 已提交
489

490
  ~rocksdb_slicetransform_t() override { (*destructor_)(state_); }
T
Thomas Adam 已提交
491

492
  const char* Name() const override { return (*name_)(state_); }
T
Thomas Adam 已提交
493

494
  Slice Transform(const Slice& src) const override {
T
Thomas Adam 已提交
495 496 497 498 499
    size_t len;
    char* dst = (*transform_)(state_, src.data(), src.size(), &len);
    return Slice(dst, len);
  }

500
  bool InDomain(const Slice& src) const override {
T
Thomas Adam 已提交
501 502 503
    return (*in_domain_)(state_, src.data(), src.size());
  }

504
  bool InRange(const Slice& src) const override {
T
Thomas Adam 已提交
505 506 507 508
    return (*in_range_)(state_, src.data(), src.size());
  }
};

509
struct rocksdb_universal_compaction_options_t {
510
  ROCKSDB_NAMESPACE::CompactionOptionsUniversal* rep;
511 512
};

513
static bool SaveError(char** errptr, const Status& s) {
514
  assert(errptr != nullptr);
515 516
  if (s.ok()) {
    return false;
517
  } else if (*errptr == nullptr) {
518 519 520
    *errptr = strdup(s.ToString().c_str());
  } else {
    // TODO(sanjay): Merge with existing error?
521
    // This is a bug if *errptr is not created by malloc()
522 523 524 525 526 527 528 529 530 531 532 533
    free(*errptr);
    *errptr = strdup(s.ToString().c_str());
  }
  return true;
}

static char* CopyString(const std::string& str) {
  char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size()));
  memcpy(result, str.data(), sizeof(char) * str.size());
  return result;
}

534 535
rocksdb_t* rocksdb_open(const rocksdb_options_t* options, const char* name,
                        char** errptr) {
536 537
  DB* db;
  if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) {
538
    return nullptr;
539
  }
540
  rocksdb_t* result = new rocksdb_t;
541
  result->rep = db;
542 543 544
  return result;
}

545 546
rocksdb_t* rocksdb_open_with_ttl(const rocksdb_options_t* options,
                                 const char* name, int ttl, char** errptr) {
547 548 549
  ROCKSDB_NAMESPACE::DBWithTTL* db;
  if (SaveError(errptr, ROCKSDB_NAMESPACE::DBWithTTL::Open(
                            options->rep, std::string(name), &db, ttl))) {
550 551 552 553 554 555 556
    return nullptr;
  }
  rocksdb_t* result = new rocksdb_t;
  result->rep = db;
  return result;
}

557 558 559 560
rocksdb_t* rocksdb_open_for_read_only(const rocksdb_options_t* options,
                                      const char* name,
                                      unsigned char error_if_wal_file_exists,
                                      char** errptr) {
561
  DB* db;
562 563
  if (SaveError(errptr, DB::OpenForReadOnly(options->rep, std::string(name),
                                            &db, error_if_wal_file_exists))) {
564 565 566 567
    return nullptr;
  }
  rocksdb_t* result = new rocksdb_t;
  result->rep = db;
568 569 570
  return result;
}

571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
rocksdb_t* rocksdb_open_as_secondary(const rocksdb_options_t* options,
                                     const char* name,
                                     const char* secondary_path,
                                     char** errptr) {
  DB* db;
  if (SaveError(errptr,
                DB::OpenAsSecondary(options->rep, std::string(name),
                                    std::string(secondary_path), &db))) {
    return nullptr;
  }
  rocksdb_t* result = new rocksdb_t;
  result->rep = db;
  return result;
}

M
Marko Kevac 已提交
586
rocksdb_backup_engine_t* rocksdb_backup_engine_open(
I
Igor Canadi 已提交
587
    const rocksdb_options_t* options, const char* path, char** errptr) {
M
Marko Kevac 已提交
588
  BackupEngine* be;
589 590 591 592 593
  if (SaveError(errptr, BackupEngine::Open(
                            options->rep.env,
                            BackupEngineOptions(path, nullptr, true,
                                                options->rep.info_log.get()),
                            &be))) {
M
Marko Kevac 已提交
594 595 596 597 598 599 600
    return nullptr;
  }
  rocksdb_backup_engine_t* result = new rocksdb_backup_engine_t;
  result->rep = be;
  return result;
}

601
rocksdb_backup_engine_t* rocksdb_backup_engine_open_opts(
602
    const rocksdb_backup_engine_options_t* options, rocksdb_env_t* env,
603 604 605 606 607 608 609 610 611 612
    char** errptr) {
  BackupEngine* be;
  if (SaveError(errptr, BackupEngine::Open(options->rep, env->rep, &be))) {
    return nullptr;
  }
  rocksdb_backup_engine_t* result = new rocksdb_backup_engine_t;
  result->rep = be;
  return result;
}

I
Igor Canadi 已提交
613
void rocksdb_backup_engine_create_new_backup(rocksdb_backup_engine_t* be,
614
                                             rocksdb_t* db, char** errptr) {
M
Marko Kevac 已提交
615 616 617
  SaveError(errptr, be->rep->CreateNewBackup(db->rep));
}

618 619 620
void rocksdb_backup_engine_create_new_backup_flush(
    rocksdb_backup_engine_t* be, rocksdb_t* db,
    unsigned char flush_before_backup, char** errptr) {
621 622 623
  SaveError(errptr, be->rep->CreateNewBackup(db->rep, flush_before_backup));
}

624 625 626 627 628 629
void rocksdb_backup_engine_purge_old_backups(rocksdb_backup_engine_t* be,
                                             uint32_t num_backups_to_keep,
                                             char** errptr) {
  SaveError(errptr, be->rep->PurgeOldBackups(num_backups_to_keep));
}

630 631 632 633 634 635 636 637
rocksdb_restore_options_t* rocksdb_restore_options_create() {
  return new rocksdb_restore_options_t;
}

void rocksdb_restore_options_destroy(rocksdb_restore_options_t* opt) {
  delete opt;
}

I
Igor Canadi 已提交
638 639
void rocksdb_restore_options_set_keep_log_files(rocksdb_restore_options_t* opt,
                                                int v) {
640 641 642
  opt->rep.keep_log_files = v;
}

643
void rocksdb_backup_engine_verify_backup(rocksdb_backup_engine_t* be,
644
                                         uint32_t backup_id, char** errptr) {
645 646 647
  SaveError(errptr, be->rep->VerifyBackup(static_cast<BackupID>(backup_id)));
}

648
void rocksdb_backup_engine_restore_db_from_latest_backup(
I
Igor Canadi 已提交
649 650 651 652 653
    rocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir,
    const rocksdb_restore_options_t* restore_options, char** errptr) {
  SaveError(errptr, be->rep->RestoreDBFromLatestBackup(std::string(db_dir),
                                                       std::string(wal_dir),
                                                       restore_options->rep));
654 655
}

656 657 658 659 660 661 662 663 664
void rocksdb_backup_engine_restore_db_from_backup(
    rocksdb_backup_engine_t* be, const char* db_dir, const char* wal_dir,
    const rocksdb_restore_options_t* restore_options, const uint32_t backup_id,
    char** errptr) {
  SaveError(errptr, be->rep->RestoreDBFromBackup(backup_id, std::string(db_dir),
                                                 std::string(wal_dir),
                                                 restore_options->rep));
}

665 666 667 668 669 670 671
const rocksdb_backup_engine_info_t* rocksdb_backup_engine_get_backup_info(
    rocksdb_backup_engine_t* be) {
  rocksdb_backup_engine_info_t* result = new rocksdb_backup_engine_info_t;
  be->rep->GetBackupInfo(&result->rep);
  return result;
}

I
Igor Canadi 已提交
672
int rocksdb_backup_engine_info_count(const rocksdb_backup_engine_info_t* info) {
673 674 675
  return static_cast<int>(info->rep.size());
}

676
int64_t rocksdb_backup_engine_info_timestamp(
I
Igor Canadi 已提交
677
    const rocksdb_backup_engine_info_t* info, int index) {
678 679 680
  return info->rep[index].timestamp;
}

681
uint32_t rocksdb_backup_engine_info_backup_id(
I
Igor Canadi 已提交
682
    const rocksdb_backup_engine_info_t* info, int index) {
683 684 685
  return info->rep[index].backup_id;
}

686
uint64_t rocksdb_backup_engine_info_size(
I
Igor Canadi 已提交
687
    const rocksdb_backup_engine_info_t* info, int index) {
688 689 690
  return info->rep[index].size;
}

691
uint32_t rocksdb_backup_engine_info_number_files(
I
Igor Canadi 已提交
692
    const rocksdb_backup_engine_info_t* info, int index) {
693 694 695 696 697 698 699 700
  return info->rep[index].number_files;
}

void rocksdb_backup_engine_info_destroy(
    const rocksdb_backup_engine_info_t* info) {
  delete info;
}

I
Igor Canadi 已提交
701
void rocksdb_backup_engine_close(rocksdb_backup_engine_t* be) {
M
Marko Kevac 已提交
702 703 704 705
  delete be->rep;
  delete be;
}

706
rocksdb_backup_engine_options_t* rocksdb_backup_engine_options_create(
707
    const char* backup_dir) {
708 709
  return new rocksdb_backup_engine_options_t{
      BackupEngineOptions(std::string(backup_dir))};
710 711
}

712 713
void rocksdb_backup_engine_options_set_backup_dir(
    rocksdb_backup_engine_options_t* options, const char* backup_dir) {
714 715 716
  options->rep.backup_dir = std::string(backup_dir);
}

717 718
void rocksdb_backup_engine_options_set_env(
    rocksdb_backup_engine_options_t* options, rocksdb_env_t* env) {
719 720 721
  options->rep.backup_env = (env ? env->rep : nullptr);
}

722 723
void rocksdb_backup_engine_options_set_share_table_files(
    rocksdb_backup_engine_options_t* options, unsigned char val) {
724 725 726
  options->rep.share_table_files = val;
}

727 728
unsigned char rocksdb_backup_engine_options_get_share_table_files(
    rocksdb_backup_engine_options_t* options) {
729 730 731
  return options->rep.share_table_files;
}

732 733
void rocksdb_backup_engine_options_set_sync(
    rocksdb_backup_engine_options_t* options, unsigned char val) {
734 735 736
  options->rep.sync = val;
}

737 738
unsigned char rocksdb_backup_engine_options_get_sync(
    rocksdb_backup_engine_options_t* options) {
739 740 741
  return options->rep.sync;
}

742 743
void rocksdb_backup_engine_options_set_destroy_old_data(
    rocksdb_backup_engine_options_t* options, unsigned char val) {
744 745 746
  options->rep.destroy_old_data = val;
}

747 748
unsigned char rocksdb_backup_engine_options_get_destroy_old_data(
    rocksdb_backup_engine_options_t* options) {
749 750 751
  return options->rep.destroy_old_data;
}

752 753
void rocksdb_backup_engine_options_set_backup_log_files(
    rocksdb_backup_engine_options_t* options, unsigned char val) {
754 755 756
  options->rep.backup_log_files = val;
}

757 758
unsigned char rocksdb_backup_engine_options_get_backup_log_files(
    rocksdb_backup_engine_options_t* options) {
759 760 761
  return options->rep.backup_log_files;
}

762 763
void rocksdb_backup_engine_options_set_backup_rate_limit(
    rocksdb_backup_engine_options_t* options, uint64_t limit) {
764 765 766
  options->rep.backup_rate_limit = limit;
}

767 768
uint64_t rocksdb_backup_engine_options_get_backup_rate_limit(
    rocksdb_backup_engine_options_t* options) {
769 770 771
  return options->rep.backup_rate_limit;
}

772 773
void rocksdb_backup_engine_options_set_restore_rate_limit(
    rocksdb_backup_engine_options_t* options, uint64_t limit) {
774 775 776
  options->rep.restore_rate_limit = limit;
}

777 778
uint64_t rocksdb_backup_engine_options_get_restore_rate_limit(
    rocksdb_backup_engine_options_t* options) {
779 780 781
  return options->rep.restore_rate_limit;
}

782 783
void rocksdb_backup_engine_options_set_max_background_operations(
    rocksdb_backup_engine_options_t* options, int val) {
784 785 786
  options->rep.max_background_operations = val;
}

787 788
int rocksdb_backup_engine_options_get_max_background_operations(
    rocksdb_backup_engine_options_t* options) {
789 790 791
  return options->rep.max_background_operations;
}

792 793
void rocksdb_backup_engine_options_set_callback_trigger_interval_size(
    rocksdb_backup_engine_options_t* options, uint64_t size) {
794 795 796
  options->rep.callback_trigger_interval_size = size;
}

797 798
uint64_t rocksdb_backup_engine_options_get_callback_trigger_interval_size(
    rocksdb_backup_engine_options_t* options) {
799 800 801
  return options->rep.callback_trigger_interval_size;
}

802 803
void rocksdb_backup_engine_options_set_max_valid_backups_to_open(
    rocksdb_backup_engine_options_t* options, int val) {
804 805 806
  options->rep.max_valid_backups_to_open = val;
}

807 808
int rocksdb_backup_engine_options_get_max_valid_backups_to_open(
    rocksdb_backup_engine_options_t* options) {
809 810 811
  return options->rep.max_valid_backups_to_open;
}

812 813
void rocksdb_backup_engine_options_set_share_files_with_checksum_naming(
    rocksdb_backup_engine_options_t* options, int val) {
814
  options->rep.share_files_with_checksum_naming =
815
      static_cast<BackupEngineOptions::ShareFilesNaming>(val);
816 817
}

818 819
int rocksdb_backup_engine_options_get_share_files_with_checksum_naming(
    rocksdb_backup_engine_options_t* options) {
820 821 822
  return static_cast<int>(options->rep.share_files_with_checksum_naming);
}

823 824
void rocksdb_backup_engine_options_destroy(
    rocksdb_backup_engine_options_t* options) {
825 826 827
  delete options;
}

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
rocksdb_checkpoint_t* rocksdb_checkpoint_object_create(rocksdb_t* db,
                                                       char** errptr) {
  Checkpoint* checkpoint;
  if (SaveError(errptr, Checkpoint::Create(db->rep, &checkpoint))) {
    return nullptr;
  }
  rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t;
  result->rep = checkpoint;
  return result;
}

void rocksdb_checkpoint_create(rocksdb_checkpoint_t* checkpoint,
                               const char* checkpoint_dir,
                               uint64_t log_size_for_flush, char** errptr) {
  SaveError(errptr, checkpoint->rep->CreateCheckpoint(
                        std::string(checkpoint_dir), log_size_for_flush));
}

void rocksdb_checkpoint_object_destroy(rocksdb_checkpoint_t* checkpoint) {
  delete checkpoint->rep;
  delete checkpoint;
}

851
void rocksdb_close(rocksdb_t* db) {
852 853 854 855
  delete db->rep;
  delete db;
}

856
void rocksdb_options_set_uint64add_merge_operator(rocksdb_options_t* opt) {
857 858
  opt->rep.merge_operator =
      ROCKSDB_NAMESPACE::MergeOperators::CreateUInt64AddOperator();
859 860
}

861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
rocksdb_t* rocksdb_open_and_trim_history(
    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* trim_ts,
    size_t trim_tslen, char** errptr) {
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i < num_column_families; i++) {
    column_families.push_back(ColumnFamilyDescriptor(
        std::string(column_family_names[i]),
        ColumnFamilyOptions(column_family_options[i]->rep)));
  }

  std::string trim_ts_(trim_ts, trim_tslen);

  DB* db;
  std::vector<ColumnFamilyHandle*> handles;
  if (SaveError(errptr, DB::OpenAndTrimHistory(
                            DBOptions(db_options->rep), std::string(name),
                            column_families, &handles, &db, trim_ts_))) {
    return nullptr;
  }

  for (size_t i = 0; i < handles.size(); i++) {
    rocksdb_column_family_handle_t* c_handle =
        new rocksdb_column_family_handle_t;
    c_handle->rep = handles[i];
    column_family_handles[i] = c_handle;
  }
  rocksdb_t* result = new rocksdb_t;
  result->rep = db;
  return result;
}

R
Reed Allman 已提交
895
rocksdb_t* rocksdb_open_column_families(
896 897
    const rocksdb_options_t* db_options, const char* name,
    int num_column_families, const char* const* column_family_names,
Q
Qinfan Wu 已提交
898
    const rocksdb_options_t* const* column_family_options,
899
    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
R
Reed Allman 已提交
900 901 902 903 904 905 906 907 908
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i < num_column_families; i++) {
    column_families.push_back(ColumnFamilyDescriptor(
        std::string(column_family_names[i]),
        ColumnFamilyOptions(column_family_options[i]->rep)));
  }

  DB* db;
  std::vector<ColumnFamilyHandle*> handles;
909 910
  if (SaveError(errptr, DB::Open(DBOptions(db_options->rep), std::string(name),
                                 column_families, &handles, &db))) {
R
Reed Allman 已提交
911 912 913 914
    return nullptr;
  }

  for (size_t i = 0; i < handles.size(); i++) {
915 916
    rocksdb_column_family_handle_t* c_handle =
        new rocksdb_column_family_handle_t;
R
Reed Allman 已提交
917 918 919 920 921 922 923 924
    c_handle->rep = handles[i];
    column_family_handles[i] = c_handle;
  }
  rocksdb_t* result = new rocksdb_t;
  result->rep = db;
  return result;
}

925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
rocksdb_t* rocksdb_open_column_families_with_ttl(
    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, const int* ttls,
    char** errptr) {
  std::vector<int32_t> ttls_vec;
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i < num_column_families; i++) {
    ttls_vec.push_back(ttls[i]);

    column_families.push_back(ColumnFamilyDescriptor(
        std::string(column_family_names[i]),
        ColumnFamilyOptions(column_family_options[i]->rep)));
  }

  ROCKSDB_NAMESPACE::DBWithTTL* db;
  std::vector<ColumnFamilyHandle*> handles;
  if (SaveError(errptr, ROCKSDB_NAMESPACE::DBWithTTL::Open(
                            DBOptions(db_options->rep), std::string(name),
                            column_families, &handles, &db, ttls_vec))) {
    return nullptr;
  }

  for (size_t i = 0; i < handles.size(); i++) {
    rocksdb_column_family_handle_t* c_handle =
        new rocksdb_column_family_handle_t;
    c_handle->rep = handles[i];
    column_family_handles[i] = c_handle;
  }
  rocksdb_t* result = new rocksdb_t;
  result->rep = db;
  return result;
}

R
Reed Allman 已提交
960
rocksdb_t* rocksdb_open_for_read_only_column_families(
961 962
    const rocksdb_options_t* db_options, const char* name,
    int num_column_families, const char* const* column_family_names,
Q
Qinfan Wu 已提交
963
    const rocksdb_options_t* const* column_family_options,
R
Reed Allman 已提交
964
    rocksdb_column_family_handle_t** column_family_handles,
965
    unsigned char error_if_wal_file_exists, char** errptr) {
R
Reed Allman 已提交
966 967 968 969 970 971 972 973 974
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i < num_column_families; i++) {
    column_families.push_back(ColumnFamilyDescriptor(
        std::string(column_family_names[i]),
        ColumnFamilyOptions(column_family_options[i]->rep)));
  }

  DB* db;
  std::vector<ColumnFamilyHandle*> handles;
975 976 977 978
  if (SaveError(errptr,
                DB::OpenForReadOnly(DBOptions(db_options->rep),
                                    std::string(name), column_families,
                                    &handles, &db, error_if_wal_file_exists))) {
R
Reed Allman 已提交
979 980 981 982
    return nullptr;
  }

  for (size_t i = 0; i < handles.size(); i++) {
983 984
    rocksdb_column_family_handle_t* c_handle =
        new rocksdb_column_family_handle_t;
R
Reed Allman 已提交
985 986 987 988 989 990 991 992
    c_handle->rep = handles[i];
    column_family_handles[i] = c_handle;
  }
  rocksdb_t* result = new rocksdb_t;
  result->rep = db;
  return result;
}

993 994 995
rocksdb_t* rocksdb_open_as_secondary_column_families(
    const rocksdb_options_t* db_options, const char* name,
    const char* secondary_path, int num_column_families,
Q
Qinfan Wu 已提交
996 997
    const char* const* column_family_names,
    const rocksdb_options_t* const* column_family_options,
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i != num_column_families; ++i) {
    column_families.emplace_back(
        std::string(column_family_names[i]),
        ColumnFamilyOptions(column_family_options[i]->rep));
  }
  DB* db;
  std::vector<ColumnFamilyHandle*> handles;
  if (SaveError(errptr, DB::OpenAsSecondary(DBOptions(db_options->rep),
                                            std::string(name),
                                            std::string(secondary_path),
                                            column_families, &handles, &db))) {
    return nullptr;
  }
  for (size_t i = 0; i != handles.size(); ++i) {
    rocksdb_column_family_handle_t* c_handle =
        new rocksdb_column_family_handle_t;
    c_handle->rep = handles[i];
    column_family_handles[i] = c_handle;
  }
  rocksdb_t* result = new rocksdb_t;
  result->rep = db;
  return result;
}

1024 1025 1026
char** rocksdb_list_column_families(const rocksdb_options_t* options,
                                    const char* name, size_t* lencfs,
                                    char** errptr) {
R
Reed Allman 已提交
1027
  std::vector<std::string> fams;
1028 1029
  SaveError(errptr, DB::ListColumnFamilies(DBOptions(options->rep),
                                           std::string(name), &fams));
R
Reed Allman 已提交
1030 1031

  *lencfs = fams.size();
1032 1033
  char** column_families =
      static_cast<char**>(malloc(sizeof(char*) * fams.size()));
R
Reed Allman 已提交
1034 1035 1036 1037 1038 1039
  for (size_t i = 0; i < fams.size(); i++) {
    column_families[i] = strdup(fams[i].c_str());
  }
  return column_families;
}

I
Igor Canadi 已提交
1040 1041
void rocksdb_list_column_families_destroy(char** list, size_t len) {
  for (size_t i = 0; i < len; ++i) {
I
Igor Canadi 已提交
1042
    free(list[i]);
I
Igor Canadi 已提交
1043
  }
I
Igor Canadi 已提交
1044
  free(list);
I
Igor Canadi 已提交
1045 1046
}

R
Reed Allman 已提交
1047
rocksdb_column_family_handle_t* rocksdb_create_column_family(
1048 1049
    rocksdb_t* db, const rocksdb_options_t* column_family_options,
    const char* column_family_name, char** errptr) {
R
Reed Allman 已提交
1050
  rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t;
1051 1052 1053
  SaveError(errptr, db->rep->CreateColumnFamily(
                        ColumnFamilyOptions(column_family_options->rep),
                        std::string(column_family_name), &(handle->rep)));
R
Reed Allman 已提交
1054 1055 1056
  return handle;
}

1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
rocksdb_column_family_handle_t* rocksdb_create_column_family_with_ttl(
    rocksdb_t* db, const rocksdb_options_t* column_family_options,
    const char* column_family_name, int ttl, char** errptr) {
  ROCKSDB_NAMESPACE::DBWithTTL* db_with_ttl =
      static_cast<ROCKSDB_NAMESPACE::DBWithTTL*>(db->rep);
  rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t;
  SaveError(errptr, db_with_ttl->CreateColumnFamilyWithTtl(
                        ColumnFamilyOptions(column_family_options->rep),
                        std::string(column_family_name), &(handle->rep), ttl));
  return handle;
}

1069 1070 1071
void rocksdb_drop_column_family(rocksdb_t* db,
                                rocksdb_column_family_handle_t* handle,
                                char** errptr) {
R
Reed Allman 已提交
1072 1073 1074
  SaveError(errptr, db->rep->DropColumnFamily(handle->rep));
}

1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
uint32_t rocksdb_column_family_handle_get_id(
    rocksdb_column_family_handle_t* handle) {
  return handle->rep->GetID();
}

char* rocksdb_column_family_handle_get_name(
    rocksdb_column_family_handle_t* handle, size_t* name_len) {
  auto name = handle->rep->GetName();
  *name_len = name.size();
  return CopyString(name);
}

1087 1088
void rocksdb_column_family_handle_destroy(
    rocksdb_column_family_handle_t* handle) {
R
Reed Allman 已提交
1089 1090 1091 1092
  delete handle->rep;
  delete handle;
}

1093 1094 1095
void rocksdb_put(rocksdb_t* db, const rocksdb_writeoptions_t* options,
                 const char* key, size_t keylen, const char* val, size_t vallen,
                 char** errptr) {
1096 1097 1098 1099
  SaveError(errptr,
            db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
}

1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
void 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) {
  SaveError(errptr, db->rep->Put(options->rep, column_family->rep,
                                 Slice(key, keylen), Slice(val, vallen)));
}

void rocksdb_put_with_ts(rocksdb_t* db, const rocksdb_writeoptions_t* options,
                         const char* key, size_t keylen, const char* ts,
                         size_t tslen, const char* val, size_t vallen,
                         char** errptr) {
  SaveError(errptr, db->rep->Put(options->rep, Slice(key, keylen),
                                 Slice(ts, tslen), Slice(val, vallen)));
}

void rocksdb_put_cf_with_ts(rocksdb_t* db,
                            const rocksdb_writeoptions_t* options,
                            rocksdb_column_family_handle_t* column_family,
                            const char* key, size_t keylen, const char* ts,
                            size_t tslen, const char* val, size_t vallen,
                            char** errptr) {
R
Reed Allman 已提交
1122
  SaveError(errptr,
1123 1124
            db->rep->Put(options->rep, column_family->rep, Slice(key, keylen),
                         Slice(ts, tslen), Slice(val, vallen)));
R
Reed Allman 已提交
1125 1126
}

1127 1128
void rocksdb_delete(rocksdb_t* db, const rocksdb_writeoptions_t* options,
                    const char* key, size_t keylen, char** errptr) {
1129 1130 1131
  SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
}

1132 1133 1134
void 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) {
R
Reed Allman 已提交
1135
  SaveError(errptr, db->rep->Delete(options->rep, column_family->rep,
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
                                    Slice(key, keylen)));
}

void rocksdb_delete_with_ts(rocksdb_t* db,
                            const rocksdb_writeoptions_t* options,
                            const char* key, size_t keylen, const char* ts,
                            size_t tslen, char** errptr) {
  SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen),
                                    Slice(ts, tslen)));
}

void rocksdb_delete_cf_with_ts(rocksdb_t* db,
                               const rocksdb_writeoptions_t* options,
                               rocksdb_column_family_handle_t* column_family,
                               const char* key, size_t keylen, const char* ts,
                               size_t tslen, char** errptr) {
  SaveError(errptr, db->rep->Delete(options->rep, column_family->rep,
                                    Slice(key, keylen), Slice(ts, tslen)));
}

void rocksdb_singledelete(rocksdb_t* db, const rocksdb_writeoptions_t* options,
                          const char* key, size_t keylen, char** errptr) {
  SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen)));
}

void rocksdb_singledelete_cf(rocksdb_t* db,
                             const rocksdb_writeoptions_t* options,
                             rocksdb_column_family_handle_t* column_family,
                             const char* key, size_t keylen, char** errptr) {
  SaveError(errptr, db->rep->SingleDelete(options->rep, column_family->rep,
                                          Slice(key, keylen)));
}

void rocksdb_singledelete_with_ts(rocksdb_t* db,
                                  const rocksdb_writeoptions_t* options,
                                  const char* key, size_t keylen,
                                  const char* ts, size_t tslen, char** errptr) {
  SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen),
                                          Slice(ts, tslen)));
}

void rocksdb_singledelete_cf_with_ts(
    rocksdb_t* db, const rocksdb_writeoptions_t* options,
    rocksdb_column_family_handle_t* column_family, const char* key,
    size_t keylen, const char* ts, size_t tslen, char** errptr) {
  SaveError(errptr,
            db->rep->SingleDelete(options->rep, column_family->rep,
                                  Slice(key, keylen), Slice(ts, tslen)));
}

void rocksdb_increase_full_history_ts_low(
    rocksdb_t* db, rocksdb_column_family_handle_t* column_family,
    const char* ts_low, size_t ts_lowlen, char** errptr) {
  std::string ts(ts_low, ts_lowlen);
  SaveError(errptr, db->rep->IncreaseFullHistoryTsLow(column_family->rep, ts));
}

char* rocksdb_get_full_history_ts_low(
    rocksdb_t* db, rocksdb_column_family_handle_t* column_family,
    size_t* ts_len, char** errptr) {
  char* result = nullptr;
  std::string tmp;
  Status s = db->rep->GetFullHistoryTsLow(column_family->rep, &tmp);
  if (s.ok()) {
    *ts_len = tmp.size();
    result = CopyString(tmp);
  } else {
    *ts_len = 0;
    SaveError(errptr, s);
  }
  return result;
R
Reed Allman 已提交
1207 1208
}

Y
Yanqin Jin 已提交
1209 1210 1211 1212 1213 1214
void 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) {
1215
  SaveError(errptr, db->rep->DeleteRange(options->rep, column_family->rep,
Y
Yanqin Jin 已提交
1216 1217
                                         Slice(start_key, start_key_len),
                                         Slice(end_key, end_key_len)));
1218 1219
}

1220 1221 1222 1223 1224
void rocksdb_merge(rocksdb_t* db, const rocksdb_writeoptions_t* options,
                   const char* key, size_t keylen, const char* val,
                   size_t vallen, char** errptr) {
  SaveError(errptr, db->rep->Merge(options->rep, Slice(key, keylen),
                                   Slice(val, vallen)));
T
Thomas Adam 已提交
1225
}
1226

1227 1228 1229 1230
void 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) {
1231 1232
  SaveError(errptr, db->rep->Merge(options->rep, column_family->rep,
                                   Slice(key, keylen), Slice(val, vallen)));
R
Reed Allman 已提交
1233 1234
}

1235 1236
void rocksdb_write(rocksdb_t* db, const rocksdb_writeoptions_t* options,
                   rocksdb_writebatch_t* batch, char** errptr) {
1237 1238 1239
  SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
}

1240 1241 1242
char* rocksdb_get(rocksdb_t* db, const rocksdb_readoptions_t* options,
                  const char* key, size_t keylen, size_t* vallen,
                  char** errptr) {
1243
  char* result = nullptr;
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257
  std::string tmp;
  Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp);
  if (s.ok()) {
    *vallen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vallen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

1258 1259 1260 1261
char* 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) {
R
Reed Allman 已提交
1262 1263
  char* result = nullptr;
  std::string tmp;
1264 1265
  Status s =
      db->rep->Get(options->rep, column_family->rep, Slice(key, keylen), &tmp);
R
Reed Allman 已提交
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
  if (s.ok()) {
    *vallen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vallen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
char* rocksdb_get_with_ts(rocksdb_t* db, const rocksdb_readoptions_t* options,
                          const char* key, size_t keylen, size_t* vallen,
                          char** ts, size_t* tslen, char** errptr) {
  char* result = nullptr;
  std::string tmp_val;
  std::string tmp_ts;
  Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp_val, &tmp_ts);
  if (s.ok()) {
    *vallen = tmp_val.size();
    result = CopyString(tmp_val);
    *tslen = tmp_ts.size();
    *ts = CopyString(tmp_ts);
  } else {
    *vallen = 0;
    *tslen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

char* rocksdb_get_cf_with_ts(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** ts, size_t* tslen, char** errptr) {
  char* result = nullptr;
  std::string tmp;
  std::string tmp_ts;
  Status s = db->rep->Get(options->rep, column_family->rep, Slice(key, keylen),
                          &tmp, &tmp_ts);
  if (s.ok()) {
    *vallen = tmp.size();
    result = CopyString(tmp);
    *tslen = tmp_ts.size();
    *ts = CopyString(tmp_ts);
  } else {
    *vallen = 0;
    *tslen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

void 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) {
R
Reed Allman 已提交
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
  std::vector<Slice> keys(num_keys);
  for (size_t i = 0; i < num_keys; i++) {
    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<std::string> values(num_keys);
  std::vector<Status> statuses = db->rep->MultiGet(options->rep, keys, &values);
  for (size_t i = 0; i < num_keys; i++) {
    if (statuses[i].ok()) {
      values_list[i] = CopyString(values[i]);
      values_list_sizes[i] = values[i].size();
      errs[i] = nullptr;
    } else {
      values_list[i] = nullptr;
      values_list_sizes[i] = 0;
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }
}

1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
void rocksdb_multi_get_with_ts(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** timestamp_list,
                               size_t* timestamp_list_sizes, char** errs) {
  std::vector<Slice> keys(num_keys);
  for (size_t i = 0; i < num_keys; i++) {
    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<std::string> values(num_keys);
  std::vector<std::string> timestamps(num_keys);
  std::vector<Status> statuses =
      db->rep->MultiGet(options->rep, keys, &values, &timestamps);
  for (size_t i = 0; i < num_keys; i++) {
    if (statuses[i].ok()) {
      values_list[i] = CopyString(values[i]);
      values_list_sizes[i] = values[i].size();
      timestamp_list[i] = CopyString(timestamps[i]);
      timestamp_list_sizes[i] = timestamps[i].size();
      errs[i] = nullptr;
    } else {
      values_list[i] = nullptr;
      values_list_sizes[i] = 0;
      timestamp_list[i] = nullptr;
      timestamp_list_sizes[i] = 0;
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }
}

R
Reed Allman 已提交
1388
void rocksdb_multi_get_cf(
1389
    rocksdb_t* db, const rocksdb_readoptions_t* options,
R
Reed Allman 已提交
1390 1391
    const rocksdb_column_family_handle_t* const* column_families,
    size_t num_keys, const char* const* keys_list,
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
    const size_t* keys_list_sizes, char** values_list,
    size_t* values_list_sizes, char** errs) {
  std::vector<Slice> keys(num_keys);
  std::vector<ColumnFamilyHandle*> cfs(num_keys);
  for (size_t i = 0; i < num_keys; i++) {
    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
    cfs[i] = column_families[i]->rep;
  }
  std::vector<std::string> values(num_keys);
  std::vector<Status> statuses =
      db->rep->MultiGet(options->rep, cfs, keys, &values);
  for (size_t i = 0; i < num_keys; i++) {
    if (statuses[i].ok()) {
      values_list[i] = CopyString(values[i]);
      values_list_sizes[i] = values[i].size();
      errs[i] = nullptr;
    } else {
      values_list[i] = nullptr;
      values_list_sizes[i] = 0;
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }
}

void rocksdb_multi_get_cf_with_ts(
    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** timestamps_list,
    size_t* timestamps_list_sizes, char** errs) {
R
Reed Allman 已提交
1427 1428 1429 1430 1431 1432 1433
  std::vector<Slice> keys(num_keys);
  std::vector<ColumnFamilyHandle*> cfs(num_keys);
  for (size_t i = 0; i < num_keys; i++) {
    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
    cfs[i] = column_families[i]->rep;
  }
  std::vector<std::string> values(num_keys);
1434 1435 1436
  std::vector<std::string> timestamps(num_keys);
  std::vector<Status> statuses =
      db->rep->MultiGet(options->rep, cfs, keys, &values, &timestamps);
R
Reed Allman 已提交
1437 1438 1439 1440
  for (size_t i = 0; i < num_keys; i++) {
    if (statuses[i].ok()) {
      values_list[i] = CopyString(values[i]);
      values_list_sizes[i] = values[i].size();
1441 1442
      timestamps_list[i] = CopyString(timestamps[i]);
      timestamps_list_sizes[i] = timestamps[i].size();
R
Reed Allman 已提交
1443 1444 1445 1446
      errs[i] = nullptr;
    } else {
      values_list[i] = nullptr;
      values_list_sizes[i] = 0;
1447 1448
      timestamps_list[i] = nullptr;
      timestamps_list_sizes[i] = 0;
R
Reed Allman 已提交
1449 1450 1451 1452 1453 1454 1455 1456 1457
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }
}

1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494
void rocksdb_batched_multi_get_cf(rocksdb_t* db,
                                  const rocksdb_readoptions_t* options,
                                  rocksdb_column_family_handle_t* column_family,
                                  size_t num_keys, const char* const* keys_list,
                                  const size_t* keys_list_sizes,
                                  rocksdb_pinnableslice_t** values, char** errs,
                                  const bool sorted_input) {
  Slice* key_slices = new Slice[num_keys];
  PinnableSlice* value_slices = new PinnableSlice[num_keys];
  Status* statuses = new Status[num_keys];
  for (size_t i = 0; i < num_keys; ++i) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }

  db->rep->MultiGet(options->rep, column_family->rep, num_keys, key_slices,
                    value_slices, statuses, sorted_input);

  for (size_t i = 0; i < num_keys; ++i) {
    if (statuses[i].ok()) {
      values[i] = new (rocksdb_pinnableslice_t);
      values[i]->rep = std::move(value_slices[i]);
      errs[i] = nullptr;
    } else {
      values[i] = nullptr;
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }

  delete[] key_slices;
  delete[] value_slices;
  delete[] statuses;
}

1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
unsigned char rocksdb_key_may_exist(rocksdb_t* db,
                                    const rocksdb_readoptions_t* options,
                                    const char* key, size_t key_len,
                                    char** value, size_t* val_len,
                                    const char* timestamp, size_t timestamp_len,
                                    unsigned char* value_found) {
  std::string tmp;
  std::string time;
  if (timestamp) {
    time.assign(timestamp, timestamp_len);
  }
  bool found = false;
  const bool result = db->rep->KeyMayExist(options->rep, Slice(key, key_len),
                                           &tmp, timestamp ? &time : nullptr,
                                           value_found ? &found : nullptr);
  if (value_found) {
    *value_found = found;
    if (found) {
      *val_len = tmp.size();
      *value = CopyString(tmp);
    }
  }
  return result;
}

unsigned char rocksdb_key_may_exist_cf(
    rocksdb_t* db, const rocksdb_readoptions_t* options,
    rocksdb_column_family_handle_t* column_family, const char* key,
    size_t key_len, char** value, size_t* val_len, const char* timestamp,
    size_t timestamp_len, unsigned char* value_found) {
  std::string tmp;
  std::string time;
  if (timestamp) {
    time.assign(timestamp, timestamp_len);
  }
  bool found = false;
  const bool result = db->rep->KeyMayExist(
      options->rep, column_family->rep, Slice(key, key_len), &tmp,
      timestamp ? &time : nullptr, value_found ? &found : nullptr);
  if (value_found) {
    *value_found = found;
    if (found) {
      *val_len = tmp.size();
      *value = CopyString(tmp);
    }
  }
  return result;
}

1544
rocksdb_iterator_t* rocksdb_create_iterator(
1545
    rocksdb_t* db, const rocksdb_readoptions_t* options) {
1546
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
1547 1548 1549 1550
  result->rep = db->rep->NewIterator(options->rep);
  return result;
}

1551
rocksdb_wal_iterator_t* rocksdb_get_updates_since(
1552 1553
    rocksdb_t* db, uint64_t seq_number,
    const rocksdb_wal_readoptions_t* options, char** errptr) {
1554 1555
  std::unique_ptr<TransactionLogIterator> iter;
  TransactionLogIterator::ReadOptions ro;
1556 1557
  if (options != nullptr) {
    ro = options->rep;
1558 1559 1560 1561 1562 1563 1564 1565 1566
  }
  if (SaveError(errptr, db->rep->GetUpdatesSince(seq_number, &iter, ro))) {
    return nullptr;
  }
  rocksdb_wal_iterator_t* result = new rocksdb_wal_iterator_t;
  result->rep = iter.release();
  return result;
}

1567
void rocksdb_wal_iter_next(rocksdb_wal_iterator_t* iter) { iter->rep->Next(); }
1568 1569

unsigned char rocksdb_wal_iter_valid(const rocksdb_wal_iterator_t* iter) {
1570
  return iter->rep->Valid();
1571 1572
}

1573 1574 1575
void rocksdb_wal_iter_status(const rocksdb_wal_iterator_t* iter,
                             char** errptr) {
  SaveError(errptr, iter->rep->status());
1576 1577
}

1578
void rocksdb_wal_iter_destroy(const rocksdb_wal_iterator_t* iter) {
1579 1580 1581 1582
  delete iter->rep;
  delete iter;
}

1583 1584
rocksdb_writebatch_t* rocksdb_wal_iter_get_batch(
    const rocksdb_wal_iterator_t* iter, uint64_t* seq) {
1585 1586
  rocksdb_writebatch_t* result = rocksdb_writebatch_create();
  BatchResult wal_batch = iter->rep->GetBatch();
1587
  result->rep = std::move(*wal_batch.writeBatchPtr);
1588 1589 1590 1591 1592 1593
  if (seq != nullptr) {
    *seq = wal_batch.sequence;
  }
  return result;
}

1594 1595
uint64_t rocksdb_get_latest_sequence_number(rocksdb_t* db) {
  return db->rep->GetLatestSequenceNumber();
1596 1597
}

R
Reed Allman 已提交
1598
rocksdb_iterator_t* rocksdb_create_iterator_cf(
1599
    rocksdb_t* db, const rocksdb_readoptions_t* options,
R
Reed Allman 已提交
1600 1601 1602 1603 1604 1605
    rocksdb_column_family_handle_t* column_family) {
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
  result->rep = db->rep->NewIterator(options->rep, column_family->rep);
  return result;
}

1606 1607 1608 1609
void 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) {
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
  std::vector<ColumnFamilyHandle*> column_families_vec;
  for (size_t i = 0; i < size; i++) {
    column_families_vec.push_back(column_families[i]->rep);
  }

  std::vector<Iterator*> res;
  Status status = db->rep->NewIterators(opts->rep, column_families_vec, &res);
  assert(res.size() == size);
  if (SaveError(errptr, status)) {
    return;
  }

  for (size_t i = 0; i < size; i++) {
    iterators[i] = new rocksdb_iterator_t;
    iterators[i]->rep = res[i];
  }
}

1628
const rocksdb_snapshot_t* rocksdb_create_snapshot(rocksdb_t* db) {
1629
  rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
1630 1631 1632 1633
  result->rep = db->rep->GetSnapshot();
  return result;
}

1634 1635
void rocksdb_release_snapshot(rocksdb_t* db,
                              const rocksdb_snapshot_t* snapshot) {
1636 1637 1638 1639
  db->rep->ReleaseSnapshot(snapshot->rep);
  delete snapshot;
}

1640
char* rocksdb_property_value(rocksdb_t* db, const char* propname) {
1641 1642
  std::string tmp;
  if (db->rep->GetProperty(Slice(propname), &tmp)) {
1643 1644
    // We use strdup() since we expect human readable output.
    return strdup(tmp.c_str());
1645
  } else {
1646
    return nullptr;
1647 1648 1649
  }
}

1650 1651
int rocksdb_property_int(rocksdb_t* db, const char* propname,
                         uint64_t* out_val) {
O
oranagra 已提交
1652 1653 1654 1655 1656 1657 1658
  if (db->rep->GetIntProperty(Slice(propname), out_val)) {
    return 0;
  } else {
    return -1;
  }
}

1659 1660 1661
int rocksdb_property_int_cf(rocksdb_t* db,
                            rocksdb_column_family_handle_t* column_family,
                            const char* propname, uint64_t* out_val) {
D
David Palm 已提交
1662 1663 1664 1665 1666 1667 1668
  if (db->rep->GetIntProperty(column_family->rep, Slice(propname), out_val)) {
    return 0;
  } else {
    return -1;
  }
}

1669 1670 1671
char* rocksdb_property_value_cf(rocksdb_t* db,
                                rocksdb_column_family_handle_t* column_family,
                                const char* propname) {
R
Reed Allman 已提交
1672 1673 1674 1675 1676 1677 1678 1679 1680
  std::string tmp;
  if (db->rep->GetProperty(column_family->rep, Slice(propname), &tmp)) {
    // We use strdup() since we expect human readable output.
    return strdup(tmp.c_str());
  } else {
    return nullptr;
  }
}

1681 1682 1683 1684 1685 1686
void 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, char** errptr) {
1687 1688 1689 1690 1691
  Range* ranges = new Range[num_ranges];
  for (int i = 0; i < num_ranges; i++) {
    ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
    ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
  }
1692 1693 1694 1695
  Status s = db->rep->GetApproximateSizes(ranges, num_ranges, sizes);
  if (!s.ok()) {
    SaveError(errptr, s);
  }
1696 1697 1698
  delete[] ranges;
}

R
Reed Allman 已提交
1699
void rocksdb_approximate_sizes_cf(
1700 1701 1702 1703
    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, char** errptr) {
R
Reed Allman 已提交
1704 1705 1706 1707 1708
  Range* ranges = new Range[num_ranges];
  for (int i = 0; i < num_ranges; i++) {
    ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
    ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
  }
1709 1710 1711 1712 1713
  Status s = db->rep->GetApproximateSizes(column_family->rep, ranges,
                                          num_ranges, sizes);
  if (!s.ok()) {
    SaveError(errptr, s);
  }
R
Reed Allman 已提交
1714 1715 1716
  delete[] ranges;
}

1717
void rocksdb_delete_file(rocksdb_t* db, const char* name) {
A
Albert Strasheim 已提交
1718 1719 1720
  db->rep->DeleteFile(name);
}

1721
const rocksdb_livefiles_t* rocksdb_livefiles(rocksdb_t* db) {
A
Albert Strasheim 已提交
1722 1723 1724 1725 1726
  rocksdb_livefiles_t* result = new rocksdb_livefiles_t;
  db->rep->GetLiveFilesMetaData(&result->rep);
  return result;
}

1727 1728 1729
void rocksdb_compact_range(rocksdb_t* db, const char* start_key,
                           size_t start_key_len, const char* limit_key,
                           size_t limit_key_len) {
S
Sanjay Ghemawat 已提交
1730 1731
  Slice a, b;
  db->rep->CompactRange(
1732
      CompactRangeOptions(),
1733 1734 1735
      // Pass nullptr Slice if corresponding "const char*" is nullptr
      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
S
Sanjay Ghemawat 已提交
1736 1737
}

1738 1739 1740 1741
void 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) {
R
Reed Allman 已提交
1742 1743
  Slice a, b;
  db->rep->CompactRange(
1744
      CompactRangeOptions(), column_family->rep,
R
Reed Allman 已提交
1745 1746 1747 1748 1749
      // Pass nullptr Slice if corresponding "const char*" is nullptr
      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
}

1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
void rocksdb_suggest_compact_range(rocksdb_t* db, const char* start_key,
                                   size_t start_key_len, const char* limit_key,
                                   size_t limit_key_len, char** errptr) {
  Slice a, b;
  Status s = ROCKSDB_NAMESPACE::experimental::SuggestCompactRange(
      db->rep,
      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
  SaveError(errptr, s);
}

void rocksdb_suggest_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, char** errptr) {
  Slice a, b;
  Status s = db->rep->SuggestCompactRange(
      column_family->rep,
      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
  SaveError(errptr, s);
}

Z
zhangjinpeng1987 已提交
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796
void 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) {
  Slice a, b;
  db->rep->CompactRange(
      opt->rep,
      // Pass nullptr Slice if corresponding "const char*" is nullptr
      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
}

void 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) {
  Slice a, b;
  db->rep->CompactRange(
      opt->rep, column_family->rep,
      // Pass nullptr Slice if corresponding "const char*" is nullptr
      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
}

1797 1798
void rocksdb_flush(rocksdb_t* db, const rocksdb_flushoptions_t* options,
                   char** errptr) {
T
Thomas Adam 已提交
1799 1800 1801
  SaveError(errptr, db->rep->Flush(options->rep));
}

1802 1803 1804
void rocksdb_flush_cf(rocksdb_t* db, const rocksdb_flushoptions_t* options,
                      rocksdb_column_family_handle_t* column_family,
                      char** errptr) {
1805 1806 1807
  SaveError(errptr, db->rep->Flush(options->rep, column_family->rep));
}

1808 1809 1810 1811
void rocksdb_flush_wal(rocksdb_t* db, unsigned char sync, char** errptr) {
  SaveError(errptr, db->rep->FlushWAL(sync));
}

1812
void rocksdb_disable_file_deletions(rocksdb_t* db, char** errptr) {
T
Thomas Adam 已提交
1813 1814 1815
  SaveError(errptr, db->rep->DisableFileDeletions());
}

1816 1817
void rocksdb_enable_file_deletions(rocksdb_t* db, unsigned char force,
                                   char** errptr) {
T
Thomas Adam 已提交
1818 1819 1820
  SaveError(errptr, db->rep->EnableFileDeletions(force));
}

1821 1822
void rocksdb_destroy_db(const rocksdb_options_t* options, const char* name,
                        char** errptr) {
1823 1824 1825
  SaveError(errptr, DestroyDB(name, options->rep));
}

1826 1827
void rocksdb_repair_db(const rocksdb_options_t* options, const char* name,
                       char** errptr) {
1828 1829 1830
  SaveError(errptr, RepairDB(name, options->rep));
}

1831
void rocksdb_iter_destroy(rocksdb_iterator_t* iter) {
1832 1833 1834 1835
  delete iter->rep;
  delete iter;
}

1836
unsigned char rocksdb_iter_valid(const rocksdb_iterator_t* iter) {
1837 1838 1839
  return iter->rep->Valid();
}

1840
void rocksdb_iter_seek_to_first(rocksdb_iterator_t* iter) {
1841 1842 1843
  iter->rep->SeekToFirst();
}

1844
void rocksdb_iter_seek_to_last(rocksdb_iterator_t* iter) {
1845 1846 1847
  iter->rep->SeekToLast();
}

1848
void rocksdb_iter_seek(rocksdb_iterator_t* iter, const char* k, size_t klen) {
1849 1850 1851
  iter->rep->Seek(Slice(k, klen));
}

J
Jay Lee 已提交
1852 1853 1854 1855 1856
void rocksdb_iter_seek_for_prev(rocksdb_iterator_t* iter, const char* k,
                                size_t klen) {
  iter->rep->SeekForPrev(Slice(k, klen));
}

1857
void rocksdb_iter_next(rocksdb_iterator_t* iter) { iter->rep->Next(); }
1858

1859
void rocksdb_iter_prev(rocksdb_iterator_t* iter) { iter->rep->Prev(); }
1860

1861
const char* rocksdb_iter_key(const rocksdb_iterator_t* iter, size_t* klen) {
1862 1863 1864 1865 1866
  Slice s = iter->rep->key();
  *klen = s.size();
  return s.data();
}

1867
const char* rocksdb_iter_value(const rocksdb_iterator_t* iter, size_t* vlen) {
1868 1869 1870 1871 1872
  Slice s = iter->rep->value();
  *vlen = s.size();
  return s.data();
}

1873 1874 1875 1876 1877 1878 1879
const char* rocksdb_iter_timestamp(const rocksdb_iterator_t* iter,
                                   size_t* tslen) {
  Slice s = iter->rep->timestamp();
  *tslen = s.size();
  return s.data();
}

1880
void rocksdb_iter_get_error(const rocksdb_iterator_t* iter, char** errptr) {
1881 1882 1883
  SaveError(errptr, iter->rep->status());
}

1884 1885
rocksdb_writebatch_t* rocksdb_writebatch_create() {
  return new rocksdb_writebatch_t;
1886 1887
}

1888 1889 1890 1891 1892 1893 1894
rocksdb_writebatch_t* rocksdb_writebatch_create_from(const char* rep,
                                                     size_t size) {
  rocksdb_writebatch_t* b = new rocksdb_writebatch_t;
  b->rep = WriteBatch(std::string(rep, size));
  return b;
}

1895
void rocksdb_writebatch_destroy(rocksdb_writebatch_t* b) { delete b; }
1896

1897
void rocksdb_writebatch_clear(rocksdb_writebatch_t* b) { b->rep.Clear(); }
1898

1899
int rocksdb_writebatch_count(rocksdb_writebatch_t* b) { return b->rep.Count(); }
A
Albert Strasheim 已提交
1900

1901 1902
void rocksdb_writebatch_put(rocksdb_writebatch_t* b, const char* key,
                            size_t klen, const char* val, size_t vlen) {
1903 1904 1905
  b->rep.Put(Slice(key, klen), Slice(val, vlen));
}

1906 1907 1908 1909
void 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) {
R
Reed Allman 已提交
1910 1911 1912
  b->rep.Put(column_family->rep, Slice(key, klen), Slice(val, vlen));
}

1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925
void rocksdb_writebatch_put_cf_with_ts(
    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
    const char* key, size_t klen, const char* ts, size_t tslen, const char* val,
    size_t vlen) {
  b->rep.Put(column_family->rep, Slice(key, klen), Slice(ts, tslen),
             Slice(val, vlen));
}

void 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) {
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<Slice> value_slices(num_values);
  for (int i = 0; i < num_values; i++) {
    value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
  }
  b->rep.Put(SliceParts(key_slices.data(), num_keys),
             SliceParts(value_slices.data(), num_values));
}

1938 1939 1940 1941 1942 1943
void 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) {
1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<Slice> value_slices(num_values);
  for (int i = 0; i < num_values; i++) {
    value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
  }
  b->rep.Put(column_family->rep, SliceParts(key_slices.data(), num_keys),
             SliceParts(value_slices.data(), num_values));
}

1956 1957
void rocksdb_writebatch_merge(rocksdb_writebatch_t* b, const char* key,
                              size_t klen, const char* val, size_t vlen) {
T
Thomas Adam 已提交
1958 1959 1960
  b->rep.Merge(Slice(key, klen), Slice(val, vlen));
}

1961 1962 1963 1964
void 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) {
R
Reed Allman 已提交
1965 1966 1967
  b->rep.Merge(column_family->rep, Slice(key, klen), Slice(val, vlen));
}

1968 1969 1970 1971 1972
void 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) {
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<Slice> value_slices(num_values);
  for (int i = 0; i < num_values; i++) {
    value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
  }
  b->rep.Merge(SliceParts(key_slices.data(), num_keys),
               SliceParts(value_slices.data(), num_values));
}

1985 1986 1987 1988 1989 1990
void 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) {
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<Slice> value_slices(num_values);
  for (int i = 0; i < num_values; i++) {
    value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
  }
  b->rep.Merge(column_family->rep, SliceParts(key_slices.data(), num_keys),
               SliceParts(value_slices.data(), num_values));
}

2003 2004
void rocksdb_writebatch_delete(rocksdb_writebatch_t* b, const char* key,
                               size_t klen) {
2005 2006 2007
  b->rep.Delete(Slice(key, klen));
}

2008 2009 2010 2011 2012
void rocksdb_writebatch_singledelete(rocksdb_writebatch_t* b, const char* key,
                                     size_t klen) {
  b->rep.SingleDelete(Slice(key, klen));
}

2013 2014 2015
void rocksdb_writebatch_delete_cf(rocksdb_writebatch_t* b,
                                  rocksdb_column_family_handle_t* column_family,
                                  const char* key, size_t klen) {
R
Reed Allman 已提交
2016 2017 2018
  b->rep.Delete(column_family->rep, Slice(key, klen));
}

2019 2020 2021 2022 2023 2024
void rocksdb_writebatch_delete_cf_with_ts(
    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
    const char* key, size_t klen, const char* ts, size_t tslen) {
  b->rep.Delete(column_family->rep, Slice(key, klen), Slice(ts, tslen));
}

2025 2026 2027 2028 2029 2030
void rocksdb_writebatch_singledelete_cf(
    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
    const char* key, size_t klen) {
  b->rep.SingleDelete(column_family->rep, Slice(key, klen));
}

2031 2032 2033 2034 2035 2036 2037 2038 2039
void rocksdb_writebatch_singledelete_cf_with_ts(
    rocksdb_writebatch_t* b, rocksdb_column_family_handle_t* column_family,
    const char* key, size_t klen, const char* ts, size_t tslen) {
  b->rep.SingleDelete(column_family->rep, Slice(key, klen), Slice(ts, tslen));
}

void rocksdb_writebatch_deletev(rocksdb_writebatch_t* b, int num_keys,
                                const char* const* keys_list,
                                const size_t* keys_list_sizes) {
2040 2041 2042 2043 2044 2045 2046 2047
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  b->rep.Delete(SliceParts(key_slices.data(), num_keys));
}

void rocksdb_writebatch_deletev_cf(
2048 2049
    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) {
2050 2051 2052 2053 2054 2055 2056
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  b->rep.Delete(column_family->rep, SliceParts(key_slices.data(), num_keys));
}

2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
void 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) {
  b->rep.DeleteRange(Slice(start_key, start_key_len),
                     Slice(end_key, end_key_len));
}

void 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) {
  b->rep.DeleteRange(column_family->rep, Slice(start_key, start_key_len),
                     Slice(end_key, end_key_len));
}

void 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) {
  std::vector<Slice> start_key_slices(num_keys);
  std::vector<Slice> end_key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
    end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
  }
  b->rep.DeleteRange(SliceParts(start_key_slices.data(), num_keys),
                     SliceParts(end_key_slices.data(), num_keys));
}

void 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) {
  std::vector<Slice> start_key_slices(num_keys);
  std::vector<Slice> end_key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
    end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
  }
  b->rep.DeleteRange(column_family->rep,
                     SliceParts(start_key_slices.data(), num_keys),
                     SliceParts(end_key_slices.data(), num_keys));
}

2104 2105
void rocksdb_writebatch_put_log_data(rocksdb_writebatch_t* b, const char* blob,
                                     size_t len) {
2106 2107 2108
  b->rep.PutLogData(Slice(blob, len));
}

2109 2110 2111 2112 2113
class H : public WriteBatch::Handler {
 public:
  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);
2114
  void Put(const Slice& key, const Slice& value) override {
2115 2116
    (*put_)(state_, key.data(), key.size(), value.data(), value.size());
  }
2117
  void Delete(const Slice& key) override {
2118 2119 2120 2121
    (*deleted_)(state_, key.data(), key.size());
  }
};

2122 2123 2124 2125 2126
void 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)) {
2127 2128 2129 2130 2131 2132 2133
  H handler;
  handler.state_ = state;
  handler.put_ = put;
  handler.deleted_ = deleted;
  b->rep.Iterate(&handler);
}

A
Albert Strasheim 已提交
2134 2135 2136 2137 2138
const char* rocksdb_writebatch_data(rocksdb_writebatch_t* b, size_t* size) {
  *size = b->rep.GetDataSize();
  return b->rep.Data().c_str();
}

J
Jay Lee 已提交
2139 2140 2141 2142 2143 2144 2145 2146 2147
void rocksdb_writebatch_set_save_point(rocksdb_writebatch_t* b) {
  b->rep.SetSavePoint();
}

void rocksdb_writebatch_rollback_to_save_point(rocksdb_writebatch_t* b,
                                               char** errptr) {
  SaveError(errptr, b->rep.RollbackToSavePoint());
}

S
siddontang 已提交
2148 2149 2150 2151
void rocksdb_writebatch_pop_save_point(rocksdb_writebatch_t* b, char** errptr) {
  SaveError(errptr, b->rep.PopSavePoint());
}

2152 2153
rocksdb_writebatch_wi_t* rocksdb_writebatch_wi_create(
    size_t reserved_bytes, unsigned char overwrite_key) {
2154
  rocksdb_writebatch_wi_t* b = new rocksdb_writebatch_wi_t;
2155 2156
  b->rep = new WriteBatchWithIndex(BytewiseComparator(), reserved_bytes,
                                   overwrite_key);
2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174
  return b;
}

void rocksdb_writebatch_wi_destroy(rocksdb_writebatch_wi_t* b) {
  if (b->rep) {
    delete b->rep;
  }
  delete b;
}

void rocksdb_writebatch_wi_clear(rocksdb_writebatch_wi_t* b) {
  b->rep->Clear();
}

int rocksdb_writebatch_wi_count(rocksdb_writebatch_wi_t* b) {
  return b->rep->GetWriteBatch()->Count();
}

2175 2176
void rocksdb_writebatch_wi_put(rocksdb_writebatch_wi_t* b, const char* key,
                               size_t klen, const char* val, size_t vlen) {
2177 2178 2179
  b->rep->Put(Slice(key, klen), Slice(val, vlen));
}

2180 2181 2182 2183
void 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) {
2184 2185 2186
  b->rep->Put(column_family->rep, Slice(key, klen), Slice(val, vlen));
}

2187 2188 2189 2190 2191
void 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) {
2192 2193 2194 2195 2196 2197 2198 2199 2200
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<Slice> value_slices(num_values);
  for (int i = 0; i < num_values; i++) {
    value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
  }
  b->rep->Put(SliceParts(key_slices.data(), num_keys),
2201
              SliceParts(value_slices.data(), num_values));
2202 2203 2204
}

void rocksdb_writebatch_wi_putv_cf(
2205 2206
    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,
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
    int num_values, const char* const* values_list,
    const size_t* values_list_sizes) {
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<Slice> value_slices(num_values);
  for (int i = 0; i < num_values; i++) {
    value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
  }
  b->rep->Put(column_family->rep, SliceParts(key_slices.data(), num_keys),
2218
              SliceParts(value_slices.data(), num_values));
2219 2220
}

2221 2222
void rocksdb_writebatch_wi_merge(rocksdb_writebatch_wi_t* b, const char* key,
                                 size_t klen, const char* val, size_t vlen) {
2223 2224 2225 2226
  b->rep->Merge(Slice(key, klen), Slice(val, vlen));
}

void rocksdb_writebatch_wi_merge_cf(
2227 2228
    rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
    const char* key, size_t klen, const char* val, size_t vlen) {
2229 2230 2231
  b->rep->Merge(column_family->rep, Slice(key, klen), Slice(val, vlen));
}

2232 2233 2234 2235 2236
void 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) {
2237 2238 2239 2240 2241 2242 2243 2244 2245
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<Slice> value_slices(num_values);
  for (int i = 0; i < num_values; i++) {
    value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
  }
  b->rep->Merge(SliceParts(key_slices.data(), num_keys),
2246
                SliceParts(value_slices.data(), num_values));
2247 2248 2249
}

void rocksdb_writebatch_wi_mergev_cf(
2250 2251
    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,
2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262
    int num_values, const char* const* values_list,
    const size_t* values_list_sizes) {
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<Slice> value_slices(num_values);
  for (int i = 0; i < num_values; i++) {
    value_slices[i] = Slice(values_list[i], values_list_sizes[i]);
  }
  b->rep->Merge(column_family->rep, SliceParts(key_slices.data(), num_keys),
2263
                SliceParts(value_slices.data(), num_values));
2264 2265
}

2266 2267
void rocksdb_writebatch_wi_delete(rocksdb_writebatch_wi_t* b, const char* key,
                                  size_t klen) {
2268 2269 2270
  b->rep->Delete(Slice(key, klen));
}

2271 2272 2273 2274 2275
void rocksdb_writebatch_wi_singledelete(rocksdb_writebatch_wi_t* b,
                                        const char* key, size_t klen) {
  b->rep->SingleDelete(Slice(key, klen));
}

2276
void rocksdb_writebatch_wi_delete_cf(
2277
    rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
2278 2279 2280 2281
    const char* key, size_t klen) {
  b->rep->Delete(column_family->rep, Slice(key, klen));
}

2282 2283 2284 2285 2286 2287
void rocksdb_writebatch_wi_singledelete_cf(
    rocksdb_writebatch_wi_t* b, rocksdb_column_family_handle_t* column_family,
    const char* key, size_t klen) {
  b->rep->SingleDelete(column_family->rep, Slice(key, klen));
}

2288 2289 2290
void rocksdb_writebatch_wi_deletev(rocksdb_writebatch_wi_t* b, int num_keys,
                                   const char* const* keys_list,
                                   const size_t* keys_list_sizes) {
2291 2292 2293 2294 2295 2296 2297 2298
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  b->rep->Delete(SliceParts(key_slices.data(), num_keys));
}

void rocksdb_writebatch_wi_deletev_cf(
2299 2300
    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) {
2301 2302 2303 2304 2305 2306 2307 2308
  std::vector<Slice> key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    key_slices[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  b->rep->Delete(column_family->rep, SliceParts(key_slices.data(), num_keys));
}

void rocksdb_writebatch_wi_delete_range(rocksdb_writebatch_wi_t* b,
2309 2310 2311 2312
                                        const char* start_key,
                                        size_t start_key_len,
                                        const char* end_key,
                                        size_t end_key_len) {
2313
  b->rep->DeleteRange(Slice(start_key, start_key_len),
2314
                      Slice(end_key, end_key_len));
2315 2316 2317 2318 2319 2320 2321
}

void 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) {
  b->rep->DeleteRange(column_family->rep, Slice(start_key, start_key_len),
2322
                      Slice(end_key, end_key_len));
2323 2324
}

2325 2326 2327 2328 2329 2330
void 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) {
2331 2332 2333 2334 2335 2336 2337
  std::vector<Slice> start_key_slices(num_keys);
  std::vector<Slice> end_key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
    end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
  }
  b->rep->DeleteRange(SliceParts(start_key_slices.data(), num_keys),
2338
                      SliceParts(end_key_slices.data(), num_keys));
2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352
}

void 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) {
  std::vector<Slice> start_key_slices(num_keys);
  std::vector<Slice> end_key_slices(num_keys);
  for (int i = 0; i < num_keys; i++) {
    start_key_slices[i] = Slice(start_keys_list[i], start_keys_list_sizes[i]);
    end_key_slices[i] = Slice(end_keys_list[i], end_keys_list_sizes[i]);
  }
  b->rep->DeleteRange(column_family->rep,
2353 2354
                      SliceParts(start_key_slices.data(), num_keys),
                      SliceParts(end_key_slices.data(), num_keys));
2355 2356
}

2357 2358
void rocksdb_writebatch_wi_put_log_data(rocksdb_writebatch_wi_t* b,
                                        const char* blob, size_t len) {
2359 2360 2361 2362
  b->rep->PutLogData(Slice(blob, len));
}

void rocksdb_writebatch_wi_iterate(
2363
    rocksdb_writebatch_wi_t* b, void* state,
2364 2365 2366 2367 2368 2369 2370 2371 2372
    void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
    void (*deleted)(void*, const char* k, size_t klen)) {
  H handler;
  handler.state_ = state;
  handler.put_ = put;
  handler.deleted_ = deleted;
  b->rep->GetWriteBatch()->Iterate(&handler);
}

2373 2374
const char* rocksdb_writebatch_wi_data(rocksdb_writebatch_wi_t* b,
                                       size_t* size) {
2375 2376 2377 2378 2379 2380 2381 2382 2383 2384
  WriteBatch* wb = b->rep->GetWriteBatch();
  *size = wb->GetDataSize();
  return wb->Data().c_str();
}

void rocksdb_writebatch_wi_set_save_point(rocksdb_writebatch_wi_t* b) {
  b->rep->SetSavePoint();
}

void rocksdb_writebatch_wi_rollback_to_save_point(rocksdb_writebatch_wi_t* b,
2385
                                                  char** errptr) {
2386 2387 2388 2389
  SaveError(errptr, b->rep->RollbackToSavePoint());
}

rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base(
2390
    rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator) {
2391
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
2392
  result->rep = wbwi->rep->NewIteratorWithBase(base_iterator->rep);
2393 2394 2395 2396
  delete base_iterator;
  return result;
}

2397
rocksdb_iterator_t* rocksdb_writebatch_wi_create_iterator_with_base_cf(
2398
    rocksdb_writebatch_wi_t* wbwi, rocksdb_iterator_t* base_iterator,
2399 2400
    rocksdb_column_family_handle_t* column_family) {
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
2401 2402
  result->rep =
      wbwi->rep->NewIteratorWithBase(column_family->rep, base_iterator->rep);
2403 2404 2405 2406
  delete base_iterator;
  return result;
}

2407 2408 2409 2410
char* 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) {
2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
  char* result = nullptr;
  std::string tmp;
  Status s = wbwi->rep->GetFromBatch(options->rep, Slice(key, keylen), &tmp);
  if (s.ok()) {
    *vallen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vallen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

char* rocksdb_writebatch_wi_get_from_batch_cf(
2427 2428 2429
    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) {
2430 2431 2432
  char* result = nullptr;
  std::string tmp;
  Status s = wbwi->rep->GetFromBatch(column_family->rep, options->rep,
2433
                                     Slice(key, keylen), &tmp);
2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
  if (s.ok()) {
    *vallen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vallen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

char* rocksdb_writebatch_wi_get_from_batch_and_db(
2447 2448 2449
    rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db,
    const rocksdb_readoptions_t* options, const char* key, size_t keylen,
    size_t* vallen, char** errptr) {
2450 2451
  char* result = nullptr;
  std::string tmp;
2452 2453
  Status s = wbwi->rep->GetFromBatchAndDB(db->rep, options->rep,
                                          Slice(key, keylen), &tmp);
2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466
  if (s.ok()) {
    *vallen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vallen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

char* rocksdb_writebatch_wi_get_from_batch_and_db_cf(
2467
    rocksdb_writebatch_wi_t* wbwi, rocksdb_t* db,
2468
    const rocksdb_readoptions_t* options,
2469 2470
    rocksdb_column_family_handle_t* column_family, const char* key,
    size_t keylen, size_t* vallen, char** errptr) {
2471 2472
  char* result = nullptr;
  std::string tmp;
2473 2474
  Status s = wbwi->rep->GetFromBatchAndDB(
      db->rep, options->rep, column_family->rep, Slice(key, keylen), &tmp);
2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
  if (s.ok()) {
    *vallen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vallen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

2487 2488 2489
void rocksdb_write_writebatch_wi(rocksdb_t* db,
                                 const rocksdb_writeoptions_t* options,
                                 rocksdb_writebatch_wi_t* wbwi, char** errptr) {
2490 2491 2492 2493
  WriteBatch* wb = wbwi->rep->GetWriteBatch();
  SaveError(errptr, db->rep->Write(options->rep, wb));
}

2494 2495 2496 2497 2498 2499 2500
void rocksdb_load_latest_options(
    const char* db_path, rocksdb_env_t* env, bool ignore_unknown_options,
    rocksdb_cache_t* cache, rocksdb_options_t** db_options,
    size_t* num_column_families, char*** list_column_family_names,
    rocksdb_options_t*** list_column_family_options, char** errptr) {
  DBOptions db_opt;
  std::vector<ColumnFamilyDescriptor> cf_descs;
2501 2502 2503 2504 2505 2506
  ConfigOptions config_opts;
  config_opts.ignore_unknown_options = ignore_unknown_options;
  config_opts.input_strings_escaped = true;
  config_opts.env = env->rep;
  Status s = LoadLatestOptions(config_opts, std::string(db_path), &db_opt,
                               &cf_descs, &cache->rep);
2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547
  if (s.ok()) {
    char** cf_names = (char**)malloc(cf_descs.size() * sizeof(char*));
    rocksdb_options_t** cf_options = (rocksdb_options_t**)malloc(
        cf_descs.size() * sizeof(rocksdb_options_t*));
    for (size_t i = 0; i < cf_descs.size(); ++i) {
      cf_names[i] = strdup(cf_descs[i].name.c_str());
      cf_options[i] = new rocksdb_options_t{
          Options(DBOptions(), std::move(cf_descs[i].options))};
    }
    *num_column_families = cf_descs.size();
    *db_options = new rocksdb_options_t{
        Options(std::move(db_opt), ColumnFamilyOptions())};
    *list_column_family_names = cf_names;
    *list_column_family_options = cf_options;
  } else {
    *num_column_families = 0;
    *db_options = nullptr;
    *list_column_family_names = nullptr;
    *list_column_family_options = nullptr;
    SaveError(errptr, s);
  }
}

void rocksdb_load_latest_options_destroy(
    rocksdb_options_t* db_options, char** list_column_family_names,
    rocksdb_options_t** list_column_family_options, size_t len) {
  rocksdb_options_destroy(db_options);
  if (list_column_family_names) {
    for (size_t i = 0; i < len; ++i) {
      free(list_column_family_names[i]);
    }
    free(list_column_family_names);
  }
  if (list_column_family_options) {
    for (size_t i = 0; i < len; ++i) {
      rocksdb_options_destroy(list_column_family_options[i]);
    }
    free(list_column_family_options);
  }
}

2548
rocksdb_block_based_table_options_t* rocksdb_block_based_options_create() {
2549 2550 2551 2552 2553 2554
  return new rocksdb_block_based_table_options_t;
}

void rocksdb_block_based_options_destroy(
    rocksdb_block_based_table_options_t* options) {
  delete options;
2555 2556 2557 2558 2559
}

void rocksdb_block_based_options_set_checksum(
    rocksdb_block_based_table_options_t* opt, char v) {
  opt->rep.checksum = static_cast<ROCKSDB_NAMESPACE::ChecksumType>(v);
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
}

void rocksdb_block_based_options_set_block_size(
    rocksdb_block_based_table_options_t* options, size_t block_size) {
  options->rep.block_size = block_size;
}

void rocksdb_block_based_options_set_block_size_deviation(
    rocksdb_block_based_table_options_t* options, int block_size_deviation) {
  options->rep.block_size_deviation = block_size_deviation;
}

void rocksdb_block_based_options_set_block_restart_interval(
    rocksdb_block_based_table_options_t* options, int block_restart_interval) {
  options->rep.block_restart_interval = block_restart_interval;
}

2577
void rocksdb_block_based_options_set_index_block_restart_interval(
2578 2579
    rocksdb_block_based_table_options_t* options,
    int index_block_restart_interval) {
2580 2581 2582 2583
  options->rep.index_block_restart_interval = index_block_restart_interval;
}

void rocksdb_block_based_options_set_metadata_block_size(
2584 2585
    rocksdb_block_based_table_options_t* options,
    uint64_t metadata_block_size) {
2586 2587 2588 2589
  options->rep.metadata_block_size = metadata_block_size;
}

void rocksdb_block_based_options_set_partition_filters(
2590 2591
    rocksdb_block_based_table_options_t* options,
    unsigned char partition_filters) {
2592 2593 2594
  options->rep.partition_filters = partition_filters;
}

2595 2596 2597 2598 2599 2600
void rocksdb_block_based_options_set_optimize_filters_for_memory(
    rocksdb_block_based_table_options_t* options,
    unsigned char optimize_filters_for_memory) {
  options->rep.optimize_filters_for_memory = optimize_filters_for_memory;
}

2601
void rocksdb_block_based_options_set_use_delta_encoding(
2602 2603
    rocksdb_block_based_table_options_t* options,
    unsigned char use_delta_encoding) {
2604 2605 2606
  options->rep.use_delta_encoding = use_delta_encoding;
}

2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
void rocksdb_block_based_options_set_filter_policy(
    rocksdb_block_based_table_options_t* options,
    rocksdb_filterpolicy_t* filter_policy) {
  options->rep.filter_policy.reset(filter_policy);
}

void rocksdb_block_based_options_set_no_block_cache(
    rocksdb_block_based_table_options_t* options,
    unsigned char no_block_cache) {
  options->rep.no_block_cache = no_block_cache;
}

void rocksdb_block_based_options_set_block_cache(
    rocksdb_block_based_table_options_t* options,
    rocksdb_cache_t* block_cache) {
  if (block_cache) {
    options->rep.block_cache = block_cache->rep;
  }
}

void rocksdb_block_based_options_set_whole_key_filtering(
    rocksdb_block_based_table_options_t* options, unsigned char v) {
  options->rep.whole_key_filtering = v;
}

2632 2633 2634 2635 2636 2637 2638 2639 2640 2641
void rocksdb_block_based_options_set_format_version(
    rocksdb_block_based_table_options_t* options, int v) {
  options->rep.format_version = v;
}

void rocksdb_block_based_options_set_index_type(
    rocksdb_block_based_table_options_t* options, int v) {
  options->rep.index_type = static_cast<BlockBasedTableOptions::IndexType>(v);
}

2642 2643 2644
void rocksdb_block_based_options_set_data_block_index_type(
    rocksdb_block_based_table_options_t* options, int v) {
  options->rep.data_block_index_type =
2645
      static_cast<BlockBasedTableOptions::DataBlockIndexType>(v);
2646 2647 2648 2649 2650 2651 2652
}

void rocksdb_block_based_options_set_data_block_hash_ratio(
    rocksdb_block_based_table_options_t* options, double v) {
  options->rep.data_block_hash_table_util_ratio = v;
}

2653 2654 2655 2656 2657
void rocksdb_block_based_options_set_cache_index_and_filter_blocks(
    rocksdb_block_based_table_options_t* options, unsigned char v) {
  options->rep.cache_index_and_filter_blocks = v;
}

2658 2659 2660 2661 2662
void rocksdb_block_based_options_set_cache_index_and_filter_blocks_with_high_priority(
    rocksdb_block_based_table_options_t* options, unsigned char v) {
  options->rep.cache_index_and_filter_blocks_with_high_priority = v;
}

2663 2664 2665 2666 2667
void rocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(
    rocksdb_block_based_table_options_t* options, unsigned char v) {
  options->rep.pin_l0_filter_and_index_blocks_in_cache = v;
}

2668 2669 2670 2671 2672
void rocksdb_block_based_options_set_pin_top_level_index_and_filter(
    rocksdb_block_based_table_options_t* options, unsigned char v) {
  options->rep.pin_top_level_index_and_filter = v;
}

2673
void rocksdb_options_set_block_based_table_factory(
2674
    rocksdb_options_t* opt,
2675 2676 2677
    rocksdb_block_based_table_options_t* table_options) {
  if (table_options) {
    opt->rep.table_factory.reset(
2678
        ROCKSDB_NAMESPACE::NewBlockBasedTableFactory(table_options->rep));
2679 2680 2681
  }
}

2682
rocksdb_cuckoo_table_options_t* rocksdb_cuckoo_options_create() {
2683 2684 2685
  return new rocksdb_cuckoo_table_options_t;
}

2686
void rocksdb_cuckoo_options_destroy(rocksdb_cuckoo_table_options_t* options) {
2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
  delete options;
}

void rocksdb_cuckoo_options_set_hash_ratio(
    rocksdb_cuckoo_table_options_t* options, double v) {
  options->rep.hash_table_ratio = v;
}

void rocksdb_cuckoo_options_set_max_search_depth(
    rocksdb_cuckoo_table_options_t* options, uint32_t v) {
  options->rep.max_search_depth = v;
}

void rocksdb_cuckoo_options_set_cuckoo_block_size(
    rocksdb_cuckoo_table_options_t* options, uint32_t v) {
  options->rep.cuckoo_block_size = v;
}

void rocksdb_cuckoo_options_set_identity_as_first_hash(
    rocksdb_cuckoo_table_options_t* options, unsigned char v) {
  options->rep.identity_as_first_hash = v;
}

void rocksdb_cuckoo_options_set_use_module_hash(
    rocksdb_cuckoo_table_options_t* options, unsigned char v) {
  options->rep.use_module_hash = v;
}

void rocksdb_options_set_cuckoo_table_factory(
2716
    rocksdb_options_t* opt, rocksdb_cuckoo_table_options_t* table_options) {
2717 2718
  if (table_options) {
    opt->rep.table_factory.reset(
2719
        ROCKSDB_NAMESPACE::NewCuckooTableFactory(table_options->rep));
2720 2721 2722
  }
}

2723 2724 2725 2726 2727
void rocksdb_set_options(rocksdb_t* db, int count, const char* const keys[],
                         const char* const values[], char** errptr) {
  std::unordered_map<std::string, std::string> options_map;
  for (int i = 0; i < count; i++) options_map[keys[i]] = values[i];
  SaveError(errptr, db->rep->SetOptions(options_map));
2728 2729
}

2730 2731 2732 2733 2734 2735 2736
void 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) {
  std::unordered_map<std::string, std::string> options_map;
  for (int i = 0; i < count; i++) options_map[keys[i]] = values[i];
  SaveError(errptr, db->rep->SetOptions(handle->rep, options_map));
2737 2738
}

2739 2740 2741 2742
rocksdb_options_t* rocksdb_options_create() { return new rocksdb_options_t; }

void rocksdb_options_destroy(rocksdb_options_t* options) { delete options; }

2743 2744 2745 2746
rocksdb_options_t* rocksdb_options_create_copy(rocksdb_options_t* options) {
  return new rocksdb_options_t(*options);
}

2747 2748
void rocksdb_options_increase_parallelism(rocksdb_options_t* opt,
                                          int total_threads) {
2749 2750 2751
  opt->rep.IncreaseParallelism(total_threads);
}

2752 2753
void rocksdb_options_optimize_for_point_lookup(rocksdb_options_t* opt,
                                               uint64_t block_cache_size_mb) {
L
Lei Jin 已提交
2754
  opt->rep.OptimizeForPointLookup(block_cache_size_mb);
2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
}

void rocksdb_options_optimize_level_style_compaction(
    rocksdb_options_t* opt, uint64_t memtable_memory_budget) {
  opt->rep.OptimizeLevelStyleCompaction(memtable_memory_budget);
}

void rocksdb_options_optimize_universal_style_compaction(
    rocksdb_options_t* opt, uint64_t memtable_memory_budget) {
  opt->rep.OptimizeUniversalStyleCompaction(memtable_memory_budget);
}

2767 2768
void rocksdb_options_set_allow_ingest_behind(rocksdb_options_t* opt,
                                             unsigned char v) {
2769 2770 2771
  opt->rep.allow_ingest_behind = v;
}

2772 2773 2774 2775
unsigned char rocksdb_options_get_allow_ingest_behind(rocksdb_options_t* opt) {
  return opt->rep.allow_ingest_behind;
}

2776 2777
void rocksdb_options_set_compaction_filter(rocksdb_options_t* opt,
                                           rocksdb_compactionfilter_t* filter) {
2778 2779 2780
  opt->rep.compaction_filter = filter;
}

2781 2782 2783 2784 2785 2786
void rocksdb_options_set_compaction_filter_factory(
    rocksdb_options_t* opt, rocksdb_compactionfilterfactory_t* factory) {
  opt->rep.compaction_filter_factory =
      std::shared_ptr<CompactionFilterFactory>(factory);
}

2787 2788
void rocksdb_options_compaction_readahead_size(rocksdb_options_t* opt,
                                               size_t s) {
2789 2790 2791
  opt->rep.compaction_readahead_size = s;
}

2792 2793 2794 2795
size_t rocksdb_options_get_compaction_readahead_size(rocksdb_options_t* opt) {
  return opt->rep.compaction_readahead_size;
}

2796 2797
void rocksdb_options_set_comparator(rocksdb_options_t* opt,
                                    rocksdb_comparator_t* cmp) {
2798 2799 2800
  opt->rep.comparator = cmp;
}

I
Igor Canadi 已提交
2801
void rocksdb_options_set_merge_operator(
2802
    rocksdb_options_t* opt, rocksdb_mergeoperator_t* merge_operator) {
T
Thomas Adam 已提交
2803 2804 2805
  opt->rep.merge_operator = std::shared_ptr<MergeOperator>(merge_operator);
}

2806 2807
void rocksdb_options_set_create_if_missing(rocksdb_options_t* opt,
                                           unsigned char v) {
2808 2809 2810
  opt->rep.create_if_missing = v;
}

2811 2812 2813 2814
unsigned char rocksdb_options_get_create_if_missing(rocksdb_options_t* opt) {
  return opt->rep.create_if_missing;
}

2815 2816
void rocksdb_options_set_create_missing_column_families(rocksdb_options_t* opt,
                                                        unsigned char v) {
2817 2818 2819
  opt->rep.create_missing_column_families = v;
}

2820 2821 2822 2823 2824
unsigned char rocksdb_options_get_create_missing_column_families(
    rocksdb_options_t* opt) {
  return opt->rep.create_missing_column_families;
}

2825 2826
void rocksdb_options_set_error_if_exists(rocksdb_options_t* opt,
                                         unsigned char v) {
2827 2828 2829
  opt->rep.error_if_exists = v;
}

2830 2831 2832 2833
unsigned char rocksdb_options_get_error_if_exists(rocksdb_options_t* opt) {
  return opt->rep.error_if_exists;
}

2834 2835
void rocksdb_options_set_paranoid_checks(rocksdb_options_t* opt,
                                         unsigned char v) {
2836 2837 2838
  opt->rep.paranoid_checks = v;
}

2839 2840 2841 2842
unsigned char rocksdb_options_get_paranoid_checks(rocksdb_options_t* opt) {
  return opt->rep.paranoid_checks;
}

2843 2844
void rocksdb_options_set_db_paths(rocksdb_options_t* opt,
                                  const rocksdb_dbpath_t** dbpath_values,
K
kapitan-k 已提交
2845 2846 2847 2848 2849 2850 2851 2852
                                  size_t num_paths) {
  std::vector<DbPath> db_paths(num_paths);
  for (size_t i = 0; i < num_paths; ++i) {
    db_paths[i] = dbpath_values[i]->rep;
  }
  opt->rep.db_paths = db_paths;
}

2853
void rocksdb_options_set_env(rocksdb_options_t* opt, rocksdb_env_t* env) {
2854
  opt->rep.env = (env ? env->rep : nullptr);
2855 2856
}

2857
void rocksdb_options_set_info_log(rocksdb_options_t* opt, rocksdb_logger_t* l) {
2858 2859 2860
  if (l) {
    opt->rep.info_log = l->rep;
  }
2861 2862
}

2863
void rocksdb_options_set_info_log_level(rocksdb_options_t* opt, int v) {
T
Thomas Adam 已提交
2864 2865 2866
  opt->rep.info_log_level = static_cast<InfoLogLevel>(v);
}

2867 2868 2869 2870
int rocksdb_options_get_info_log_level(rocksdb_options_t* opt) {
  return static_cast<int>(opt->rep.info_log_level);
}

2871 2872 2873 2874 2875
void rocksdb_options_set_db_write_buffer_size(rocksdb_options_t* opt,
                                              size_t s) {
  opt->rep.db_write_buffer_size = s;
}

2876 2877 2878 2879
size_t rocksdb_options_get_db_write_buffer_size(rocksdb_options_t* opt) {
  return opt->rep.db_write_buffer_size;
}

2880
void rocksdb_options_set_write_buffer_size(rocksdb_options_t* opt, size_t s) {
2881 2882 2883
  opt->rep.write_buffer_size = s;
}

2884 2885 2886 2887
size_t rocksdb_options_get_write_buffer_size(rocksdb_options_t* opt) {
  return opt->rep.write_buffer_size;
}

2888
void rocksdb_options_set_max_open_files(rocksdb_options_t* opt, int n) {
2889 2890 2891
  opt->rep.max_open_files = n;
}

2892 2893 2894 2895
int rocksdb_options_get_max_open_files(rocksdb_options_t* opt) {
  return opt->rep.max_open_files;
}

2896 2897
void rocksdb_options_set_max_file_opening_threads(rocksdb_options_t* opt,
                                                  int n) {
2898 2899 2900
  opt->rep.max_file_opening_threads = n;
}

2901 2902 2903 2904
int rocksdb_options_get_max_file_opening_threads(rocksdb_options_t* opt) {
  return opt->rep.max_file_opening_threads;
}

2905 2906
void rocksdb_options_set_max_total_wal_size(rocksdb_options_t* opt,
                                            uint64_t n) {
R
Reed Allman 已提交
2907 2908 2909
  opt->rep.max_total_wal_size = n;
}

2910 2911 2912 2913
uint64_t rocksdb_options_get_max_total_wal_size(rocksdb_options_t* opt) {
  return opt->rep.max_total_wal_size;
}

2914 2915
void rocksdb_options_set_target_file_size_base(rocksdb_options_t* opt,
                                               uint64_t n) {
2916 2917 2918
  opt->rep.target_file_size_base = n;
}

2919 2920 2921 2922
uint64_t rocksdb_options_get_target_file_size_base(rocksdb_options_t* opt) {
  return opt->rep.target_file_size_base;
}

2923 2924
void rocksdb_options_set_target_file_size_multiplier(rocksdb_options_t* opt,
                                                     int n) {
2925 2926 2927
  opt->rep.target_file_size_multiplier = n;
}

2928 2929 2930 2931
int rocksdb_options_get_target_file_size_multiplier(rocksdb_options_t* opt) {
  return opt->rep.target_file_size_multiplier;
}

2932 2933
void rocksdb_options_set_max_bytes_for_level_base(rocksdb_options_t* opt,
                                                  uint64_t n) {
2934 2935 2936
  opt->rep.max_bytes_for_level_base = n;
}

2937 2938 2939 2940
uint64_t rocksdb_options_get_max_bytes_for_level_base(rocksdb_options_t* opt) {
  return opt->rep.max_bytes_for_level_base;
}

2941 2942 2943 2944 2945
void rocksdb_options_set_level_compaction_dynamic_level_bytes(
    rocksdb_options_t* opt, unsigned char v) {
  opt->rep.level_compaction_dynamic_level_bytes = v;
}

2946 2947 2948 2949 2950
unsigned char rocksdb_options_get_level_compaction_dynamic_level_bytes(
    rocksdb_options_t* opt) {
  return opt->rep.level_compaction_dynamic_level_bytes;
}

2951 2952
void rocksdb_options_set_max_bytes_for_level_multiplier(rocksdb_options_t* opt,
                                                        double n) {
2953 2954 2955
  opt->rep.max_bytes_for_level_multiplier = n;
}

2956 2957 2958 2959 2960
double rocksdb_options_get_max_bytes_for_level_multiplier(
    rocksdb_options_t* opt) {
  return opt->rep.max_bytes_for_level_multiplier;
}

2961 2962 2963
void rocksdb_options_set_max_compaction_bytes(rocksdb_options_t* opt,
                                              uint64_t n) {
  opt->rep.max_compaction_bytes = n;
2964 2965
}

2966 2967 2968 2969
uint64_t rocksdb_options_get_max_compaction_bytes(rocksdb_options_t* opt) {
  return opt->rep.max_compaction_bytes;
}

T
Thomas Adam 已提交
2970 2971 2972 2973 2974 2975 2976 2977
void rocksdb_options_set_max_bytes_for_level_multiplier_additional(
    rocksdb_options_t* opt, int* level_values, size_t num_levels) {
  opt->rep.max_bytes_for_level_multiplier_additional.resize(num_levels);
  for (size_t i = 0; i < num_levels; ++i) {
    opt->rep.max_bytes_for_level_multiplier_additional[i] = level_values[i];
  }
}

T
Thomas Adam 已提交
2978
void rocksdb_options_enable_statistics(rocksdb_options_t* opt) {
2979
  opt->rep.statistics = ROCKSDB_NAMESPACE::CreateDBStatistics();
T
Thomas Adam 已提交
2980 2981
}

2982 2983
void rocksdb_options_set_skip_stats_update_on_db_open(rocksdb_options_t* opt,
                                                      unsigned char val) {
2984 2985 2986
  opt->rep.skip_stats_update_on_db_open = val;
}

2987 2988 2989 2990 2991
unsigned char rocksdb_options_get_skip_stats_update_on_db_open(
    rocksdb_options_t* opt) {
  return opt->rep.skip_stats_update_on_db_open;
}

2992 2993 2994 2995 2996
void rocksdb_options_set_skip_checking_sst_file_sizes_on_db_open(
    rocksdb_options_t* opt, unsigned char val) {
  opt->rep.skip_checking_sst_file_sizes_on_db_open = val;
}

2997 2998 2999 3000 3001
unsigned char rocksdb_options_get_skip_checking_sst_file_sizes_on_db_open(
    rocksdb_options_t* opt) {
  return opt->rep.skip_checking_sst_file_sizes_on_db_open;
}

M
mrambacher 已提交
3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054
/* Blob Options Settings */
void rocksdb_options_set_enable_blob_files(rocksdb_options_t* opt,
                                           unsigned char val) {
  opt->rep.enable_blob_files = val;
}
extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_enable_blob_files(
    rocksdb_options_t* opt) {
  return opt->rep.enable_blob_files;
}

void rocksdb_options_set_min_blob_size(rocksdb_options_t* opt, uint64_t val) {
  opt->rep.min_blob_size = val;
}

uint64_t rocksdb_options_get_min_blob_size(rocksdb_options_t* opt) {
  return opt->rep.min_blob_size;
}

void rocksdb_options_set_blob_file_size(rocksdb_options_t* opt, uint64_t val) {
  opt->rep.blob_file_size = val;
}

uint64_t rocksdb_options_get_blob_file_size(rocksdb_options_t* opt) {
  return opt->rep.blob_file_size;
}

void rocksdb_options_set_blob_compression_type(rocksdb_options_t* opt,
                                               int val) {
  opt->rep.blob_compression_type = static_cast<CompressionType>(val);
}

int rocksdb_options_get_blob_compression_type(rocksdb_options_t* opt) {
  return opt->rep.blob_compression_type;
}

void rocksdb_options_set_enable_blob_gc(rocksdb_options_t* opt,
                                        unsigned char val) {
  opt->rep.enable_blob_garbage_collection = val;
}

unsigned char rocksdb_options_get_enable_blob_gc(rocksdb_options_t* opt) {
  return opt->rep.enable_blob_garbage_collection;
}

void rocksdb_options_set_blob_gc_age_cutoff(rocksdb_options_t* opt,
                                            double val) {
  opt->rep.blob_garbage_collection_age_cutoff = val;
}

double rocksdb_options_get_blob_gc_age_cutoff(rocksdb_options_t* opt) {
  return opt->rep.blob_garbage_collection_age_cutoff;
}

3055 3056 3057 3058 3059 3060 3061 3062 3063
void rocksdb_options_set_blob_gc_force_threshold(rocksdb_options_t* opt,
                                                 double val) {
  opt->rep.blob_garbage_collection_force_threshold = val;
}

double rocksdb_options_get_blob_gc_force_threshold(rocksdb_options_t* opt) {
  return opt->rep.blob_garbage_collection_force_threshold;
}

3064 3065 3066 3067 3068 3069 3070 3071 3072 3073
void rocksdb_options_set_blob_compaction_readahead_size(rocksdb_options_t* opt,
                                                        uint64_t val) {
  opt->rep.blob_compaction_readahead_size = val;
}

uint64_t rocksdb_options_get_blob_compaction_readahead_size(
    rocksdb_options_t* opt) {
  return opt->rep.blob_compaction_readahead_size;
}

3074 3075 3076 3077 3078 3079 3080 3081 3082
void rocksdb_options_set_blob_file_starting_level(rocksdb_options_t* opt,
                                                  int val) {
  opt->rep.blob_file_starting_level = val;
}

int rocksdb_options_get_blob_file_starting_level(rocksdb_options_t* opt) {
  return opt->rep.blob_file_starting_level;
}

3083 3084 3085 3086 3087
void rocksdb_options_set_blob_cache(rocksdb_options_t* opt,
                                    rocksdb_cache_t* blob_cache) {
  opt->rep.blob_cache = blob_cache->rep;
}

3088 3089 3090 3091 3092 3093 3094 3095
void rocksdb_options_set_prepopulate_blob_cache(rocksdb_options_t* opt, int t) {
  opt->rep.prepopulate_blob_cache = static_cast<PrepopulateBlobCache>(t);
}

int rocksdb_options_get_prepopulate_blob_cache(rocksdb_options_t* opt) {
  return static_cast<int>(opt->rep.prepopulate_blob_cache);
}

3096
void rocksdb_options_set_num_levels(rocksdb_options_t* opt, int n) {
A
Abhishek Kona 已提交
3097
  opt->rep.num_levels = n;
3098 3099
}

3100 3101 3102 3103
int rocksdb_options_get_num_levels(rocksdb_options_t* opt) {
  return opt->rep.num_levels;
}

3104 3105
void rocksdb_options_set_level0_file_num_compaction_trigger(
    rocksdb_options_t* opt, int n) {
A
Abhishek Kona 已提交
3106
  opt->rep.level0_file_num_compaction_trigger = n;
3107 3108
}

3109 3110 3111 3112 3113
int rocksdb_options_get_level0_file_num_compaction_trigger(
    rocksdb_options_t* opt) {
  return opt->rep.level0_file_num_compaction_trigger;
}

3114 3115
void rocksdb_options_set_level0_slowdown_writes_trigger(rocksdb_options_t* opt,
                                                        int n) {
A
Abhishek Kona 已提交
3116
  opt->rep.level0_slowdown_writes_trigger = n;
3117 3118
}

3119 3120 3121 3122
int rocksdb_options_get_level0_slowdown_writes_trigger(rocksdb_options_t* opt) {
  return opt->rep.level0_slowdown_writes_trigger;
}

3123 3124
void rocksdb_options_set_level0_stop_writes_trigger(rocksdb_options_t* opt,
                                                    int n) {
A
Abhishek Kona 已提交
3125
  opt->rep.level0_stop_writes_trigger = n;
3126 3127
}

3128 3129 3130 3131
int rocksdb_options_get_level0_stop_writes_trigger(rocksdb_options_t* opt) {
  return opt->rep.level0_stop_writes_trigger;
}

3132
void rocksdb_options_set_wal_recovery_mode(rocksdb_options_t* opt, int mode) {
3133 3134 3135
  opt->rep.wal_recovery_mode = static_cast<WALRecoveryMode>(mode);
}

3136 3137 3138 3139
int rocksdb_options_get_wal_recovery_mode(rocksdb_options_t* opt) {
  return static_cast<int>(opt->rep.wal_recovery_mode);
}

3140
void rocksdb_options_set_compression(rocksdb_options_t* opt, int t) {
3141 3142 3143
  opt->rep.compression = static_cast<CompressionType>(t);
}

3144 3145 3146 3147
int rocksdb_options_get_compression(rocksdb_options_t* opt) {
  return opt->rep.compression;
}

3148 3149 3150 3151
void rocksdb_options_set_bottommost_compression(rocksdb_options_t* opt, int t) {
  opt->rep.bottommost_compression = static_cast<CompressionType>(t);
}

3152 3153 3154 3155
int rocksdb_options_get_bottommost_compression(rocksdb_options_t* opt) {
  return opt->rep.bottommost_compression;
}

3156
void rocksdb_options_set_compression_per_level(rocksdb_options_t* opt,
3157
                                               const int* level_values,
3158 3159 3160 3161
                                               size_t num_levels) {
  opt->rep.compression_per_level.resize(num_levels);
  for (size_t i = 0; i < num_levels; ++i) {
    opt->rep.compression_per_level[i] =
3162
        static_cast<CompressionType>(level_values[i]);
3163 3164 3165
  }
}

3166 3167 3168 3169
void rocksdb_options_set_bottommost_compression_options(rocksdb_options_t* opt,
                                                        int w_bits, int level,
                                                        int strategy,
                                                        int max_dict_bytes,
3170
                                                        unsigned char enabled) {
3171 3172 3173 3174 3175 3176 3177
  opt->rep.bottommost_compression_opts.window_bits = w_bits;
  opt->rep.bottommost_compression_opts.level = level;
  opt->rep.bottommost_compression_opts.strategy = strategy;
  opt->rep.bottommost_compression_opts.max_dict_bytes = max_dict_bytes;
  opt->rep.bottommost_compression_opts.enabled = enabled;
}

3178 3179 3180 3181 3182 3183 3184
void rocksdb_options_set_bottommost_compression_options_zstd_max_train_bytes(
    rocksdb_options_t* opt, int zstd_max_train_bytes, unsigned char enabled) {
  opt->rep.bottommost_compression_opts.zstd_max_train_bytes =
      zstd_max_train_bytes;
  opt->rep.bottommost_compression_opts.enabled = enabled;
}

3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198
void rocksdb_options_set_bottommost_compression_options_use_zstd_dict_trainer(
    rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer,
    unsigned char enabled) {
  opt->rep.bottommost_compression_opts.use_zstd_dict_trainer =
      use_zstd_dict_trainer;
  opt->rep.bottommost_compression_opts.enabled = enabled;
}

unsigned char
rocksdb_options_get_bottommost_compression_options_use_zstd_dict_trainer(
    rocksdb_options_t* opt) {
  return opt->rep.bottommost_compression_opts.use_zstd_dict_trainer;
}

3199 3200 3201 3202 3203 3204 3205 3206
void rocksdb_options_set_bottommost_compression_options_max_dict_buffer_bytes(
    rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes,
    unsigned char enabled) {
  opt->rep.bottommost_compression_opts.max_dict_buffer_bytes =
      max_dict_buffer_bytes;
  opt->rep.bottommost_compression_opts.enabled = enabled;
}

3207 3208
void rocksdb_options_set_compression_options(rocksdb_options_t* opt, int w_bits,
                                             int level, int strategy,
3209
                                             int max_dict_bytes) {
3210 3211 3212
  opt->rep.compression_opts.window_bits = w_bits;
  opt->rep.compression_opts.level = level;
  opt->rep.compression_opts.strategy = strategy;
3213
  opt->rep.compression_opts.max_dict_bytes = max_dict_bytes;
3214 3215
}

3216 3217 3218 3219 3220
void rocksdb_options_set_compression_options_zstd_max_train_bytes(
    rocksdb_options_t* opt, int zstd_max_train_bytes) {
  opt->rep.compression_opts.zstd_max_train_bytes = zstd_max_train_bytes;
}

3221 3222 3223 3224 3225
int rocksdb_options_get_compression_options_zstd_max_train_bytes(
    rocksdb_options_t* opt) {
  return opt->rep.compression_opts.zstd_max_train_bytes;
}

3226 3227 3228 3229 3230 3231 3232 3233 3234 3235
void rocksdb_options_set_compression_options_use_zstd_dict_trainer(
    rocksdb_options_t* opt, unsigned char use_zstd_dict_trainer) {
  opt->rep.compression_opts.use_zstd_dict_trainer = use_zstd_dict_trainer;
}

unsigned char rocksdb_options_get_compression_options_use_zstd_dict_trainer(
    rocksdb_options_t* opt) {
  return opt->rep.compression_opts.use_zstd_dict_trainer;
}

3236 3237 3238 3239 3240 3241 3242 3243 3244 3245
void rocksdb_options_set_compression_options_parallel_threads(
    rocksdb_options_t* opt, int value) {
  opt->rep.compression_opts.parallel_threads = value;
}

int rocksdb_options_get_compression_options_parallel_threads(
    rocksdb_options_t* opt) {
  return opt->rep.compression_opts.parallel_threads;
}

3246 3247 3248 3249 3250
void rocksdb_options_set_compression_options_max_dict_buffer_bytes(
    rocksdb_options_t* opt, uint64_t max_dict_buffer_bytes) {
  opt->rep.compression_opts.max_dict_buffer_bytes = max_dict_buffer_bytes;
}

3251 3252 3253 3254 3255
uint64_t rocksdb_options_get_compression_options_max_dict_buffer_bytes(
    rocksdb_options_t* opt) {
  return opt->rep.compression_opts.max_dict_buffer_bytes;
}

T
Thomas Adam 已提交
3256 3257
void rocksdb_options_set_prefix_extractor(
    rocksdb_options_t* opt, rocksdb_slicetransform_t* prefix_extractor) {
3258
  opt->rep.prefix_extractor.reset(prefix_extractor);
T
Thomas Adam 已提交
3259 3260
}

3261
void rocksdb_options_set_use_fsync(rocksdb_options_t* opt, int use_fsync) {
H
heyongqiang 已提交
3262 3263 3264
  opt->rep.use_fsync = use_fsync;
}

3265 3266 3267 3268
int rocksdb_options_get_use_fsync(rocksdb_options_t* opt) {
  return opt->rep.use_fsync;
}

3269 3270
void rocksdb_options_set_db_log_dir(rocksdb_options_t* opt,
                                    const char* db_log_dir) {
H
heyongqiang 已提交
3271 3272 3273
  opt->rep.db_log_dir = db_log_dir;
}

3274
void rocksdb_options_set_wal_dir(rocksdb_options_t* opt, const char* v) {
T
Thomas Adam 已提交
3275 3276 3277
  opt->rep.wal_dir = v;
}

3278
void rocksdb_options_set_WAL_ttl_seconds(rocksdb_options_t* opt, uint64_t ttl) {
3279 3280 3281
  opt->rep.WAL_ttl_seconds = ttl;
}

3282 3283 3284 3285
uint64_t rocksdb_options_get_WAL_ttl_seconds(rocksdb_options_t* opt) {
  return opt->rep.WAL_ttl_seconds;
}

3286 3287
void rocksdb_options_set_WAL_size_limit_MB(rocksdb_options_t* opt,
                                           uint64_t limit) {
3288 3289 3290
  opt->rep.WAL_size_limit_MB = limit;
}

3291 3292 3293 3294
uint64_t rocksdb_options_get_WAL_size_limit_MB(rocksdb_options_t* opt) {
  return opt->rep.WAL_size_limit_MB;
}

3295 3296
void rocksdb_options_set_manifest_preallocation_size(rocksdb_options_t* opt,
                                                     size_t v) {
T
Thomas Adam 已提交
3297 3298 3299
  opt->rep.manifest_preallocation_size = v;
}

3300 3301 3302 3303
size_t rocksdb_options_get_manifest_preallocation_size(rocksdb_options_t* opt) {
  return opt->rep.manifest_preallocation_size;
}

A
Aaron Gao 已提交
3304 3305 3306 3307 3308
void rocksdb_options_set_use_direct_reads(rocksdb_options_t* opt,
                                          unsigned char v) {
  opt->rep.use_direct_reads = v;
}

3309 3310 3311 3312
unsigned char rocksdb_options_get_use_direct_reads(rocksdb_options_t* opt) {
  return opt->rep.use_direct_reads;
}

3313 3314 3315
void rocksdb_options_set_use_direct_io_for_flush_and_compaction(
    rocksdb_options_t* opt, unsigned char v) {
  opt->rep.use_direct_io_for_flush_and_compaction = v;
T
Thomas Adam 已提交
3316 3317
}

3318 3319 3320 3321 3322
unsigned char rocksdb_options_get_use_direct_io_for_flush_and_compaction(
    rocksdb_options_t* opt) {
  return opt->rep.use_direct_io_for_flush_and_compaction;
}

3323 3324
void rocksdb_options_set_allow_mmap_reads(rocksdb_options_t* opt,
                                          unsigned char v) {
T
Thomas Adam 已提交
3325 3326 3327
  opt->rep.allow_mmap_reads = v;
}

3328 3329 3330 3331
unsigned char rocksdb_options_get_allow_mmap_reads(rocksdb_options_t* opt) {
  return opt->rep.allow_mmap_reads;
}

3332 3333
void rocksdb_options_set_allow_mmap_writes(rocksdb_options_t* opt,
                                           unsigned char v) {
T
Thomas Adam 已提交
3334 3335 3336
  opt->rep.allow_mmap_writes = v;
}

3337 3338 3339 3340
unsigned char rocksdb_options_get_allow_mmap_writes(rocksdb_options_t* opt) {
  return opt->rep.allow_mmap_writes;
}

3341 3342
void rocksdb_options_set_is_fd_close_on_exec(rocksdb_options_t* opt,
                                             unsigned char v) {
T
Thomas Adam 已提交
3343 3344 3345
  opt->rep.is_fd_close_on_exec = v;
}

3346 3347 3348 3349
unsigned char rocksdb_options_get_is_fd_close_on_exec(rocksdb_options_t* opt) {
  return opt->rep.is_fd_close_on_exec;
}

3350 3351
void rocksdb_options_set_stats_dump_period_sec(rocksdb_options_t* opt,
                                               unsigned int v) {
T
Thomas Adam 已提交
3352 3353 3354
  opt->rep.stats_dump_period_sec = v;
}

3355 3356 3357 3358
unsigned int rocksdb_options_get_stats_dump_period_sec(rocksdb_options_t* opt) {
  return opt->rep.stats_dump_period_sec;
}

3359 3360 3361 3362 3363 3364 3365 3366 3367 3368
void rocksdb_options_set_stats_persist_period_sec(rocksdb_options_t* opt,
                                                  unsigned int v) {
  opt->rep.stats_persist_period_sec = v;
}

unsigned int rocksdb_options_get_stats_persist_period_sec(
    rocksdb_options_t* opt) {
  return opt->rep.stats_persist_period_sec;
}

3369 3370
void rocksdb_options_set_advise_random_on_open(rocksdb_options_t* opt,
                                               unsigned char v) {
T
Thomas Adam 已提交
3371 3372 3373
  opt->rep.advise_random_on_open = v;
}

3374 3375 3376 3377 3378
unsigned char rocksdb_options_get_advise_random_on_open(
    rocksdb_options_t* opt) {
  return opt->rep.advise_random_on_open;
}

3379 3380 3381
void rocksdb_options_set_access_hint_on_compaction_start(rocksdb_options_t* opt,
                                                         int v) {
  switch (v) {
T
Thomas Adam 已提交
3382
    case 0:
3383 3384
      opt->rep.access_hint_on_compaction_start =
          ROCKSDB_NAMESPACE::Options::NONE;
T
Thomas Adam 已提交
3385 3386
      break;
    case 1:
3387 3388
      opt->rep.access_hint_on_compaction_start =
          ROCKSDB_NAMESPACE::Options::NORMAL;
T
Thomas Adam 已提交
3389 3390
      break;
    case 2:
3391 3392
      opt->rep.access_hint_on_compaction_start =
          ROCKSDB_NAMESPACE::Options::SEQUENTIAL;
T
Thomas Adam 已提交
3393 3394
      break;
    case 3:
3395 3396
      opt->rep.access_hint_on_compaction_start =
          ROCKSDB_NAMESPACE::Options::WILLNEED;
T
Thomas Adam 已提交
3397
      break;
S
storagezhang 已提交
3398 3399
    default:
      assert(0);
T
Thomas Adam 已提交
3400 3401 3402
  }
}

3403 3404 3405 3406 3407
int rocksdb_options_get_access_hint_on_compaction_start(
    rocksdb_options_t* opt) {
  return opt->rep.access_hint_on_compaction_start;
}

3408 3409
void rocksdb_options_set_use_adaptive_mutex(rocksdb_options_t* opt,
                                            unsigned char v) {
T
Thomas Adam 已提交
3410 3411 3412
  opt->rep.use_adaptive_mutex = v;
}

3413 3414 3415 3416
unsigned char rocksdb_options_get_use_adaptive_mutex(rocksdb_options_t* opt) {
  return opt->rep.use_adaptive_mutex;
}

3417 3418
void rocksdb_options_set_wal_bytes_per_sync(rocksdb_options_t* opt,
                                            uint64_t v) {
3419 3420 3421
  opt->rep.wal_bytes_per_sync = v;
}

3422 3423 3424 3425
uint64_t rocksdb_options_get_wal_bytes_per_sync(rocksdb_options_t* opt) {
  return opt->rep.wal_bytes_per_sync;
}

3426
void rocksdb_options_set_bytes_per_sync(rocksdb_options_t* opt, uint64_t v) {
T
Thomas Adam 已提交
3427 3428 3429
  opt->rep.bytes_per_sync = v;
}

3430 3431 3432 3433
uint64_t rocksdb_options_get_bytes_per_sync(rocksdb_options_t* opt) {
  return opt->rep.bytes_per_sync;
}

3434 3435
void rocksdb_options_set_writable_file_max_buffer_size(rocksdb_options_t* opt,
                                                       uint64_t v) {
3436
  opt->rep.writable_file_max_buffer_size = static_cast<size_t>(v);
3437 3438
}

3439 3440 3441 3442 3443
uint64_t rocksdb_options_get_writable_file_max_buffer_size(
    rocksdb_options_t* opt) {
  return opt->rep.writable_file_max_buffer_size;
}

3444 3445 3446 3447 3448
void rocksdb_options_set_allow_concurrent_memtable_write(rocksdb_options_t* opt,
                                                         unsigned char v) {
  opt->rep.allow_concurrent_memtable_write = v;
}

3449 3450 3451 3452 3453
unsigned char rocksdb_options_get_allow_concurrent_memtable_write(
    rocksdb_options_t* opt) {
  return opt->rep.allow_concurrent_memtable_write;
}

3454 3455 3456 3457 3458
void rocksdb_options_set_enable_write_thread_adaptive_yield(
    rocksdb_options_t* opt, unsigned char v) {
  opt->rep.enable_write_thread_adaptive_yield = v;
}

3459 3460 3461 3462 3463
unsigned char rocksdb_options_get_enable_write_thread_adaptive_yield(
    rocksdb_options_t* opt) {
  return opt->rep.enable_write_thread_adaptive_yield;
}

T
Thomas Adam 已提交
3464 3465 3466 3467 3468
void rocksdb_options_set_max_sequential_skip_in_iterations(
    rocksdb_options_t* opt, uint64_t v) {
  opt->rep.max_sequential_skip_in_iterations = v;
}

3469 3470 3471 3472 3473
uint64_t rocksdb_options_get_max_sequential_skip_in_iterations(
    rocksdb_options_t* opt) {
  return opt->rep.max_sequential_skip_in_iterations;
}

3474 3475
void rocksdb_options_set_max_write_buffer_number(rocksdb_options_t* opt,
                                                 int n) {
3476 3477 3478
  opt->rep.max_write_buffer_number = n;
}

3479 3480 3481 3482
int rocksdb_options_get_max_write_buffer_number(rocksdb_options_t* opt) {
  return opt->rep.max_write_buffer_number;
}

3483 3484
void rocksdb_options_set_min_write_buffer_number_to_merge(
    rocksdb_options_t* opt, int n) {
3485 3486 3487
  opt->rep.min_write_buffer_number_to_merge = n;
}

3488 3489 3490 3491 3492
int rocksdb_options_get_min_write_buffer_number_to_merge(
    rocksdb_options_t* opt) {
  return opt->rep.min_write_buffer_number_to_merge;
}

3493 3494 3495 3496 3497
void rocksdb_options_set_max_write_buffer_number_to_maintain(
    rocksdb_options_t* opt, int n) {
  opt->rep.max_write_buffer_number_to_maintain = n;
}

3498 3499 3500 3501 3502
int rocksdb_options_get_max_write_buffer_number_to_maintain(
    rocksdb_options_t* opt) {
  return opt->rep.max_write_buffer_number_to_maintain;
}

3503 3504 3505 3506 3507
void rocksdb_options_set_max_write_buffer_size_to_maintain(
    rocksdb_options_t* opt, int64_t n) {
  opt->rep.max_write_buffer_size_to_maintain = n;
}

3508 3509 3510 3511 3512
int64_t rocksdb_options_get_max_write_buffer_size_to_maintain(
    rocksdb_options_t* opt) {
  return opt->rep.max_write_buffer_size_to_maintain;
}

3513 3514
void rocksdb_options_set_enable_pipelined_write(rocksdb_options_t* opt,
                                                unsigned char v) {
H
Huachao Huang 已提交
3515 3516 3517
  opt->rep.enable_pipelined_write = v;
}

3518 3519 3520 3521 3522
unsigned char rocksdb_options_get_enable_pipelined_write(
    rocksdb_options_t* opt) {
  return opt->rep.enable_pipelined_write;
}

M
Maysam Yabandeh 已提交
3523 3524 3525 3526 3527
void rocksdb_options_set_unordered_write(rocksdb_options_t* opt,
                                         unsigned char v) {
  opt->rep.unordered_write = v;
}

3528 3529 3530 3531
unsigned char rocksdb_options_get_unordered_write(rocksdb_options_t* opt) {
  return opt->rep.unordered_write;
}

3532 3533
void rocksdb_options_set_max_subcompactions(rocksdb_options_t* opt,
                                            uint32_t n) {
H
Huachao Huang 已提交
3534 3535 3536
  opt->rep.max_subcompactions = n;
}

3537 3538 3539 3540
uint32_t rocksdb_options_get_max_subcompactions(rocksdb_options_t* opt) {
  return opt->rep.max_subcompactions;
}

H
Huachao Huang 已提交
3541 3542 3543 3544
void rocksdb_options_set_max_background_jobs(rocksdb_options_t* opt, int n) {
  opt->rep.max_background_jobs = n;
}

3545 3546 3547 3548
int rocksdb_options_get_max_background_jobs(rocksdb_options_t* opt) {
  return opt->rep.max_background_jobs;
}

3549 3550
void rocksdb_options_set_max_background_compactions(rocksdb_options_t* opt,
                                                    int n) {
3551 3552 3553
  opt->rep.max_background_compactions = n;
}

3554 3555 3556 3557
int rocksdb_options_get_max_background_compactions(rocksdb_options_t* opt) {
  return opt->rep.max_background_compactions;
}

3558 3559 3560 3561
void rocksdb_options_set_max_background_flushes(rocksdb_options_t* opt, int n) {
  opt->rep.max_background_flushes = n;
}

3562 3563 3564 3565
int rocksdb_options_get_max_background_flushes(rocksdb_options_t* opt) {
  return opt->rep.max_background_flushes;
}

3566 3567 3568 3569 3570 3571 3572 3573 3574 3575
void rocksdb_options_set_experimental_mempurge_threshold(rocksdb_options_t* opt,
                                                         double v) {
  opt->rep.experimental_mempurge_threshold = v;
}

double rocksdb_options_get_experimental_mempurge_threshold(
    rocksdb_options_t* opt) {
  return opt->rep.experimental_mempurge_threshold;
}

T
Thomas Adam 已提交
3576 3577 3578 3579
void rocksdb_options_set_max_log_file_size(rocksdb_options_t* opt, size_t v) {
  opt->rep.max_log_file_size = v;
}

3580 3581 3582 3583
size_t rocksdb_options_get_max_log_file_size(rocksdb_options_t* opt) {
  return opt->rep.max_log_file_size;
}

3584 3585
void rocksdb_options_set_log_file_time_to_roll(rocksdb_options_t* opt,
                                               size_t v) {
T
Thomas Adam 已提交
3586 3587 3588
  opt->rep.log_file_time_to_roll = v;
}

3589 3590 3591 3592
size_t rocksdb_options_get_log_file_time_to_roll(rocksdb_options_t* opt) {
  return opt->rep.log_file_time_to_roll;
}

T
Thomas Adam 已提交
3593 3594 3595 3596
void rocksdb_options_set_keep_log_file_num(rocksdb_options_t* opt, size_t v) {
  opt->rep.keep_log_file_num = v;
}

3597 3598 3599 3600
size_t rocksdb_options_get_keep_log_file_num(rocksdb_options_t* opt) {
  return opt->rep.keep_log_file_num;
}

3601 3602 3603 3604 3605
void rocksdb_options_set_recycle_log_file_num(rocksdb_options_t* opt,
                                              size_t v) {
  opt->rep.recycle_log_file_num = v;
}

3606 3607 3608 3609
size_t rocksdb_options_get_recycle_log_file_num(rocksdb_options_t* opt) {
  return opt->rep.recycle_log_file_num;
}

3610 3611
void rocksdb_options_set_soft_pending_compaction_bytes_limit(
    rocksdb_options_t* opt, size_t v) {
O
oranagra 已提交
3612 3613 3614
  opt->rep.soft_pending_compaction_bytes_limit = v;
}

3615 3616 3617 3618 3619
size_t rocksdb_options_get_soft_pending_compaction_bytes_limit(
    rocksdb_options_t* opt) {
  return opt->rep.soft_pending_compaction_bytes_limit;
}

3620 3621
void rocksdb_options_set_hard_pending_compaction_bytes_limit(
    rocksdb_options_t* opt, size_t v) {
O
oranagra 已提交
3622 3623 3624
  opt->rep.hard_pending_compaction_bytes_limit = v;
}

3625 3626 3627 3628 3629
size_t rocksdb_options_get_hard_pending_compaction_bytes_limit(
    rocksdb_options_t* opt) {
  return opt->rep.hard_pending_compaction_bytes_limit;
}

3630 3631
void rocksdb_options_set_max_manifest_file_size(rocksdb_options_t* opt,
                                                size_t v) {
T
Thomas Adam 已提交
3632 3633 3634
  opt->rep.max_manifest_file_size = v;
}

3635 3636 3637 3638
size_t rocksdb_options_get_max_manifest_file_size(rocksdb_options_t* opt) {
  return opt->rep.max_manifest_file_size;
}

3639 3640
void rocksdb_options_set_table_cache_numshardbits(rocksdb_options_t* opt,
                                                  int v) {
T
Thomas Adam 已提交
3641 3642 3643
  opt->rep.table_cache_numshardbits = v;
}

3644 3645 3646 3647
int rocksdb_options_get_table_cache_numshardbits(rocksdb_options_t* opt) {
  return opt->rep.table_cache_numshardbits;
}

3648
void rocksdb_options_set_arena_block_size(rocksdb_options_t* opt, size_t v) {
T
Thomas Adam 已提交
3649 3650 3651
  opt->rep.arena_block_size = v;
}

3652 3653 3654 3655
size_t rocksdb_options_get_arena_block_size(rocksdb_options_t* opt) {
  return opt->rep.arena_block_size;
}

3656 3657
void rocksdb_options_set_disable_auto_compactions(rocksdb_options_t* opt,
                                                  int disable) {
3658 3659 3660
  opt->rep.disable_auto_compactions = disable;
}

3661 3662 3663 3664 3665
unsigned char rocksdb_options_get_disable_auto_compactions(
    rocksdb_options_t* opt) {
  return opt->rep.disable_auto_compactions;
}

3666 3667
void rocksdb_options_set_optimize_filters_for_hits(rocksdb_options_t* opt,
                                                   int v) {
O
oranagra 已提交
3668 3669 3670
  opt->rep.optimize_filters_for_hits = v;
}

3671 3672 3673 3674 3675
unsigned char rocksdb_options_get_optimize_filters_for_hits(
    rocksdb_options_t* opt) {
  return opt->rep.optimize_filters_for_hits;
}

T
Thomas Adam 已提交
3676 3677 3678 3679 3680
void rocksdb_options_set_delete_obsolete_files_period_micros(
    rocksdb_options_t* opt, uint64_t v) {
  opt->rep.delete_obsolete_files_period_micros = v;
}

3681 3682 3683 3684 3685
uint64_t rocksdb_options_get_delete_obsolete_files_period_micros(
    rocksdb_options_t* opt) {
  return opt->rep.delete_obsolete_files_period_micros;
}

3686 3687 3688 3689
void rocksdb_options_prepare_for_bulk_load(rocksdb_options_t* opt) {
  opt->rep.PrepareForBulkLoad();
}

3690
void rocksdb_options_set_memtable_vector_rep(rocksdb_options_t* opt) {
3691
  opt->rep.memtable_factory.reset(new ROCKSDB_NAMESPACE::VectorRepFactory);
3692 3693
}

3694 3695 3696
void rocksdb_options_set_memtable_prefix_bloom_size_ratio(
    rocksdb_options_t* opt, double v) {
  opt->rep.memtable_prefix_bloom_size_ratio = v;
T
Thomas Adam 已提交
3697 3698
}

3699 3700 3701 3702 3703
double rocksdb_options_get_memtable_prefix_bloom_size_ratio(
    rocksdb_options_t* opt) {
  return opt->rep.memtable_prefix_bloom_size_ratio;
}

3704 3705 3706
void rocksdb_options_set_memtable_huge_page_size(rocksdb_options_t* opt,
                                                 size_t v) {
  opt->rep.memtable_huge_page_size = v;
3707 3708
}

3709 3710 3711 3712
size_t rocksdb_options_get_memtable_huge_page_size(rocksdb_options_t* opt) {
  return opt->rep.memtable_huge_page_size;
}

3713 3714 3715 3716
void rocksdb_options_set_hash_skip_list_rep(rocksdb_options_t* opt,
                                            size_t bucket_count,
                                            int32_t skiplist_height,
                                            int32_t skiplist_branching_factor) {
3717 3718 3719
  ROCKSDB_NAMESPACE::MemTableRepFactory* factory =
      ROCKSDB_NAMESPACE::NewHashSkipListRepFactory(
          bucket_count, skiplist_height, skiplist_branching_factor);
3720 3721 3722
  opt->rep.memtable_factory.reset(factory);
}

3723 3724
void rocksdb_options_set_hash_link_list_rep(rocksdb_options_t* opt,
                                            size_t bucket_count) {
3725 3726
  opt->rep.memtable_factory.reset(
      ROCKSDB_NAMESPACE::NewHashLinkListRepFactory(bucket_count));
3727 3728
}

3729 3730 3731 3732 3733
void 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) {
3734
  ROCKSDB_NAMESPACE::PlainTableOptions options;
3735 3736 3737 3738 3739
  options.user_key_len = user_key_len;
  options.bloom_bits_per_key = bloom_bits_per_key;
  options.hash_table_ratio = hash_table_ratio;
  options.index_sparseness = index_sparseness;

3740 3741
  ROCKSDB_NAMESPACE::TableFactory* factory =
      ROCKSDB_NAMESPACE::NewPlainTableFactory(options);
3742 3743 3744
  opt->rep.table_factory.reset(factory);
}

3745 3746
void rocksdb_options_set_max_successive_merges(rocksdb_options_t* opt,
                                               size_t v) {
T
Thomas Adam 已提交
3747 3748 3749
  opt->rep.max_successive_merges = v;
}

3750 3751 3752 3753
size_t rocksdb_options_get_max_successive_merges(rocksdb_options_t* opt) {
  return opt->rep.max_successive_merges;
}

3754
void rocksdb_options_set_bloom_locality(rocksdb_options_t* opt, uint32_t v) {
T
Thomas Adam 已提交
3755 3756 3757
  opt->rep.bloom_locality = v;
}

3758 3759 3760 3761
uint32_t rocksdb_options_get_bloom_locality(rocksdb_options_t* opt) {
  return opt->rep.bloom_locality;
}

3762 3763
void rocksdb_options_set_inplace_update_support(rocksdb_options_t* opt,
                                                unsigned char v) {
T
Thomas Adam 已提交
3764 3765 3766
  opt->rep.inplace_update_support = v;
}

3767 3768 3769 3770 3771
unsigned char rocksdb_options_get_inplace_update_support(
    rocksdb_options_t* opt) {
  return opt->rep.inplace_update_support;
}

3772 3773
void rocksdb_options_set_inplace_update_num_locks(rocksdb_options_t* opt,
                                                  size_t v) {
T
Thomas Adam 已提交
3774 3775 3776
  opt->rep.inplace_update_num_locks = v;
}

3777 3778 3779 3780
size_t rocksdb_options_get_inplace_update_num_locks(rocksdb_options_t* opt) {
  return opt->rep.inplace_update_num_locks;
}

3781
void rocksdb_options_set_report_bg_io_stats(rocksdb_options_t* opt, int v) {
3782 3783 3784
  opt->rep.report_bg_io_stats = v;
}

3785 3786 3787 3788
unsigned char rocksdb_options_get_report_bg_io_stats(rocksdb_options_t* opt) {
  return opt->rep.report_bg_io_stats;
}

3789
void rocksdb_options_set_compaction_style(rocksdb_options_t* opt, int style) {
3790 3791
  opt->rep.compaction_style =
      static_cast<ROCKSDB_NAMESPACE::CompactionStyle>(style);
3792 3793
}

3794 3795 3796 3797
int rocksdb_options_get_compaction_style(rocksdb_options_t* opt) {
  return opt->rep.compaction_style;
}

3798 3799
void rocksdb_options_set_universal_compaction_options(
    rocksdb_options_t* opt, rocksdb_universal_compaction_options_t* uco) {
3800 3801 3802
  opt->rep.compaction_options_universal = *(uco->rep);
}

3803
void rocksdb_options_set_fifo_compaction_options(
3804
    rocksdb_options_t* opt, rocksdb_fifo_compaction_options_t* fifo) {
3805 3806 3807
  opt->rep.compaction_options_fifo = fifo->rep;
}

3808
char* rocksdb_options_statistics_get_string(rocksdb_options_t* opt) {
3809
  ROCKSDB_NAMESPACE::Statistics* statistics = opt->rep.statistics.get();
3810 3811 3812 3813 3814 3815
  if (statistics) {
    return strdup(statistics->ToString().c_str());
  }
  return nullptr;
}

3816 3817
void rocksdb_options_set_ratelimiter(rocksdb_options_t* opt,
                                     rocksdb_ratelimiter_t* limiter) {
3818 3819 3820
  if (limiter) {
    opt->rep.rate_limiter = limiter->rep;
  }
Z
zhangjinpeng1987 已提交
3821 3822
}

3823 3824 3825
void rocksdb_options_set_atomic_flush(rocksdb_options_t* opt,
                                      unsigned char atomic_flush) {
  opt->rep.atomic_flush = atomic_flush;
3826 3827
}

3828 3829 3830 3831
unsigned char rocksdb_options_get_atomic_flush(rocksdb_options_t* opt) {
  return opt->rep.atomic_flush;
}

3832 3833 3834 3835 3836 3837 3838 3839 3840
void rocksdb_options_set_manual_wal_flush(rocksdb_options_t* opt,
                                          unsigned char manual_wal_flush) {
  opt->rep.manual_wal_flush = manual_wal_flush;
}

unsigned char rocksdb_options_get_manual_wal_flush(rocksdb_options_t* opt) {
  return opt->rep.manual_wal_flush;
}

3841 3842 3843 3844 3845 3846 3847 3848
void rocksdb_options_set_wal_compression(rocksdb_options_t* opt, int val) {
  opt->rep.wal_compression = static_cast<CompressionType>(val);
}

int rocksdb_options_get_wal_compression(rocksdb_options_t* opt) {
  return opt->rep.wal_compression;
}

3849 3850 3851
rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(int64_t rate_bytes_per_sec,
                                                  int64_t refill_period_us,
                                                  int32_t fairness) {
Z
zhangjinpeng1987 已提交
3852
  rocksdb_ratelimiter_t* rate_limiter = new rocksdb_ratelimiter_t;
3853
  rate_limiter->rep.reset(
3854
      NewGenericRateLimiter(rate_bytes_per_sec, refill_period_us, fairness));
Z
zhangjinpeng1987 已提交
3855 3856 3857
  return rate_limiter;
}

3858
void rocksdb_ratelimiter_destroy(rocksdb_ratelimiter_t* limiter) {
Z
zhangjinpeng1987 已提交
3859 3860 3861
  delete limiter;
}

3862 3863 3864
void rocksdb_options_set_row_cache(rocksdb_options_t* opt,
                                   rocksdb_cache_t* cache) {
  if (cache) {
3865 3866 3867 3868
    opt->rep.row_cache = cache->rep;
  }
}

3869 3870 3871 3872 3873 3874 3875 3876
void rocksdb_options_add_compact_on_deletion_collector_factory(
    rocksdb_options_t* opt, size_t window_size, size_t num_dels_trigger) {
  std::shared_ptr<ROCKSDB_NAMESPACE::TablePropertiesCollectorFactory>
      compact_on_del =
          NewCompactOnDeletionCollectorFactory(window_size, num_dels_trigger);
  opt->rep.table_properties_collector_factories.emplace_back(compact_on_del);
}

Q
QingpingWang 已提交
3877 3878 3879 3880 3881 3882 3883
void rocksdb_set_perf_level(int v) {
  PerfLevel level = static_cast<PerfLevel>(v);
  SetPerfLevel(level);
}

rocksdb_perfcontext_t* rocksdb_perfcontext_create() {
  rocksdb_perfcontext_t* context = new rocksdb_perfcontext_t;
3884
  context->rep = ROCKSDB_NAMESPACE::get_perf_context();
Q
QingpingWang 已提交
3885 3886 3887 3888 3889 3890 3891 3892
  return context;
}

void rocksdb_perfcontext_reset(rocksdb_perfcontext_t* context) {
  context->rep->Reset();
}

char* rocksdb_perfcontext_report(rocksdb_perfcontext_t* context,
3893
                                 unsigned char exclude_zero_counters) {
Q
QingpingWang 已提交
3894 3895 3896 3897
  return strdup(context->rep->ToString(exclude_zero_counters).c_str());
}

uint64_t rocksdb_perfcontext_metric(rocksdb_perfcontext_t* context,
3898
                                    int metric) {
Q
QingpingWang 已提交
3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036
  PerfContext* rep = context->rep;
  switch (metric) {
    case rocksdb_user_key_comparison_count:
      return rep->user_key_comparison_count;
    case rocksdb_block_cache_hit_count:
      return rep->block_cache_hit_count;
    case rocksdb_block_read_count:
      return rep->block_read_count;
    case rocksdb_block_read_byte:
      return rep->block_read_byte;
    case rocksdb_block_read_time:
      return rep->block_read_time;
    case rocksdb_block_checksum_time:
      return rep->block_checksum_time;
    case rocksdb_block_decompress_time:
      return rep->block_decompress_time;
    case rocksdb_get_read_bytes:
      return rep->get_read_bytes;
    case rocksdb_multiget_read_bytes:
      return rep->multiget_read_bytes;
    case rocksdb_iter_read_bytes:
      return rep->iter_read_bytes;
    case rocksdb_internal_key_skipped_count:
      return rep->internal_key_skipped_count;
    case rocksdb_internal_delete_skipped_count:
      return rep->internal_delete_skipped_count;
    case rocksdb_internal_recent_skipped_count:
      return rep->internal_recent_skipped_count;
    case rocksdb_internal_merge_count:
      return rep->internal_merge_count;
    case rocksdb_get_snapshot_time:
      return rep->get_snapshot_time;
    case rocksdb_get_from_memtable_time:
      return rep->get_from_memtable_time;
    case rocksdb_get_from_memtable_count:
      return rep->get_from_memtable_count;
    case rocksdb_get_post_process_time:
      return rep->get_post_process_time;
    case rocksdb_get_from_output_files_time:
      return rep->get_from_output_files_time;
    case rocksdb_seek_on_memtable_time:
      return rep->seek_on_memtable_time;
    case rocksdb_seek_on_memtable_count:
      return rep->seek_on_memtable_count;
    case rocksdb_next_on_memtable_count:
      return rep->next_on_memtable_count;
    case rocksdb_prev_on_memtable_count:
      return rep->prev_on_memtable_count;
    case rocksdb_seek_child_seek_time:
      return rep->seek_child_seek_time;
    case rocksdb_seek_child_seek_count:
      return rep->seek_child_seek_count;
    case rocksdb_seek_min_heap_time:
      return rep->seek_min_heap_time;
    case rocksdb_seek_max_heap_time:
      return rep->seek_max_heap_time;
    case rocksdb_seek_internal_seek_time:
      return rep->seek_internal_seek_time;
    case rocksdb_find_next_user_entry_time:
      return rep->find_next_user_entry_time;
    case rocksdb_write_wal_time:
      return rep->write_wal_time;
    case rocksdb_write_memtable_time:
      return rep->write_memtable_time;
    case rocksdb_write_delay_time:
      return rep->write_delay_time;
    case rocksdb_write_pre_and_post_process_time:
      return rep->write_pre_and_post_process_time;
    case rocksdb_db_mutex_lock_nanos:
      return rep->db_mutex_lock_nanos;
    case rocksdb_db_condition_wait_nanos:
      return rep->db_condition_wait_nanos;
    case rocksdb_merge_operator_time_nanos:
      return rep->merge_operator_time_nanos;
    case rocksdb_read_index_block_nanos:
      return rep->read_index_block_nanos;
    case rocksdb_read_filter_block_nanos:
      return rep->read_filter_block_nanos;
    case rocksdb_new_table_block_iter_nanos:
      return rep->new_table_block_iter_nanos;
    case rocksdb_new_table_iterator_nanos:
      return rep->new_table_iterator_nanos;
    case rocksdb_block_seek_nanos:
      return rep->block_seek_nanos;
    case rocksdb_find_table_nanos:
      return rep->find_table_nanos;
    case rocksdb_bloom_memtable_hit_count:
      return rep->bloom_memtable_hit_count;
    case rocksdb_bloom_memtable_miss_count:
      return rep->bloom_memtable_miss_count;
    case rocksdb_bloom_sst_hit_count:
      return rep->bloom_sst_hit_count;
    case rocksdb_bloom_sst_miss_count:
      return rep->bloom_sst_miss_count;
    case rocksdb_key_lock_wait_time:
      return rep->key_lock_wait_time;
    case rocksdb_key_lock_wait_count:
      return rep->key_lock_wait_count;
    case rocksdb_env_new_sequential_file_nanos:
      return rep->env_new_sequential_file_nanos;
    case rocksdb_env_new_random_access_file_nanos:
      return rep->env_new_random_access_file_nanos;
    case rocksdb_env_new_writable_file_nanos:
      return rep->env_new_writable_file_nanos;
    case rocksdb_env_reuse_writable_file_nanos:
      return rep->env_reuse_writable_file_nanos;
    case rocksdb_env_new_random_rw_file_nanos:
      return rep->env_new_random_rw_file_nanos;
    case rocksdb_env_new_directory_nanos:
      return rep->env_new_directory_nanos;
    case rocksdb_env_file_exists_nanos:
      return rep->env_file_exists_nanos;
    case rocksdb_env_get_children_nanos:
      return rep->env_get_children_nanos;
    case rocksdb_env_get_children_file_attributes_nanos:
      return rep->env_get_children_file_attributes_nanos;
    case rocksdb_env_delete_file_nanos:
      return rep->env_delete_file_nanos;
    case rocksdb_env_create_dir_nanos:
      return rep->env_create_dir_nanos;
    case rocksdb_env_create_dir_if_missing_nanos:
      return rep->env_create_dir_if_missing_nanos;
    case rocksdb_env_delete_dir_nanos:
      return rep->env_delete_dir_nanos;
    case rocksdb_env_get_file_size_nanos:
      return rep->env_get_file_size_nanos;
    case rocksdb_env_get_file_modification_time_nanos:
      return rep->env_get_file_modification_time_nanos;
    case rocksdb_env_rename_file_nanos:
      return rep->env_rename_file_nanos;
    case rocksdb_env_link_file_nanos:
      return rep->env_link_file_nanos;
    case rocksdb_env_lock_file_nanos:
      return rep->env_lock_file_nanos;
    case rocksdb_env_unlock_file_nanos:
      return rep->env_unlock_file_nanos;
    case rocksdb_env_new_logger_nanos:
      return rep->env_new_logger_nanos;
A
Akanksha Mahajan 已提交
4037 4038
    case rocksdb_number_async_seek:
      return rep->number_async_seek;
4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
    case rocksdb_blob_cache_hit_count:
      return rep->blob_cache_hit_count;
    case rocksdb_blob_read_count:
      return rep->blob_read_count;
    case rocksdb_blob_read_byte:
      return rep->blob_read_byte;
    case rocksdb_blob_read_time:
      return rep->blob_read_time;
    case rocksdb_blob_checksum_time:
      return rep->blob_checksum_time;
    case rocksdb_blob_decompress_time:
      return rep->blob_decompress_time;
4051 4052
    case rocksdb_internal_range_del_reseek_count:
      return rep->internal_range_del_reseek_count;
Q
QingpingWang 已提交
4053 4054 4055 4056 4057 4058 4059 4060 4061 4062
    default:
      break;
  }
  return 0;
}

void rocksdb_perfcontext_destroy(rocksdb_perfcontext_t* context) {
  delete context;
}

4063 4064
/*
TODO:
T
Thomas Adam 已提交
4065 4066 4067 4068 4069 4070 4071 4072 4073
DB::OpenForReadOnly
DB::KeyMayExist
DB::GetOptions
DB::GetSortedWalFiles
DB::GetLatestSequenceNumber
DB::GetUpdatesSince
DB::GetDbIdentity
DB::RunManualCompaction
custom cache
4074 4075 4076
table_properties_collectors
*/

4077
rocksdb_compactionfilter_t* rocksdb_compactionfilter_create(
4078 4079 4080 4081 4082 4083
    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),
4084 4085 4086 4087 4088
    const char* (*name)(void*)) {
  rocksdb_compactionfilter_t* result = new rocksdb_compactionfilter_t;
  result->state_ = state;
  result->destructor_ = destructor;
  result->filter_ = filter;
4089
  result->ignore_snapshots_ = true;
4090 4091 4092 4093
  result->name_ = name;
  return result;
}

4094
void rocksdb_compactionfilter_set_ignore_snapshots(
4095
    rocksdb_compactionfilter_t* filter, unsigned char whether_ignore) {
4096 4097 4098
  filter->ignore_snapshots_ = whether_ignore;
}

4099 4100 4101 4102
void rocksdb_compactionfilter_destroy(rocksdb_compactionfilter_t* filter) {
  delete filter;
}

4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131
unsigned char rocksdb_compactionfiltercontext_is_full_compaction(
    rocksdb_compactionfiltercontext_t* context) {
  return context->rep.is_full_compaction;
}

unsigned char rocksdb_compactionfiltercontext_is_manual_compaction(
    rocksdb_compactionfiltercontext_t* context) {
  return context->rep.is_manual_compaction;
}

rocksdb_compactionfilterfactory_t* rocksdb_compactionfilterfactory_create(
    void* state, void (*destructor)(void*),
    rocksdb_compactionfilter_t* (*create_compaction_filter)(
        void*, rocksdb_compactionfiltercontext_t* context),
    const char* (*name)(void*)) {
  rocksdb_compactionfilterfactory_t* result =
      new rocksdb_compactionfilterfactory_t;
  result->state_ = state;
  result->destructor_ = destructor;
  result->create_compaction_filter_ = create_compaction_filter;
  result->name_ = name;
  return result;
}

void rocksdb_compactionfilterfactory_destroy(
    rocksdb_compactionfilterfactory_t* factory) {
  delete factory;
}

4132
rocksdb_comparator_t* rocksdb_comparator_create(
4133 4134 4135
    void* state, void (*destructor)(void*),
    int (*compare)(void*, const char* a, size_t alen, const char* b,
                   size_t blen),
4136
    const char* (*name)(void*)) {
4137
  rocksdb_comparator_t* result = new rocksdb_comparator_t;
4138 4139 4140 4141
  result->state_ = state;
  result->destructor_ = destructor;
  result->compare_ = compare;
  result->name_ = name;
4142 4143
  result->compare_ts_ = nullptr;
  result->compare_without_ts_ = nullptr;
4144 4145 4146
  return result;
}

4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166
void rocksdb_comparator_destroy(rocksdb_comparator_t* cmp) { delete cmp; }

rocksdb_comparator_t* rocksdb_comparator_with_ts_create(
    void* state, void (*destructor)(void*),
    int (*compare)(void*, const char* a, size_t alen, const char* b,
                   size_t blen),
    int (*compare_ts)(void*, const char* a_ts, size_t a_tslen, const char* b_ts,
                      size_t b_tslen),
    int (*compare_without_ts)(void*, const char* a, size_t alen,
                              unsigned char a_has_ts, const char* b,
                              size_t blen, unsigned char b_has_ts),
    const char* (*name)(void*), size_t timestamp_size) {
  rocksdb_comparator_t* result = new rocksdb_comparator_t(timestamp_size);
  result->state_ = state;
  result->destructor_ = destructor;
  result->compare_ = compare;
  result->compare_ts_ = compare_ts;
  result->compare_without_ts_ = compare_without_ts;
  result->name_ = name;
  return result;
4167 4168
}

4169
void rocksdb_filterpolicy_destroy(rocksdb_filterpolicy_t* filter) {
S
Sanjay Ghemawat 已提交
4170 4171 4172
  delete filter;
}

4173 4174
rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_format(
    double bits_per_key, bool original_format) {
4175
  // Make a rocksdb_filterpolicy_t, but override all of its methods so
S
Sanjay Ghemawat 已提交
4176 4177
  // they delegate to a NewBloomFilterPolicy() instead of user
  // supplied C functions.
4178
  struct Wrapper : public rocksdb_filterpolicy_t {
S
Sanjay Ghemawat 已提交
4179
    const FilterPolicy* rep_;
4180
    ~Wrapper() override { delete rep_; }
I
Igor Sugak 已提交
4181
    const char* Name() const override { return rep_->Name(); }
4182 4183 4184
    const char* CompatibilityName() const override {
      return rep_->CompatibilityName();
    }
4185
    // No need to override GetFilterBitsBuilder if this one is overridden
4186 4187 4188
    ROCKSDB_NAMESPACE::FilterBitsBuilder* GetBuilderWithContext(
        const ROCKSDB_NAMESPACE::FilterBuildingContext& context)
        const override {
4189 4190
      return rep_->GetBuilderWithContext(context);
    }
4191
    ROCKSDB_NAMESPACE::FilterBitsReader* GetFilterBitsReader(
4192 4193 4194
        const Slice& contents) const override {
      return rep_->GetFilterBitsReader(contents);
    }
4195
    static void DoNothing(void*) {}
S
Sanjay Ghemawat 已提交
4196 4197
  };
  Wrapper* wrapper = new Wrapper;
4198
  wrapper->rep_ = NewBloomFilterPolicy(bits_per_key, original_format);
4199
  wrapper->state_ = nullptr;
S
Sanjay Ghemawat 已提交
4200 4201 4202 4203
  wrapper->destructor_ = &Wrapper::DoNothing;
  return wrapper;
}

4204 4205
rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom_full(
    double bits_per_key) {
4206 4207 4208
  return rocksdb_filterpolicy_create_bloom_format(bits_per_key, false);
}

4209
rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_bloom(double bits_per_key) {
4210 4211 4212
  return rocksdb_filterpolicy_create_bloom_format(bits_per_key, true);
}

Q
qieqieplus 已提交
4213
rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon_format(
4214
    double bloom_equivalent_bits_per_key, int bloom_before_level) {
Q
qieqieplus 已提交
4215 4216 4217 4218 4219 4220 4221
  // Make a rocksdb_filterpolicy_t, but override all of its methods so
  // they delegate to a NewRibbonFilterPolicy() instead of user
  // supplied C functions.
  struct Wrapper : public rocksdb_filterpolicy_t {
    const FilterPolicy* rep_;
    ~Wrapper() override { delete rep_; }
    const char* Name() const override { return rep_->Name(); }
4222 4223 4224
    const char* CompatibilityName() const override {
      return rep_->CompatibilityName();
    }
Q
qieqieplus 已提交
4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236
    ROCKSDB_NAMESPACE::FilterBitsBuilder* GetBuilderWithContext(
        const ROCKSDB_NAMESPACE::FilterBuildingContext& context)
        const override {
      return rep_->GetBuilderWithContext(context);
    }
    ROCKSDB_NAMESPACE::FilterBitsReader* GetFilterBitsReader(
        const Slice& contents) const override {
      return rep_->GetFilterBitsReader(contents);
    }
    static void DoNothing(void*) {}
  };
  Wrapper* wrapper = new Wrapper;
4237 4238
  wrapper->rep_ =
      NewRibbonFilterPolicy(bloom_equivalent_bits_per_key, bloom_before_level);
Q
qieqieplus 已提交
4239 4240 4241 4242 4243 4244
  wrapper->state_ = nullptr;
  wrapper->destructor_ = &Wrapper::DoNothing;
  return wrapper;
}

rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon(
4245
    double bloom_equivalent_bits_per_key) {
Q
qieqieplus 已提交
4246
  return rocksdb_filterpolicy_create_ribbon_format(
4247 4248 4249 4250 4251 4252 4253
      bloom_equivalent_bits_per_key, /*bloom_before_level = disabled*/ -1);
}

rocksdb_filterpolicy_t* rocksdb_filterpolicy_create_ribbon_hybrid(
    double bloom_equivalent_bits_per_key, int bloom_before_level) {
  return rocksdb_filterpolicy_create_ribbon_format(
      bloom_equivalent_bits_per_key, bloom_before_level);
Q
qieqieplus 已提交
4254 4255
}

T
Thomas Adam 已提交
4256
rocksdb_mergeoperator_t* rocksdb_mergeoperator_create(
4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268
    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),
T
Thomas Adam 已提交
4269 4270 4271 4272 4273 4274
    const char* (*name)(void*)) {
  rocksdb_mergeoperator_t* result = new rocksdb_mergeoperator_t;
  result->state_ = state;
  result->destructor_ = destructor;
  result->full_merge_ = full_merge;
  result->partial_merge_ = partial_merge;
4275
  result->delete_value_ = delete_value;
T
Thomas Adam 已提交
4276 4277 4278 4279 4280 4281 4282 4283
  result->name_ = name;
  return result;
}

void rocksdb_mergeoperator_destroy(rocksdb_mergeoperator_t* merge_operator) {
  delete merge_operator;
}

4284 4285
rocksdb_readoptions_t* rocksdb_readoptions_create() {
  return new rocksdb_readoptions_t;
4286 4287
}

4288
void rocksdb_readoptions_destroy(rocksdb_readoptions_t* opt) { delete opt; }
4289

4290 4291
void rocksdb_readoptions_set_verify_checksums(rocksdb_readoptions_t* opt,
                                              unsigned char v) {
4292 4293 4294
  opt->rep.verify_checksums = v;
}

4295 4296 4297 4298 4299
unsigned char rocksdb_readoptions_get_verify_checksums(
    rocksdb_readoptions_t* opt) {
  return opt->rep.verify_checksums;
}

4300 4301
void rocksdb_readoptions_set_fill_cache(rocksdb_readoptions_t* opt,
                                        unsigned char v) {
4302 4303 4304
  opt->rep.fill_cache = v;
}

4305 4306 4307 4308
unsigned char rocksdb_readoptions_get_fill_cache(rocksdb_readoptions_t* opt) {
  return opt->rep.fill_cache;
}

4309 4310
void rocksdb_readoptions_set_snapshot(rocksdb_readoptions_t* opt,
                                      const rocksdb_snapshot_t* snap) {
4311
  opt->rep.snapshot = (snap ? snap->rep : nullptr);
4312 4313
}

4314 4315 4316
void rocksdb_readoptions_set_iterate_upper_bound(rocksdb_readoptions_t* opt,
                                                 const char* key,
                                                 size_t keylen) {
4317 4318 4319 4320 4321 4322 4323 4324
  if (key == nullptr) {
    opt->upper_bound = Slice();
    opt->rep.iterate_upper_bound = nullptr;

  } else {
    opt->upper_bound = Slice(key, keylen);
    opt->rep.iterate_upper_bound = &opt->upper_bound;
  }
4325 4326
}

4327 4328 4329
void rocksdb_readoptions_set_iterate_lower_bound(rocksdb_readoptions_t* opt,
                                                 const char* key,
                                                 size_t keylen) {
4330 4331 4332 4333 4334 4335 4336 4337 4338
  if (key == nullptr) {
    opt->lower_bound = Slice();
    opt->rep.iterate_lower_bound = nullptr;
  } else {
    opt->lower_bound = Slice(key, keylen);
    opt->rep.iterate_lower_bound = &opt->lower_bound;
  }
}

4339
void rocksdb_readoptions_set_read_tier(rocksdb_readoptions_t* opt, int v) {
4340
  opt->rep.read_tier = static_cast<ROCKSDB_NAMESPACE::ReadTier>(v);
T
Thomas Adam 已提交
4341 4342
}

4343 4344 4345 4346
int rocksdb_readoptions_get_read_tier(rocksdb_readoptions_t* opt) {
  return static_cast<int>(opt->rep.read_tier);
}

4347 4348
void rocksdb_readoptions_set_tailing(rocksdb_readoptions_t* opt,
                                     unsigned char v) {
T
Thomas Adam 已提交
4349 4350 4351
  opt->rep.tailing = v;
}

4352 4353 4354 4355
unsigned char rocksdb_readoptions_get_tailing(rocksdb_readoptions_t* opt) {
  return opt->rep.tailing;
}

4356 4357
void rocksdb_readoptions_set_managed(rocksdb_readoptions_t* opt,
                                     unsigned char v) {
4358 4359 4360
  opt->rep.managed = v;
}

4361 4362
void rocksdb_readoptions_set_readahead_size(rocksdb_readoptions_t* opt,
                                            size_t v) {
S
siddontang 已提交
4363 4364 4365
  opt->rep.readahead_size = v;
}

4366 4367 4368 4369
size_t rocksdb_readoptions_get_readahead_size(rocksdb_readoptions_t* opt) {
  return opt->rep.readahead_size;
}

4370 4371
void rocksdb_readoptions_set_prefix_same_as_start(rocksdb_readoptions_t* opt,
                                                  unsigned char v) {
4372 4373 4374
  opt->rep.prefix_same_as_start = v;
}

4375 4376 4377 4378 4379
unsigned char rocksdb_readoptions_get_prefix_same_as_start(
    rocksdb_readoptions_t* opt) {
  return opt->rep.prefix_same_as_start;
}

4380 4381 4382 4383 4384
void rocksdb_readoptions_set_pin_data(rocksdb_readoptions_t* opt,
                                      unsigned char v) {
  opt->rep.pin_data = v;
}

4385 4386 4387 4388
unsigned char rocksdb_readoptions_get_pin_data(rocksdb_readoptions_t* opt) {
  return opt->rep.pin_data;
}

S
siddontang 已提交
4389 4390 4391 4392 4393
void rocksdb_readoptions_set_total_order_seek(rocksdb_readoptions_t* opt,
                                              unsigned char v) {
  opt->rep.total_order_seek = v;
}

4394 4395 4396 4397 4398
unsigned char rocksdb_readoptions_get_total_order_seek(
    rocksdb_readoptions_t* opt) {
  return opt->rep.total_order_seek;
}

4399
void rocksdb_readoptions_set_max_skippable_internal_keys(
4400
    rocksdb_readoptions_t* opt, uint64_t v) {
4401 4402 4403
  opt->rep.max_skippable_internal_keys = v;
}

4404 4405 4406 4407 4408
uint64_t rocksdb_readoptions_get_max_skippable_internal_keys(
    rocksdb_readoptions_t* opt) {
  return opt->rep.max_skippable_internal_keys;
}

4409 4410 4411 4412 4413
void rocksdb_readoptions_set_background_purge_on_iterator_cleanup(
    rocksdb_readoptions_t* opt, unsigned char v) {
  opt->rep.background_purge_on_iterator_cleanup = v;
}

4414 4415 4416 4417 4418
unsigned char rocksdb_readoptions_get_background_purge_on_iterator_cleanup(
    rocksdb_readoptions_t* opt) {
  return opt->rep.background_purge_on_iterator_cleanup;
}

4419 4420
void rocksdb_readoptions_set_ignore_range_deletions(rocksdb_readoptions_t* opt,
                                                    unsigned char v) {
4421 4422 4423
  opt->rep.ignore_range_deletions = v;
}

4424 4425 4426 4427 4428
unsigned char rocksdb_readoptions_get_ignore_range_deletions(
    rocksdb_readoptions_t* opt) {
  return opt->rep.ignore_range_deletions;
}

4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
void rocksdb_readoptions_set_deadline(rocksdb_readoptions_t* opt,
                                      uint64_t microseconds) {
  opt->rep.deadline = std::chrono::microseconds(microseconds);
}

uint64_t rocksdb_readoptions_get_deadline(rocksdb_readoptions_t* opt) {
  return opt->rep.deadline.count();
}

void rocksdb_readoptions_set_io_timeout(rocksdb_readoptions_t* opt,
                                        uint64_t microseconds) {
  opt->rep.io_timeout = std::chrono::microseconds(microseconds);
}

extern ROCKSDB_LIBRARY_API uint64_t
rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t* opt) {
  return opt->rep.io_timeout.count();
}

4448 4449 4450 4451 4452 4453 4454 4455 4456
void rocksdb_readoptions_set_async_io(rocksdb_readoptions_t* opt,
                                      unsigned char v) {
  opt->rep.async_io = v;
}

unsigned char rocksdb_readoptions_get_async_io(rocksdb_readoptions_t* opt) {
  return opt->rep.async_io;
}

4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478
void rocksdb_readoptions_set_timestamp(rocksdb_readoptions_t* opt,
                                       const char* ts, size_t tslen) {
  if (ts == nullptr) {
    opt->timestamp = Slice();
    opt->rep.timestamp = nullptr;
  } else {
    opt->timestamp = Slice(ts, tslen);
    opt->rep.timestamp = &opt->timestamp;
  }
}

void rocksdb_readoptions_set_iter_start_ts(rocksdb_readoptions_t* opt,
                                           const char* ts, size_t tslen) {
  if (ts == nullptr) {
    opt->iter_start_ts = Slice();
    opt->rep.iter_start_ts = nullptr;
  } else {
    opt->iter_start_ts = Slice(ts, tslen);
    opt->rep.iter_start_ts = &opt->iter_start_ts;
  }
}

4479 4480
rocksdb_writeoptions_t* rocksdb_writeoptions_create() {
  return new rocksdb_writeoptions_t;
4481 4482
}

4483
void rocksdb_writeoptions_destroy(rocksdb_writeoptions_t* opt) { delete opt; }
4484

4485 4486
void rocksdb_writeoptions_set_sync(rocksdb_writeoptions_t* opt,
                                   unsigned char v) {
4487 4488 4489
  opt->rep.sync = v;
}

4490 4491 4492 4493
unsigned char rocksdb_writeoptions_get_sync(rocksdb_writeoptions_t* opt) {
  return opt->rep.sync;
}

4494 4495
void rocksdb_writeoptions_disable_WAL(rocksdb_writeoptions_t* opt,
                                      int disable) {
4496 4497 4498
  opt->rep.disableWAL = disable;
}

4499 4500 4501 4502 4503
unsigned char rocksdb_writeoptions_get_disable_WAL(
    rocksdb_writeoptions_t* opt) {
  return opt->rep.disableWAL;
}

4504
void rocksdb_writeoptions_set_ignore_missing_column_families(
4505
    rocksdb_writeoptions_t* opt, unsigned char v) {
4506 4507 4508
  opt->rep.ignore_missing_column_families = v;
}

4509 4510 4511 4512 4513
unsigned char rocksdb_writeoptions_get_ignore_missing_column_families(
    rocksdb_writeoptions_t* opt) {
  return opt->rep.ignore_missing_column_families;
}

4514 4515
void rocksdb_writeoptions_set_no_slowdown(rocksdb_writeoptions_t* opt,
                                          unsigned char v) {
4516 4517 4518
  opt->rep.no_slowdown = v;
}

4519 4520 4521 4522 4523
unsigned char rocksdb_writeoptions_get_no_slowdown(
    rocksdb_writeoptions_t* opt) {
  return opt->rep.no_slowdown;
}

4524 4525
void rocksdb_writeoptions_set_low_pri(rocksdb_writeoptions_t* opt,
                                      unsigned char v) {
4526 4527 4528
  opt->rep.low_pri = v;
}

4529 4530 4531 4532
unsigned char rocksdb_writeoptions_get_low_pri(rocksdb_writeoptions_t* opt) {
  return opt->rep.low_pri;
}

4533 4534 4535 4536 4537
void rocksdb_writeoptions_set_memtable_insert_hint_per_batch(
    rocksdb_writeoptions_t* opt, unsigned char v) {
  opt->rep.memtable_insert_hint_per_batch = v;
}

4538 4539 4540 4541 4542
unsigned char rocksdb_writeoptions_get_memtable_insert_hint_per_batch(
    rocksdb_writeoptions_t* opt) {
  return opt->rep.memtable_insert_hint_per_batch;
}

Z
zhangjinpeng1987 已提交
4543 4544 4545 4546 4547 4548 4549 4550
rocksdb_compactoptions_t* rocksdb_compactoptions_create() {
  return new rocksdb_compactoptions_t;
}

void rocksdb_compactoptions_destroy(rocksdb_compactoptions_t* opt) {
  delete opt;
}

4551 4552
void rocksdb_compactoptions_set_bottommost_level_compaction(
    rocksdb_compactoptions_t* opt, unsigned char v) {
4553 4554
  opt->rep.bottommost_level_compaction =
      static_cast<BottommostLevelCompaction>(v);
4555 4556
}

4557 4558 4559 4560 4561
unsigned char rocksdb_compactoptions_get_bottommost_level_compaction(
    rocksdb_compactoptions_t* opt) {
  return static_cast<unsigned char>(opt->rep.bottommost_level_compaction);
}

Z
zhangjinpeng1987 已提交
4562 4563 4564 4565 4566
void rocksdb_compactoptions_set_exclusive_manual_compaction(
    rocksdb_compactoptions_t* opt, unsigned char v) {
  opt->rep.exclusive_manual_compaction = v;
}

4567 4568 4569 4570 4571
unsigned char rocksdb_compactoptions_get_exclusive_manual_compaction(
    rocksdb_compactoptions_t* opt) {
  return opt->rep.exclusive_manual_compaction;
}

Z
zhangjinpeng1987 已提交
4572 4573 4574 4575 4576
void rocksdb_compactoptions_set_change_level(rocksdb_compactoptions_t* opt,
                                             unsigned char v) {
  opt->rep.change_level = v;
}

4577 4578 4579 4580 4581
unsigned char rocksdb_compactoptions_get_change_level(
    rocksdb_compactoptions_t* opt) {
  return opt->rep.change_level;
}

Z
zhangjinpeng1987 已提交
4582 4583 4584 4585
void rocksdb_compactoptions_set_target_level(rocksdb_compactoptions_t* opt,
                                             int n) {
  opt->rep.target_level = n;
}
4586

4587 4588 4589 4590
int rocksdb_compactoptions_get_target_level(rocksdb_compactoptions_t* opt) {
  return opt->rep.target_level;
}

4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601
void rocksdb_compactoptions_set_full_history_ts_low(
    rocksdb_compactoptions_t* opt, char* ts, size_t tslen) {
  if (ts == nullptr) {
    opt->full_history_ts_low = Slice();
    opt->rep.full_history_ts_low = nullptr;
  } else {
    opt->full_history_ts_low = Slice(ts, tslen);
    opt->rep.full_history_ts_low = &opt->full_history_ts_low;
  }
}

T
Thomas Adam 已提交
4602 4603 4604 4605
rocksdb_flushoptions_t* rocksdb_flushoptions_create() {
  return new rocksdb_flushoptions_t;
}

4606
void rocksdb_flushoptions_destroy(rocksdb_flushoptions_t* opt) { delete opt; }
T
Thomas Adam 已提交
4607

4608 4609
void rocksdb_flushoptions_set_wait(rocksdb_flushoptions_t* opt,
                                   unsigned char v) {
T
Thomas Adam 已提交
4610 4611 4612
  opt->rep.wait = v;
}

4613 4614 4615 4616
unsigned char rocksdb_flushoptions_get_wait(rocksdb_flushoptions_t* opt) {
  return opt->rep.wait;
}

4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642
rocksdb_memory_allocator_t* rocksdb_jemalloc_nodump_allocator_create(
    char** errptr) {
  rocksdb_memory_allocator_t* allocator = new rocksdb_memory_allocator_t;
  ROCKSDB_NAMESPACE::JemallocAllocatorOptions options;
  SaveError(errptr, ROCKSDB_NAMESPACE::NewJemallocNodumpAllocator(
                        options, &allocator->rep));
  return allocator;
}

void rocksdb_memory_allocator_destroy(rocksdb_memory_allocator_t* allocator) {
  delete allocator;
}

rocksdb_lru_cache_options_t* rocksdb_lru_cache_options_create() {
  return new rocksdb_lru_cache_options_t;
}

void rocksdb_lru_cache_options_destroy(rocksdb_lru_cache_options_t* opt) {
  delete opt;
}

void rocksdb_lru_cache_options_set_capacity(rocksdb_lru_cache_options_t* opt,
                                            size_t capacity) {
  opt->rep.capacity = capacity;
}

4643 4644 4645 4646 4647
void rocksdb_lru_cache_options_set_num_shard_bits(
    rocksdb_lru_cache_options_t* opt, int num_shard_bits) {
  opt->rep.num_shard_bits = num_shard_bits;
}

4648 4649 4650 4651 4652
void rocksdb_lru_cache_options_set_memory_allocator(
    rocksdb_lru_cache_options_t* opt, rocksdb_memory_allocator_t* allocator) {
  opt->rep.memory_allocator = allocator->rep;
}

4653 4654
rocksdb_cache_t* rocksdb_cache_create_lru(size_t capacity) {
  rocksdb_cache_t* c = new rocksdb_cache_t;
4655 4656 4657 4658
  c->rep = NewLRUCache(capacity);
  return c;
}

4659 4660 4661 4662 4663 4664 4665 4666
rocksdb_cache_t* rocksdb_cache_create_lru_with_strict_capacity_limit(
    size_t capacity) {
  rocksdb_cache_t* c = new rocksdb_cache_t;
  c->rep = NewLRUCache(capacity);
  c->rep->SetStrictCapacityLimit(true);
  return c;
}

4667 4668 4669 4670 4671 4672 4673
rocksdb_cache_t* rocksdb_cache_create_lru_opts(
    rocksdb_lru_cache_options_t* opt) {
  rocksdb_cache_t* c = new rocksdb_cache_t;
  c->rep = NewLRUCache(opt->rep);
  return c;
}

4674
void rocksdb_cache_destroy(rocksdb_cache_t* cache) { delete cache; }
4675

4676 4677 4678 4679
void rocksdb_cache_disown_data(rocksdb_cache_t* cache) {
  cache->rep->DisownData();
}

4680 4681 4682 4683
void rocksdb_cache_set_capacity(rocksdb_cache_t* cache, size_t capacity) {
  cache->rep->SetCapacity(capacity);
}

4684 4685 4686 4687
size_t rocksdb_cache_get_capacity(rocksdb_cache_t* cache) {
  return cache->rep->GetCapacity();
}

4688 4689 4690 4691 4692 4693 4694 4695
size_t rocksdb_cache_get_usage(rocksdb_cache_t* cache) {
  return cache->rep->GetUsage();
}

size_t rocksdb_cache_get_pinned_usage(rocksdb_cache_t* cache) {
  return cache->rep->GetPinnedUsage();
}

4696 4697
rocksdb_dbpath_t* rocksdb_dbpath_create(const char* path,
                                        uint64_t target_size) {
K
kapitan-k 已提交
4698 4699 4700 4701 4702 4703
  rocksdb_dbpath_t* result = new rocksdb_dbpath_t;
  result->rep.path = std::string(path);
  result->rep.target_size = target_size;
  return result;
}

4704
void rocksdb_dbpath_destroy(rocksdb_dbpath_t* dbpath) { delete dbpath; }
K
kapitan-k 已提交
4705

4706 4707
rocksdb_env_t* rocksdb_create_default_env() {
  rocksdb_env_t* result = new rocksdb_env_t;
4708 4709 4710 4711 4712
  result->rep = Env::Default();
  result->is_default = true;
  return result;
}

4713 4714
rocksdb_env_t* rocksdb_create_mem_env() {
  rocksdb_env_t* result = new rocksdb_env_t;
4715
  result->rep = ROCKSDB_NAMESPACE::NewMemEnv(Env::Default());
4716 4717 4718 4719
  result->is_default = false;
  return result;
}

4720 4721 4722 4723
void rocksdb_env_set_background_threads(rocksdb_env_t* env, int n) {
  env->rep->SetBackgroundThreads(n);
}

4724 4725 4726 4727
int rocksdb_env_get_background_threads(rocksdb_env_t* env) {
  return env->rep->GetBackgroundThreads();
}

4728 4729 4730 4731 4732
void rocksdb_env_set_bottom_priority_background_threads(rocksdb_env_t* env,
                                                        int n) {
  env->rep->SetBackgroundThreads(n, Env::BOTTOM);
}

4733 4734 4735 4736
int rocksdb_env_get_bottom_priority_background_threads(rocksdb_env_t* env) {
  return env->rep->GetBackgroundThreads(Env::BOTTOM);
}

4737 4738
void rocksdb_env_set_high_priority_background_threads(rocksdb_env_t* env,
                                                      int n) {
4739 4740 4741
  env->rep->SetBackgroundThreads(n, Env::HIGH);
}

4742 4743 4744 4745
int rocksdb_env_get_high_priority_background_threads(rocksdb_env_t* env) {
  return env->rep->GetBackgroundThreads(Env::HIGH);
}

4746 4747 4748 4749 4750
void rocksdb_env_set_low_priority_background_threads(rocksdb_env_t* env,
                                                     int n) {
  env->rep->SetBackgroundThreads(n, Env::LOW);
}

4751 4752 4753 4754
int rocksdb_env_get_low_priority_background_threads(rocksdb_env_t* env) {
  return env->rep->GetBackgroundThreads(Env::LOW);
}

D
Dmitri Smirnov 已提交
4755
void rocksdb_env_join_all_threads(rocksdb_env_t* env) {
S
sdong 已提交
4756
  env->rep->WaitForJoin();
D
Dmitri Smirnov 已提交
4757 4758
}

4759 4760 4761 4762
void rocksdb_env_lower_thread_pool_io_priority(rocksdb_env_t* env) {
  env->rep->LowerThreadPoolIOPriority();
}

4763 4764
void rocksdb_env_lower_high_priority_thread_pool_io_priority(
    rocksdb_env_t* env) {
4765 4766 4767 4768 4769 4770 4771
  env->rep->LowerThreadPoolIOPriority(Env::HIGH);
}

void rocksdb_env_lower_thread_pool_cpu_priority(rocksdb_env_t* env) {
  env->rep->LowerThreadPoolCPUPriority();
}

4772 4773
void rocksdb_env_lower_high_priority_thread_pool_cpu_priority(
    rocksdb_env_t* env) {
4774 4775 4776
  env->rep->LowerThreadPoolCPUPriority(Env::HIGH);
}

4777
void rocksdb_env_destroy(rocksdb_env_t* env) {
4778 4779 4780 4781
  if (!env->is_default) delete env->rep;
  delete env;
}

J
Jay Lee 已提交
4782 4783 4784 4785 4786 4787 4788 4789 4790 4791
rocksdb_envoptions_t* rocksdb_envoptions_create() {
  rocksdb_envoptions_t* opt = new rocksdb_envoptions_t;
  return opt;
}

void rocksdb_envoptions_destroy(rocksdb_envoptions_t* opt) { delete opt; }

rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create(
    const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options) {
  rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t;
4792
  writer->rep = new SstFileWriter(env->rep, io_options->rep);
J
Jay Lee 已提交
4793 4794 4795
  return writer;
}

A
Akanksha Mahajan 已提交
4796 4797 4798 4799 4800
void rocksdb_create_dir_if_missing(rocksdb_env_t* env, const char* path,
                                   char** errptr) {
  SaveError(errptr, env->rep->CreateDirIfMissing(std::string(path)));
}

J
Jay Lee 已提交
4801 4802
rocksdb_sstfilewriter_t* rocksdb_sstfilewriter_create_with_comparator(
    const rocksdb_envoptions_t* env, const rocksdb_options_t* io_options,
A
Andrew Kryczka 已提交
4803
    const rocksdb_comparator_t* /*comparator*/) {
J
Jay Lee 已提交
4804
  rocksdb_sstfilewriter_t* writer = new rocksdb_sstfilewriter_t;
4805
  writer->rep = new SstFileWriter(env->rep, io_options->rep);
J
Jay Lee 已提交
4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816
  return writer;
}

void rocksdb_sstfilewriter_open(rocksdb_sstfilewriter_t* writer,
                                const char* name, char** errptr) {
  SaveError(errptr, writer->rep->Open(std::string(name)));
}

void rocksdb_sstfilewriter_add(rocksdb_sstfilewriter_t* writer, const char* key,
                               size_t keylen, const char* val, size_t vallen,
                               char** errptr) {
4817 4818 4819 4820 4821 4822 4823 4824 4825
  SaveError(errptr, writer->rep->Put(Slice(key, keylen), Slice(val, vallen)));
}

void rocksdb_sstfilewriter_put(rocksdb_sstfilewriter_t* writer, const char* key,
                               size_t keylen, const char* val, size_t vallen,
                               char** errptr) {
  SaveError(errptr, writer->rep->Put(Slice(key, keylen), Slice(val, vallen)));
}

4826 4827 4828 4829 4830 4831 4832 4833 4834
void rocksdb_sstfilewriter_put_with_ts(rocksdb_sstfilewriter_t* writer,
                                       const char* key, size_t keylen,
                                       const char* ts, size_t tslen,
                                       const char* val, size_t vallen,
                                       char** errptr) {
  SaveError(errptr, writer->rep->Put(Slice(key, keylen), Slice(ts, tslen),
                                     Slice(val, vallen)));
}

4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845
void rocksdb_sstfilewriter_merge(rocksdb_sstfilewriter_t* writer,
                                 const char* key, size_t keylen,
                                 const char* val, size_t vallen,
                                 char** errptr) {
  SaveError(errptr, writer->rep->Merge(Slice(key, keylen), Slice(val, vallen)));
}

void rocksdb_sstfilewriter_delete(rocksdb_sstfilewriter_t* writer,
                                  const char* key, size_t keylen,
                                  char** errptr) {
  SaveError(errptr, writer->rep->Delete(Slice(key, keylen)));
J
Jay Lee 已提交
4846 4847
}

4848 4849 4850 4851 4852 4853 4854
void rocksdb_sstfilewriter_delete_with_ts(rocksdb_sstfilewriter_t* writer,
                                          const char* key, size_t keylen,
                                          const char* ts, size_t tslen,
                                          char** errptr) {
  SaveError(errptr, writer->rep->Delete(Slice(key, keylen), Slice(ts, tslen)));
}

4855 4856 4857 4858 4859 4860 4861 4862 4863
void rocksdb_sstfilewriter_delete_range(rocksdb_sstfilewriter_t* writer,
                                        const char* begin_key,
                                        size_t begin_keylen,
                                        const char* end_key, size_t end_keylen,
                                        char** errptr) {
  SaveError(errptr, writer->rep->DeleteRange(Slice(begin_key, begin_keylen),
                                             Slice(end_key, end_keylen)));
}

J
Jay Lee 已提交
4864 4865
void rocksdb_sstfilewriter_finish(rocksdb_sstfilewriter_t* writer,
                                  char** errptr) {
4866
  SaveError(errptr, writer->rep->Finish(nullptr));
J
Jay Lee 已提交
4867 4868
}

4869
void rocksdb_sstfilewriter_file_size(rocksdb_sstfilewriter_t* writer,
4870
                                     uint64_t* file_size) {
4871 4872 4873
  *file_size = writer->rep->FileSize();
}

J
Jay Lee 已提交
4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908
void rocksdb_sstfilewriter_destroy(rocksdb_sstfilewriter_t* writer) {
  delete writer->rep;
  delete writer;
}

rocksdb_ingestexternalfileoptions_t*
rocksdb_ingestexternalfileoptions_create() {
  rocksdb_ingestexternalfileoptions_t* opt =
      new rocksdb_ingestexternalfileoptions_t;
  return opt;
}

void rocksdb_ingestexternalfileoptions_set_move_files(
    rocksdb_ingestexternalfileoptions_t* opt, unsigned char move_files) {
  opt->rep.move_files = move_files;
}

void rocksdb_ingestexternalfileoptions_set_snapshot_consistency(
    rocksdb_ingestexternalfileoptions_t* opt,
    unsigned char snapshot_consistency) {
  opt->rep.snapshot_consistency = snapshot_consistency;
}

void rocksdb_ingestexternalfileoptions_set_allow_global_seqno(
    rocksdb_ingestexternalfileoptions_t* opt,
    unsigned char allow_global_seqno) {
  opt->rep.allow_global_seqno = allow_global_seqno;
}

void rocksdb_ingestexternalfileoptions_set_allow_blocking_flush(
    rocksdb_ingestexternalfileoptions_t* opt,
    unsigned char allow_blocking_flush) {
  opt->rep.allow_blocking_flush = allow_blocking_flush;
}

4909
void rocksdb_ingestexternalfileoptions_set_ingest_behind(
4910
    rocksdb_ingestexternalfileoptions_t* opt, unsigned char ingest_behind) {
4911 4912 4913
  opt->rep.ingest_behind = ingest_behind;
}

J
Jay Lee 已提交
4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939
void rocksdb_ingestexternalfileoptions_destroy(
    rocksdb_ingestexternalfileoptions_t* opt) {
  delete opt;
}

void rocksdb_ingest_external_file(
    rocksdb_t* db, const char* const* file_list, const size_t list_len,
    const rocksdb_ingestexternalfileoptions_t* opt, char** errptr) {
  std::vector<std::string> files(list_len);
  for (size_t i = 0; i < list_len; ++i) {
    files[i] = std::string(file_list[i]);
  }
  SaveError(errptr, db->rep->IngestExternalFile(files, opt->rep));
}

void 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) {
  std::vector<std::string> files(list_len);
  for (size_t i = 0; i < list_len; ++i) {
    files[i] = std::string(file_list[i]);
  }
  SaveError(errptr, db->rep->IngestExternalFile(handle->rep, files, opt->rep));
}

4940 4941 4942 4943
void rocksdb_try_catch_up_with_primary(rocksdb_t* db, char** errptr) {
  SaveError(errptr, db->rep->TryCatchUpWithPrimary());
}

T
Thomas Adam 已提交
4944
rocksdb_slicetransform_t* rocksdb_slicetransform_create(
4945 4946 4947 4948 4949
    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),
T
Thomas Adam 已提交
4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960
    const char* (*name)(void*)) {
  rocksdb_slicetransform_t* result = new rocksdb_slicetransform_t;
  result->state_ = state;
  result->destructor_ = destructor;
  result->transform_ = transform;
  result->in_domain_ = in_domain;
  result->in_range_ = in_range;
  result->name_ = name;
  return result;
}

4961
void rocksdb_slicetransform_destroy(rocksdb_slicetransform_t* st) { delete st; }
T
Thomas Adam 已提交
4962

4963
struct SliceTransformWrapper : public rocksdb_slicetransform_t {
4964
  const SliceTransform* rep_;
4965
  ~SliceTransformWrapper() override { delete rep_; }
4966
  const char* Name() const override { return rep_->Name(); }
4967
  std::string GetId() const override { return rep_->GetId(); }
4968 4969 4970
  Slice Transform(const Slice& src) const override {
    return rep_->Transform(src);
  }
4971
  bool InDomain(const Slice& src) const override { return rep_->InDomain(src); }
4972
  bool InRange(const Slice& src) const override { return rep_->InRange(src); }
4973
  static void DoNothing(void*) {}
4974 4975
};

4976 4977
rocksdb_slicetransform_t* rocksdb_slicetransform_create_fixed_prefix(
    size_t prefixLen) {
4978
  SliceTransformWrapper* wrapper = new SliceTransformWrapper;
4979
  wrapper->rep_ = ROCKSDB_NAMESPACE::NewFixedPrefixTransform(prefixLen);
4980
  wrapper->state_ = nullptr;
4981
  wrapper->destructor_ = &SliceTransformWrapper::DoNothing;
T
Thomas Adam 已提交
4982 4983 4984
  return wrapper;
}

4985
rocksdb_slicetransform_t* rocksdb_slicetransform_create_noop() {
4986
  SliceTransformWrapper* wrapper = new SliceTransformWrapper;
4987
  wrapper->rep_ = ROCKSDB_NAMESPACE::NewNoopTransform();
4988
  wrapper->state_ = nullptr;
4989
  wrapper->destructor_ = &SliceTransformWrapper::DoNothing;
4990 4991 4992
  return wrapper;
}

4993 4994 4995 4996
rocksdb_universal_compaction_options_t*
rocksdb_universal_compaction_options_create() {
  rocksdb_universal_compaction_options_t* result =
      new rocksdb_universal_compaction_options_t;
4997
  result->rep = new ROCKSDB_NAMESPACE::CompactionOptionsUniversal;
4998 4999 5000 5001
  return result;
}

void rocksdb_universal_compaction_options_set_size_ratio(
5002
    rocksdb_universal_compaction_options_t* uco, int ratio) {
5003 5004 5005
  uco->rep->size_ratio = ratio;
}

5006 5007 5008 5009 5010
int rocksdb_universal_compaction_options_get_size_ratio(
    rocksdb_universal_compaction_options_t* uco) {
  return uco->rep->size_ratio;
}

5011
void rocksdb_universal_compaction_options_set_min_merge_width(
5012
    rocksdb_universal_compaction_options_t* uco, int w) {
5013 5014 5015
  uco->rep->min_merge_width = w;
}

5016 5017 5018 5019 5020
int rocksdb_universal_compaction_options_get_min_merge_width(
    rocksdb_universal_compaction_options_t* uco) {
  return uco->rep->min_merge_width;
}

5021
void rocksdb_universal_compaction_options_set_max_merge_width(
5022
    rocksdb_universal_compaction_options_t* uco, int w) {
5023 5024 5025
  uco->rep->max_merge_width = w;
}

5026 5027 5028 5029 5030
int rocksdb_universal_compaction_options_get_max_merge_width(
    rocksdb_universal_compaction_options_t* uco) {
  return uco->rep->max_merge_width;
}

5031
void rocksdb_universal_compaction_options_set_max_size_amplification_percent(
5032
    rocksdb_universal_compaction_options_t* uco, int p) {
5033 5034 5035
  uco->rep->max_size_amplification_percent = p;
}

5036 5037 5038 5039 5040
int rocksdb_universal_compaction_options_get_max_size_amplification_percent(
    rocksdb_universal_compaction_options_t* uco) {
  return uco->rep->max_size_amplification_percent;
}

5041
void rocksdb_universal_compaction_options_set_compression_size_percent(
5042
    rocksdb_universal_compaction_options_t* uco, int p) {
5043 5044 5045
  uco->rep->compression_size_percent = p;
}

5046 5047 5048 5049 5050
int rocksdb_universal_compaction_options_get_compression_size_percent(
    rocksdb_universal_compaction_options_t* uco) {
  return uco->rep->compression_size_percent;
}

5051
void rocksdb_universal_compaction_options_set_stop_style(
5052
    rocksdb_universal_compaction_options_t* uco, int style) {
5053 5054
  uco->rep->stop_style =
      static_cast<ROCKSDB_NAMESPACE::CompactionStopStyle>(style);
5055 5056
}

5057 5058 5059 5060 5061
int rocksdb_universal_compaction_options_get_stop_style(
    rocksdb_universal_compaction_options_t* uco) {
  return static_cast<int>(uco->rep->stop_style);
}

5062
void rocksdb_universal_compaction_options_destroy(
5063
    rocksdb_universal_compaction_options_t* uco) {
5064 5065 5066 5067
  delete uco->rep;
  delete uco;
}

5068
rocksdb_fifo_compaction_options_t* rocksdb_fifo_compaction_options_create() {
5069 5070 5071
  rocksdb_fifo_compaction_options_t* result =
      new rocksdb_fifo_compaction_options_t;
  result->rep = CompactionOptionsFIFO();
5072 5073 5074 5075 5076 5077 5078 5079
  return result;
}

void rocksdb_fifo_compaction_options_set_max_table_files_size(
    rocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size) {
  fifo_opts->rep.max_table_files_size = size;
}

5080 5081 5082 5083 5084
uint64_t rocksdb_fifo_compaction_options_get_max_table_files_size(
    rocksdb_fifo_compaction_options_t* fifo_opts) {
  return fifo_opts->rep.max_table_files_size;
}

5085 5086 5087 5088 5089
void rocksdb_fifo_compaction_options_destroy(
    rocksdb_fifo_compaction_options_t* fifo_opts) {
  delete fifo_opts;
}

5090 5091
void rocksdb_options_set_min_level_to_compress(rocksdb_options_t* opt,
                                               int level) {
A
Albert Strasheim 已提交
5092 5093 5094 5095
  if (level >= 0) {
    assert(level <= opt->rep.num_levels);
    opt->rep.compression_per_level.resize(opt->rep.num_levels);
    for (int i = 0; i < level; i++) {
5096
      opt->rep.compression_per_level[i] = ROCKSDB_NAMESPACE::kNoCompression;
A
Albert Strasheim 已提交
5097 5098 5099 5100 5101 5102 5103
    }
    for (int i = level; i < opt->rep.num_levels; i++) {
      opt->rep.compression_per_level[i] = opt->rep.compression;
    }
  }
}

5104
int rocksdb_livefiles_count(const rocksdb_livefiles_t* lf) {
5105
  return static_cast<int>(lf->rep.size());
A
Albert Strasheim 已提交
5106 5107
}

5108 5109 5110 5111 5112
const char* rocksdb_livefiles_column_family_name(const rocksdb_livefiles_t* lf,
                                                 int index) {
  return lf->rep[index].column_family_name.c_str();
}

5113
const char* rocksdb_livefiles_name(const rocksdb_livefiles_t* lf, int index) {
A
Albert Strasheim 已提交
5114 5115 5116
  return lf->rep[index].name.c_str();
}

5117
int rocksdb_livefiles_level(const rocksdb_livefiles_t* lf, int index) {
A
Albert Strasheim 已提交
5118 5119 5120
  return lf->rep[index].level;
}

5121
size_t rocksdb_livefiles_size(const rocksdb_livefiles_t* lf, int index) {
A
Albert Strasheim 已提交
5122 5123 5124
  return lf->rep[index].size;
}

5125 5126
const char* rocksdb_livefiles_smallestkey(const rocksdb_livefiles_t* lf,
                                          int index, size_t* size) {
A
Albert Strasheim 已提交
5127 5128 5129 5130
  *size = lf->rep[index].smallestkey.size();
  return lf->rep[index].smallestkey.data();
}

5131 5132
const char* rocksdb_livefiles_largestkey(const rocksdb_livefiles_t* lf,
                                         int index, size_t* size) {
A
Albert Strasheim 已提交
5133 5134 5135 5136
  *size = lf->rep[index].largestkey.size();
  return lf->rep[index].largestkey.data();
}

5137
uint64_t rocksdb_livefiles_entries(const rocksdb_livefiles_t* lf, int index) {
5138 5139 5140
  return lf->rep[index].num_entries;
}

5141
uint64_t rocksdb_livefiles_deletions(const rocksdb_livefiles_t* lf, int index) {
5142 5143 5144
  return lf->rep[index].num_deletions;
}

5145
extern void rocksdb_livefiles_destroy(const rocksdb_livefiles_t* lf) {
A
Albert Strasheim 已提交
5146 5147 5148
  delete lf;
}

S
sdong 已提交
5149 5150 5151 5152 5153 5154 5155
void rocksdb_get_options_from_string(const rocksdb_options_t* base_options,
                                     const char* opts_str,
                                     rocksdb_options_t* new_options,
                                     char** errptr) {
  SaveError(errptr,
            GetOptionsFromString(base_options->rep, std::string(opts_str),
                                 &new_options->rep));
D
Dmitri Smirnov 已提交
5156 5157
}

5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182
void 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) {
  Slice a, b;
  SaveError(
      errptr,
      DeleteFilesInRange(
          db->rep, db->rep->DefaultColumnFamily(),
          (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
          (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)));
}

void 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) {
  Slice a, b;
  SaveError(
      errptr,
      DeleteFilesInRange(
          db->rep, column_family->rep,
          (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
          (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)));
}

5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295
/* MetaData */

rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata(
    rocksdb_t* db) {
  rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t;
  db->rep->GetColumnFamilyMetaData(&meta->rep);
  return meta;
}

rocksdb_column_family_metadata_t* rocksdb_get_column_family_metadata_cf(
    rocksdb_t* db, rocksdb_column_family_handle_t* column_family) {
  rocksdb_column_family_metadata_t* meta = new rocksdb_column_family_metadata_t;
  db->rep->GetColumnFamilyMetaData(column_family->rep, &meta->rep);
  return meta;
}

void rocksdb_column_family_metadata_destroy(
    rocksdb_column_family_metadata_t* cf_meta) {
  delete cf_meta;
}

uint64_t rocksdb_column_family_metadata_get_size(
    rocksdb_column_family_metadata_t* cf_meta) {
  return cf_meta->rep.size;
}

size_t rocksdb_column_family_metadata_get_file_count(
    rocksdb_column_family_metadata_t* cf_meta) {
  return cf_meta->rep.file_count;
}

char* rocksdb_column_family_metadata_get_name(
    rocksdb_column_family_metadata_t* cf_meta) {
  return strdup(cf_meta->rep.name.c_str());
}

size_t rocksdb_column_family_metadata_get_level_count(
    rocksdb_column_family_metadata_t* cf_meta) {
  return cf_meta->rep.levels.size();
}

rocksdb_level_metadata_t* rocksdb_column_family_metadata_get_level_metadata(
    rocksdb_column_family_metadata_t* cf_meta, size_t i) {
  if (i >= cf_meta->rep.levels.size()) {
    return NULL;
  }
  rocksdb_level_metadata_t* level_meta =
      (rocksdb_level_metadata_t*)malloc(sizeof(rocksdb_level_metadata_t));
  level_meta->rep = &cf_meta->rep.levels[i];

  return level_meta;
}

void rocksdb_level_metadata_destroy(rocksdb_level_metadata_t* level_meta) {
  // Only free the base pointer as its parent rocksdb_column_family_metadata_t
  // has the ownership of its rep.
  free(level_meta);
}

int rocksdb_level_metadata_get_level(rocksdb_level_metadata_t* level_meta) {
  return level_meta->rep->level;
}

uint64_t rocksdb_level_metadata_get_size(rocksdb_level_metadata_t* level_meta) {
  return level_meta->rep->size;
}

size_t rocksdb_level_metadata_get_file_count(
    rocksdb_level_metadata_t* level_meta) {
  return level_meta->rep->files.size();
}

rocksdb_sst_file_metadata_t* rocksdb_level_metadata_get_sst_file_metadata(
    rocksdb_level_metadata_t* level_meta, size_t i) {
  if (i >= level_meta->rep->files.size()) {
    return nullptr;
  }
  rocksdb_sst_file_metadata_t* file_meta =
      (rocksdb_sst_file_metadata_t*)malloc(sizeof(rocksdb_sst_file_metadata_t));
  file_meta->rep = &level_meta->rep->files[i];
  return file_meta;
}

void rocksdb_sst_file_metadata_destroy(rocksdb_sst_file_metadata_t* file_meta) {
  // Only free the base pointer as its parent rocksdb_level_metadata_t
  // has the ownership of its rep.
  free(file_meta);
}

char* rocksdb_sst_file_metadata_get_relative_filename(
    rocksdb_sst_file_metadata_t* file_meta) {
  return strdup(file_meta->rep->relative_filename.c_str());
}

uint64_t rocksdb_sst_file_metadata_get_size(
    rocksdb_sst_file_metadata_t* file_meta) {
  return file_meta->rep->size;
}

char* rocksdb_sst_file_metadata_get_smallestkey(
    rocksdb_sst_file_metadata_t* file_meta, size_t* key_len) {
  *key_len = file_meta->rep->smallestkey.size();
  return CopyString(file_meta->rep->smallestkey);
}

char* rocksdb_sst_file_metadata_get_largestkey(
    rocksdb_sst_file_metadata_t* file_meta, size_t* key_len) {
  *key_len = file_meta->rep->largestkey.size();
  return CopyString(file_meta->rep->largestkey);
}

/* Transactions */

5296 5297 5298 5299
rocksdb_transactiondb_options_t* rocksdb_transactiondb_options_create() {
  return new rocksdb_transactiondb_options_t;
}

5300 5301
void rocksdb_transactiondb_options_destroy(
    rocksdb_transactiondb_options_t* opt) {
5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362
  delete opt;
}

void rocksdb_transactiondb_options_set_max_num_locks(
    rocksdb_transactiondb_options_t* opt, int64_t max_num_locks) {
  opt->rep.max_num_locks = max_num_locks;
}

void rocksdb_transactiondb_options_set_num_stripes(
    rocksdb_transactiondb_options_t* opt, size_t num_stripes) {
  opt->rep.num_stripes = num_stripes;
}

void rocksdb_transactiondb_options_set_transaction_lock_timeout(
    rocksdb_transactiondb_options_t* opt, int64_t txn_lock_timeout) {
  opt->rep.transaction_lock_timeout = txn_lock_timeout;
}

void rocksdb_transactiondb_options_set_default_lock_timeout(
    rocksdb_transactiondb_options_t* opt, int64_t default_lock_timeout) {
  opt->rep.default_lock_timeout = default_lock_timeout;
}

rocksdb_transaction_options_t* rocksdb_transaction_options_create() {
  return new rocksdb_transaction_options_t;
}

void rocksdb_transaction_options_destroy(rocksdb_transaction_options_t* opt) {
  delete opt;
}

void rocksdb_transaction_options_set_set_snapshot(
    rocksdb_transaction_options_t* opt, unsigned char v) {
  opt->rep.set_snapshot = v;
}

void rocksdb_transaction_options_set_deadlock_detect(
    rocksdb_transaction_options_t* opt, unsigned char v) {
  opt->rep.deadlock_detect = v;
}

void rocksdb_transaction_options_set_lock_timeout(
    rocksdb_transaction_options_t* opt, int64_t lock_timeout) {
  opt->rep.lock_timeout = lock_timeout;
}

void rocksdb_transaction_options_set_expiration(
    rocksdb_transaction_options_t* opt, int64_t expiration) {
  opt->rep.expiration = expiration;
}

void rocksdb_transaction_options_set_deadlock_detect_depth(
    rocksdb_transaction_options_t* opt, int64_t depth) {
  opt->rep.deadlock_detect_depth = depth;
}

void rocksdb_transaction_options_set_max_write_batch_size(
    rocksdb_transaction_options_t* opt, size_t size) {
  opt->rep.max_write_batch_size = size;
}

Y
Yiyuan Liu 已提交
5363 5364 5365 5366 5367
void rocksdb_transaction_options_set_skip_prepare(
    rocksdb_transaction_options_t* opt, unsigned char v) {
  opt->rep.skip_prepare = v;
}

5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382
rocksdb_optimistictransaction_options_t*
rocksdb_optimistictransaction_options_create() {
  return new rocksdb_optimistictransaction_options_t;
}

void rocksdb_optimistictransaction_options_destroy(
    rocksdb_optimistictransaction_options_t* opt) {
  delete opt;
}

void rocksdb_optimistictransaction_options_set_set_snapshot(
    rocksdb_optimistictransaction_options_t* opt, unsigned char v) {
  opt->rep.set_snapshot = v;
}

5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403
char* rocksdb_optimistictransactiondb_property_value(
    rocksdb_optimistictransactiondb_t* db, const char* propname) {
  std::string tmp;
  if (db->rep->GetProperty(Slice(propname), &tmp)) {
    // We use strdup() since we expect human readable output.
    return strdup(tmp.c_str());
  } else {
    return nullptr;
  }
}

int rocksdb_optimistictransactiondb_property_int(
    rocksdb_optimistictransactiondb_t* db, const char* propname,
    uint64_t* out_val) {
  if (db->rep->GetIntProperty(Slice(propname), out_val)) {
    return 0;
  } else {
    return -1;
  }
}

5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414
rocksdb_column_family_handle_t* rocksdb_transactiondb_create_column_family(
    rocksdb_transactiondb_t* txn_db,
    const rocksdb_options_t* column_family_options,
    const char* column_family_name, char** errptr) {
  rocksdb_column_family_handle_t* handle = new rocksdb_column_family_handle_t;
  SaveError(errptr, txn_db->rep->CreateColumnFamily(
                        ColumnFamilyOptions(column_family_options->rep),
                        std::string(column_family_name), &(handle->rep)));
  return handle;
}

5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428
rocksdb_transactiondb_t* rocksdb_transactiondb_open(
    const rocksdb_options_t* options,
    const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
    char** errptr) {
  TransactionDB* txn_db;
  if (SaveError(errptr, TransactionDB::Open(options->rep, txn_db_options->rep,
                                            std::string(name), &txn_db))) {
    return nullptr;
  }
  rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t;
  result->rep = txn_db;
  return result;
}

5429 5430 5431
rocksdb_transactiondb_t* rocksdb_transactiondb_open_column_families(
    const rocksdb_options_t* options,
    const rocksdb_transactiondb_options_t* txn_db_options, const char* name,
Q
Qinfan Wu 已提交
5432 5433
    int num_column_families, const char* const* column_family_names,
    const rocksdb_options_t* const* column_family_options,
5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460
    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i < num_column_families; i++) {
    column_families.push_back(ColumnFamilyDescriptor(
        std::string(column_family_names[i]),
        ColumnFamilyOptions(column_family_options[i]->rep)));
  }

  TransactionDB* txn_db;
  std::vector<ColumnFamilyHandle*> handles;
  if (SaveError(errptr, TransactionDB::Open(options->rep, txn_db_options->rep,
                                            std::string(name), column_families,
                                            &handles, &txn_db))) {
    return nullptr;
  }

  for (size_t i = 0; i < handles.size(); i++) {
    rocksdb_column_family_handle_t* c_handle =
        new rocksdb_column_family_handle_t;
    c_handle->rep = handles[i];
    column_family_handles[i] = c_handle;
  }
  rocksdb_transactiondb_t* result = new rocksdb_transactiondb_t;
  result->rep = txn_db;
  return result;
}

5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473
const rocksdb_snapshot_t* rocksdb_transactiondb_create_snapshot(
    rocksdb_transactiondb_t* txn_db) {
  rocksdb_snapshot_t* result = new rocksdb_snapshot_t;
  result->rep = txn_db->rep->GetSnapshot();
  return result;
}

void rocksdb_transactiondb_release_snapshot(
    rocksdb_transactiondb_t* txn_db, const rocksdb_snapshot_t* snapshot) {
  txn_db->rep->ReleaseSnapshot(snapshot->rep);
  delete snapshot;
}

5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494
char* rocksdb_transactiondb_property_value(rocksdb_transactiondb_t* db,
                                           const char* propname) {
  std::string tmp;
  if (db->rep->GetProperty(Slice(propname), &tmp)) {
    // We use strdup() since we expect human readable output.
    return strdup(tmp.c_str());
  } else {
    return nullptr;
  }
}

int rocksdb_transactiondb_property_int(rocksdb_transactiondb_t* db,
                                       const char* propname,
                                       uint64_t* out_val) {
  if (db->rep->GetIntProperty(Slice(propname), out_val)) {
    return 0;
  } else {
    return -1;
  }
}

5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506
rocksdb_transaction_t* 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) {
  if (old_txn == nullptr) {
    rocksdb_transaction_t* result = new rocksdb_transaction_t;
    result->rep = txn_db->rep->BeginTransaction(write_options->rep,
                                                txn_options->rep, nullptr);
    return result;
  }
  old_txn->rep = txn_db->rep->BeginTransaction(write_options->rep,
5507
                                               txn_options->rep, old_txn->rep);
5508 5509 5510
  return old_txn;
}

Y
Yiyuan Liu 已提交
5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566
rocksdb_transaction_t** rocksdb_transactiondb_get_prepared_transactions(
    rocksdb_transactiondb_t* txn_db, size_t* cnt) {
  std::vector<Transaction*> txns;
  txn_db->rep->GetAllPreparedTransactions(&txns);
  *cnt = txns.size();
  if (txns.empty()) {
    return nullptr;
  } else {
    rocksdb_transaction_t** buf = (rocksdb_transaction_t**)malloc(
        txns.size() * sizeof(rocksdb_transaction_t*));
    for (size_t i = 0; i < txns.size(); i++) {
      buf[i] = new rocksdb_transaction_t;
      buf[i]->rep = txns[i];
    }
    return buf;
  }
}

void rocksdb_transaction_set_name(rocksdb_transaction_t* txn, const char* name,
                                  size_t name_len, char** errptr) {
  std::string str = std::string(name, name_len);
  SaveError(errptr, txn->rep->SetName(str));
}

char* rocksdb_transaction_get_name(rocksdb_transaction_t* txn,
                                   size_t* name_len) {
  auto name = txn->rep->GetName();
  *name_len = name.size();
  return CopyString(name);
}

void rocksdb_transaction_prepare(rocksdb_transaction_t* txn, char** errptr) {
  SaveError(errptr, txn->rep->Prepare());
}

rocksdb_writebatch_wi_t* rocksdb_transaction_get_writebatch_wi(
    rocksdb_transaction_t* txn) {
  rocksdb_writebatch_wi_t* wi =
      (rocksdb_writebatch_wi_t*)malloc(sizeof(rocksdb_writebatch_wi_t));
  wi->rep = txn->rep->GetWriteBatch();

  return wi;
}

void rocksdb_transaction_rebuild_from_writebatch(
    rocksdb_transaction_t* txn, rocksdb_writebatch_t* writebatch,
    char** errptr) {
  SaveError(errptr, txn->rep->RebuildFromWriteBatch(&writebatch->rep));
}

void rocksdb_transaction_rebuild_from_writebatch_wi(rocksdb_transaction_t* txn,
                                                    rocksdb_writebatch_wi_t* wi,
                                                    char** errptr) {
  SaveError(errptr, txn->rep->RebuildFromWriteBatch(wi->rep->GetWriteBatch()));
}

5567 5568 5569 5570 5571 5572 5573 5574
void rocksdb_transaction_commit(rocksdb_transaction_t* txn, char** errptr) {
  SaveError(errptr, txn->rep->Commit());
}

void rocksdb_transaction_rollback(rocksdb_transaction_t* txn, char** errptr) {
  SaveError(errptr, txn->rep->Rollback());
}

5575 5576 5577 5578
void rocksdb_transaction_set_savepoint(rocksdb_transaction_t* txn) {
  txn->rep->SetSavePoint();
}

5579 5580
void rocksdb_transaction_rollback_to_savepoint(rocksdb_transaction_t* txn,
                                               char** errptr) {
5581 5582 5583
  SaveError(errptr, txn->rep->RollbackToSavePoint());
}

5584 5585 5586 5587 5588
void rocksdb_transaction_destroy(rocksdb_transaction_t* txn) {
  delete txn->rep;
  delete txn;
}

5589 5590
const rocksdb_snapshot_t* rocksdb_transaction_get_snapshot(
    rocksdb_transaction_t* txn) {
5591 5592 5593 5594
  // This will be freed later on using free, so use malloc here to avoid a
  // mismatch
  rocksdb_snapshot_t* result =
      (rocksdb_snapshot_t*)malloc(sizeof(rocksdb_snapshot_t));
5595 5596 5597 5598 5599
  result->rep = txn->rep->GetSnapshot();
  return result;
}

// Read a key inside a transaction
5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618
char* rocksdb_transaction_get(rocksdb_transaction_t* txn,
                              const rocksdb_readoptions_t* options,
                              const char* key, size_t klen, size_t* vlen,
                              char** errptr) {
  char* result = nullptr;
  std::string tmp;
  Status s = txn->rep->Get(options->rep, Slice(key, klen), &tmp);
  if (s.ok()) {
    *vlen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vlen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

Y
Yiyuan Liu 已提交
5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633
rocksdb_pinnableslice_t* rocksdb_transaction_get_pinned(
    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
    const char* key, size_t klen, char** errptr) {
  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
  Status s = txn->rep->Get(options->rep, Slice(key, klen), &v->rep);
  if (!s.ok()) {
    delete (v);
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
    return nullptr;
  }
  return v;
}

5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654
char* 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) {
  char* result = nullptr;
  std::string tmp;
  Status s =
      txn->rep->Get(options->rep, column_family->rep, Slice(key, klen), &tmp);
  if (s.ok()) {
    *vlen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vlen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

Y
Yiyuan Liu 已提交
5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671
rocksdb_pinnableslice_t* rocksdb_transaction_get_pinned_cf(
    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
    rocksdb_column_family_handle_t* column_family, const char* key, size_t klen,
    char** errptr) {
  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
  Status s = txn->rep->Get(options->rep, column_family->rep, Slice(key, klen),
                           &v->rep);
  if (!s.ok()) {
    delete (v);
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
    return nullptr;
  }
  return v;
}

5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693
// Read a key inside a transaction
char* 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) {
  char* result = nullptr;
  std::string tmp;
  Status s =
      txn->rep->GetForUpdate(options->rep, Slice(key, klen), &tmp, exclusive);
  if (s.ok()) {
    *vlen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vlen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

Y
Yiyuan Liu 已提交
5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710
rocksdb_pinnableslice_t* rocksdb_transaction_get_pinned_for_update(
    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
    const char* key, size_t klen, unsigned char exclusive, char** errptr) {
  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
  Status s = txn->rep->GetForUpdate(options->rep, Slice(key, klen),
                                    v->rep.GetSelf(), exclusive);
  v->rep.PinSelf();
  if (!s.ok()) {
    delete (v);
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
    return nullptr;
  }
  return v;
}

5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730
char* 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) {
  char* result = nullptr;
  std::string tmp;
  Status s = txn->rep->GetForUpdate(options->rep, column_family->rep,
                                    Slice(key, klen), &tmp, exclusive);
  if (s.ok()) {
    *vlen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vlen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

Y
Yiyuan Liu 已提交
5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810
rocksdb_pinnableslice_t* rocksdb_transaction_get_pinned_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,
    unsigned char exclusive, char** errptr) {
  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
  Status s = txn->rep->GetForUpdate(options->rep, column_family->rep,
                                    Slice(key, klen), &v->rep, exclusive);
  if (!s.ok()) {
    delete (v);
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
    return nullptr;
  }
  return v;
}

void rocksdb_transaction_multi_get(rocksdb_transaction_t* txn,
                                   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) {
  std::vector<Slice> keys(num_keys);
  for (size_t i = 0; i < num_keys; i++) {
    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<std::string> values(num_keys);
  std::vector<Status> statuses =
      txn->rep->MultiGet(options->rep, keys, &values);
  for (size_t i = 0; i < num_keys; i++) {
    if (statuses[i].ok()) {
      values_list[i] = CopyString(values[i]);
      values_list_sizes[i] = values[i].size();
      errs[i] = nullptr;
    } else {
      values_list[i] = nullptr;
      values_list_sizes[i] = 0;
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }
}

void rocksdb_transaction_multi_get_cf(
    rocksdb_transaction_t* txn, 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) {
  std::vector<Slice> keys(num_keys);
  std::vector<ColumnFamilyHandle*> cfs(num_keys);
  for (size_t i = 0; i < num_keys; i++) {
    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
    cfs[i] = column_families[i]->rep;
  }
  std::vector<std::string> values(num_keys);
  std::vector<Status> statuses =
      txn->rep->MultiGet(options->rep, cfs, keys, &values);
  for (size_t i = 0; i < num_keys; i++) {
    if (statuses[i].ok()) {
      values_list[i] = CopyString(values[i]);
      values_list_sizes[i] = values[i].size();
      errs[i] = nullptr;
    } else {
      values_list[i] = nullptr;
      values_list_sizes[i] = 0;
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }
}

5811
// Read a key outside a transaction
5812 5813 5814 5815
char* rocksdb_transactiondb_get(rocksdb_transactiondb_t* txn_db,
                                const rocksdb_readoptions_t* options,
                                const char* key, size_t klen, size_t* vlen,
                                char** errptr) {
5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830
  char* result = nullptr;
  std::string tmp;
  Status s = txn_db->rep->Get(options->rep, Slice(key, klen), &tmp);
  if (s.ok()) {
    *vlen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vlen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

Y
Yiyuan Liu 已提交
5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846
rocksdb_pinnableslice_t* rocksdb_transactiondb_get_pinned(
    rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
    const char* key, size_t klen, char** errptr) {
  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
  Status s = txn_db->rep->Get(options->rep, txn_db->rep->DefaultColumnFamily(),
                              Slice(key, klen), &v->rep);
  if (!s.ok()) {
    delete (v);
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
    return nullptr;
  }
  return v;
}

5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866
char* 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) {
  char* result = nullptr;
  std::string tmp;
  Status s = txn_db->rep->Get(options->rep, column_family->rep,
                              Slice(key, keylen), &tmp);
  if (s.ok()) {
    *vallen = tmp.size();
    result = CopyString(tmp);
  } else {
    *vallen = 0;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
  }
  return result;
}

Y
Yiyuan Liu 已提交
5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946
rocksdb_pinnableslice_t* rocksdb_transactiondb_get_pinned_cf(
    rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
    rocksdb_column_family_handle_t* column_family, const char* key,
    size_t keylen, char** errptr) {
  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
  Status s = txn_db->rep->Get(options->rep, column_family->rep,
                              Slice(key, keylen), &v->rep);
  if (!s.ok()) {
    delete (v);
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
    return nullptr;
  }
  return v;
}

void rocksdb_transactiondb_multi_get(rocksdb_transactiondb_t* txn_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) {
  std::vector<Slice> keys(num_keys);
  for (size_t i = 0; i < num_keys; i++) {
    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
  }
  std::vector<std::string> values(num_keys);
  std::vector<Status> statuses =
      txn_db->rep->MultiGet(options->rep, keys, &values);
  for (size_t i = 0; i < num_keys; i++) {
    if (statuses[i].ok()) {
      values_list[i] = CopyString(values[i]);
      values_list_sizes[i] = values[i].size();
      errs[i] = nullptr;
    } else {
      values_list[i] = nullptr;
      values_list_sizes[i] = 0;
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }
}

void rocksdb_transactiondb_multi_get_cf(
    rocksdb_transactiondb_t* txn_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) {
  std::vector<Slice> keys(num_keys);
  std::vector<ColumnFamilyHandle*> cfs(num_keys);
  for (size_t i = 0; i < num_keys; i++) {
    keys[i] = Slice(keys_list[i], keys_list_sizes[i]);
    cfs[i] = column_families[i]->rep;
  }
  std::vector<std::string> values(num_keys);
  std::vector<Status> statuses =
      txn_db->rep->MultiGet(options->rep, cfs, keys, &values);
  for (size_t i = 0; i < num_keys; i++) {
    if (statuses[i].ok()) {
      values_list[i] = CopyString(values[i]);
      values_list_sizes[i] = values[i].size();
      errs[i] = nullptr;
    } else {
      values_list[i] = nullptr;
      values_list_sizes[i] = 0;
      if (!statuses[i].IsNotFound()) {
        errs[i] = strdup(statuses[i].ToString().c_str());
      } else {
        errs[i] = nullptr;
      }
    }
  }
}

5947 5948 5949 5950 5951 5952 5953
// Put a key inside a transaction
void rocksdb_transaction_put(rocksdb_transaction_t* txn, const char* key,
                             size_t klen, const char* val, size_t vlen,
                             char** errptr) {
  SaveError(errptr, txn->rep->Put(Slice(key, klen), Slice(val, vlen)));
}

5954 5955 5956 5957 5958 5959 5960 5961
void 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) {
  SaveError(errptr, txn->rep->Put(column_family->rep, Slice(key, klen),
                                  Slice(val, vlen)));
}

5962 5963 5964 5965 5966 5967 5968 5969 5970 5971
void rocksdb_transaction_set_commit_timestamp(rocksdb_transaction_t* txn,
                                              uint64_t commit_timestamp) {
  txn->rep->SetCommitTimestamp(commit_timestamp);
}

void rocksdb_transaction_set_read_timestamp_for_validation(
    rocksdb_transaction_t* txn, uint64_t read_timestamp) {
  txn->rep->SetReadTimestampForValidation(read_timestamp);
}

5972
// Put a key outside a transaction
5973 5974 5975 5976
void 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) {
5977 5978
  SaveError(errptr,
            txn_db->rep->Put(options->rep, Slice(key, klen), Slice(val, vlen)));
5979 5980
}

5981 5982 5983 5984 5985 5986 5987 5988 5989 5990
void 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) {
  SaveError(errptr, txn_db->rep->Put(options->rep, column_family->rep,
                                     Slice(key, keylen), Slice(val, vallen)));
}

5991
// Write batch into transaction db
5992 5993 5994
void rocksdb_transactiondb_write(rocksdb_transactiondb_t* db,
                                 const rocksdb_writeoptions_t* options,
                                 rocksdb_writebatch_t* batch, char** errptr) {
5995 5996 5997
  SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
}

5998 5999 6000 6001 6002 6003 6004
// Merge a key inside a transaction
void rocksdb_transaction_merge(rocksdb_transaction_t* txn, const char* key,
                               size_t klen, const char* val, size_t vlen,
                               char** errptr) {
  SaveError(errptr, txn->rep->Merge(Slice(key, klen), Slice(val, vlen)));
}

6005 6006 6007 6008 6009 6010 6011 6012
void 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) {
  SaveError(errptr, txn->rep->Merge(column_family->rep, Slice(key, klen),
                                    Slice(val, vlen)));
}

6013 6014 6015 6016 6017
// Merge a key outside a transaction
void 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) {
6018 6019
  SaveError(errptr, txn_db->rep->Merge(options->rep, Slice(key, klen),
                                       Slice(val, vlen)));
6020 6021
}

6022 6023 6024 6025 6026 6027 6028 6029
void 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) {
  SaveError(errptr, txn_db->rep->Merge(options->rep, column_family->rep,
                                       Slice(key, klen), Slice(val, vlen)));
}

6030 6031 6032 6033 6034 6035
// Delete a key inside a transaction
void rocksdb_transaction_delete(rocksdb_transaction_t* txn, const char* key,
                                size_t klen, char** errptr) {
  SaveError(errptr, txn->rep->Delete(Slice(key, klen)));
}

6036 6037 6038 6039 6040 6041
void rocksdb_transaction_delete_cf(
    rocksdb_transaction_t* txn, rocksdb_column_family_handle_t* column_family,
    const char* key, size_t klen, char** errptr) {
  SaveError(errptr, txn->rep->Delete(column_family->rep, Slice(key, klen)));
}

6042 6043 6044 6045 6046 6047 6048
// Delete a key outside a transaction
void rocksdb_transactiondb_delete(rocksdb_transactiondb_t* txn_db,
                                  const rocksdb_writeoptions_t* options,
                                  const char* key, size_t klen, char** errptr) {
  SaveError(errptr, txn_db->rep->Delete(options->rep, Slice(key, klen)));
}

6049 6050 6051 6052 6053 6054 6055 6056
void 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) {
  SaveError(errptr, txn_db->rep->Delete(options->rep, column_family->rep,
                                        Slice(key, keylen)));
}

6057 6058 6059 6060 6061 6062 6063 6064
// Create an iterator inside a transaction
rocksdb_iterator_t* rocksdb_transaction_create_iterator(
    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options) {
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
  result->rep = txn->rep->GetIterator(options->rep);
  return result;
}

6065 6066 6067 6068 6069 6070 6071 6072 6073
// Create an iterator inside a transaction with column family
rocksdb_iterator_t* rocksdb_transaction_create_iterator_cf(
    rocksdb_transaction_t* txn, const rocksdb_readoptions_t* options,
    rocksdb_column_family_handle_t* column_family) {
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
  result->rep = txn->rep->GetIterator(options->rep, column_family->rep);
  return result;
}

6074 6075 6076 6077 6078 6079 6080 6081
// Create an iterator outside a transaction
rocksdb_iterator_t* rocksdb_transactiondb_create_iterator(
    rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options) {
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
  result->rep = txn_db->rep->NewIterator(options->rep);
  return result;
}

6082 6083 6084 6085 6086 6087 6088 6089
rocksdb_iterator_t* rocksdb_transactiondb_create_iterator_cf(
    rocksdb_transactiondb_t* txn_db, const rocksdb_readoptions_t* options,
    rocksdb_column_family_handle_t* column_family) {
  rocksdb_iterator_t* result = new rocksdb_iterator_t;
  result->rep = txn_db->rep->NewIterator(options->rep, column_family->rep);
  return result;
}

6090 6091 6092 6093 6094
void rocksdb_transactiondb_close(rocksdb_transactiondb_t* txn_db) {
  delete txn_db->rep;
  delete txn_db;
}

Y
Yiyuan Liu 已提交
6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111
void rocksdb_transactiondb_flush_wal(rocksdb_transactiondb_t* txn_db,
                                     unsigned char sync, char** errptr) {
  SaveError(errptr, txn_db->rep->FlushWAL(sync));
}

void rocksdb_transactiondb_flush(rocksdb_transactiondb_t* txn_db,
                                 const rocksdb_flushoptions_t* options,
                                 char** errptr) {
  SaveError(errptr, txn_db->rep->Flush(options->rep));
}

void rocksdb_transactiondb_flush_cf(
    rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
    rocksdb_column_family_handle_t* column_family, char** errptr) {
  SaveError(errptr, txn_db->rep->Flush(options->rep, column_family->rep));
}

6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122
rocksdb_checkpoint_t* rocksdb_transactiondb_checkpoint_object_create(
    rocksdb_transactiondb_t* txn_db, char** errptr) {
  Checkpoint* checkpoint;
  if (SaveError(errptr, Checkpoint::Create(txn_db->rep, &checkpoint))) {
    return nullptr;
  }
  rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t;
  result->rep = checkpoint;
  return result;
}

6123
rocksdb_optimistictransactiondb_t* rocksdb_optimistictransactiondb_open(
6124
    const rocksdb_options_t* options, const char* name, char** errptr) {
6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135
  OptimisticTransactionDB* otxn_db;
  if (SaveError(errptr, OptimisticTransactionDB::Open(
                            options->rep, std::string(name), &otxn_db))) {
    return nullptr;
  }
  rocksdb_optimistictransactiondb_t* result =
      new rocksdb_optimistictransactiondb_t;
  result->rep = otxn_db;
  return result;
}

6136 6137 6138
rocksdb_optimistictransactiondb_t*
rocksdb_optimistictransactiondb_open_column_families(
    const rocksdb_options_t* db_options, const char* name,
Q
Qinfan Wu 已提交
6139 6140
    int num_column_families, const char* const* column_family_names,
    const rocksdb_options_t* const* column_family_options,
6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185
    rocksdb_column_family_handle_t** column_family_handles, char** errptr) {
  std::vector<ColumnFamilyDescriptor> column_families;
  for (int i = 0; i < num_column_families; i++) {
    column_families.push_back(ColumnFamilyDescriptor(
        std::string(column_family_names[i]),
        ColumnFamilyOptions(column_family_options[i]->rep)));
  }

  OptimisticTransactionDB* otxn_db;
  std::vector<ColumnFamilyHandle*> handles;
  if (SaveError(errptr, OptimisticTransactionDB::Open(
                            DBOptions(db_options->rep), std::string(name),
                            column_families, &handles, &otxn_db))) {
    return nullptr;
  }

  for (size_t i = 0; i < handles.size(); i++) {
    rocksdb_column_family_handle_t* c_handle =
        new rocksdb_column_family_handle_t;
    c_handle->rep = handles[i];
    column_family_handles[i] = c_handle;
  }
  rocksdb_optimistictransactiondb_t* result =
      new rocksdb_optimistictransactiondb_t;
  result->rep = otxn_db;
  return result;
}

rocksdb_t* rocksdb_optimistictransactiondb_get_base_db(
    rocksdb_optimistictransactiondb_t* otxn_db) {
  DB* base_db = otxn_db->rep->GetBaseDB();

  if (base_db != nullptr) {
    rocksdb_t* result = new rocksdb_t;
    result->rep = base_db;
    return result;
  }

  return nullptr;
}

void rocksdb_optimistictransactiondb_close_base_db(rocksdb_t* base_db) {
  delete base_db;
}

6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201
rocksdb_transaction_t* 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) {
  if (old_txn == nullptr) {
    rocksdb_transaction_t* result = new rocksdb_transaction_t;
    result->rep = otxn_db->rep->BeginTransaction(write_options->rep,
                                                 otxn_options->rep, nullptr);
    return result;
  }
  old_txn->rep = otxn_db->rep->BeginTransaction(
      write_options->rep, otxn_options->rep, old_txn->rep);
  return old_txn;
}

6202 6203 6204 6205 6206 6207 6208 6209
// Write batch into OptimisticTransactionDB
void rocksdb_optimistictransactiondb_write(
    rocksdb_optimistictransactiondb_t* otxn_db,
    const rocksdb_writeoptions_t* options, rocksdb_writebatch_t* batch,
    char** errptr) {
  SaveError(errptr, otxn_db->rep->Write(options->rep, &batch->rep));
}

6210 6211 6212 6213 6214 6215
void rocksdb_optimistictransactiondb_close(
    rocksdb_optimistictransactiondb_t* otxn_db) {
  delete otxn_db->rep;
  delete otxn_db;
}

6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226
rocksdb_checkpoint_t* rocksdb_optimistictransactiondb_checkpoint_object_create(
    rocksdb_optimistictransactiondb_t* otxn_db, char** errptr) {
  Checkpoint* checkpoint;
  if (SaveError(errptr, Checkpoint::Create(otxn_db->rep, &checkpoint))) {
    return nullptr;
  }
  rocksdb_checkpoint_t* result = new rocksdb_checkpoint_t;
  result->rep = checkpoint;
  return result;
}

S
sdong 已提交
6227
void rocksdb_free(void* ptr) { free(ptr); }
D
Dmitri Smirnov 已提交
6228

S
siddontang 已提交
6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239
rocksdb_pinnableslice_t* rocksdb_get_pinned(
    rocksdb_t* db, const rocksdb_readoptions_t* options, const char* key,
    size_t keylen, char** errptr) {
  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
  Status s = db->rep->Get(options->rep, db->rep->DefaultColumnFamily(),
                          Slice(key, keylen), &v->rep);
  if (!s.ok()) {
    delete (v);
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
6240
    return nullptr;
S
siddontang 已提交
6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256
  }
  return v;
}

rocksdb_pinnableslice_t* 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) {
  rocksdb_pinnableslice_t* v = new (rocksdb_pinnableslice_t);
  Status s = db->rep->Get(options->rep, column_family->rep, Slice(key, keylen),
                          &v->rep);
  if (!s.ok()) {
    delete v;
    if (!s.IsNotFound()) {
      SaveError(errptr, s);
    }
6257
    return nullptr;
S
siddontang 已提交
6258 6259 6260 6261 6262 6263 6264 6265 6266 6267
  }
  return v;
}

void rocksdb_pinnableslice_destroy(rocksdb_pinnableslice_t* v) { delete v; }

const char* rocksdb_pinnableslice_value(const rocksdb_pinnableslice_t* v,
                                        size_t* vlen) {
  if (!v) {
    *vlen = 0;
6268
    return nullptr;
S
siddontang 已提交
6269 6270 6271 6272 6273
  }

  *vlen = v->rep.size();
  return v->rep.data();
}
6274

6275 6276
// container to keep databases and caches in order to use
// ROCKSDB_NAMESPACE::MemoryUtil
6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303
struct rocksdb_memory_consumers_t {
  std::vector<rocksdb_t*> dbs;
  std::unordered_set<rocksdb_cache_t*> caches;
};

// initializes new container of memory consumers
rocksdb_memory_consumers_t* rocksdb_memory_consumers_create() {
  return new rocksdb_memory_consumers_t;
}

// adds datatabase to the container of memory consumers
void rocksdb_memory_consumers_add_db(rocksdb_memory_consumers_t* consumers,
                                     rocksdb_t* db) {
  consumers->dbs.push_back(db);
}

// adds cache to the container of memory consumers
void rocksdb_memory_consumers_add_cache(rocksdb_memory_consumers_t* consumers,
                                        rocksdb_cache_t* cache) {
  consumers->caches.insert(cache);
}

// deletes container with memory consumers
void rocksdb_memory_consumers_destroy(rocksdb_memory_consumers_t* consumers) {
  delete consumers;
}

6304
// contains memory usage statistics provided by ROCKSDB_NAMESPACE::MemoryUtil
6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324
struct rocksdb_memory_usage_t {
  uint64_t mem_table_total;
  uint64_t mem_table_unflushed;
  uint64_t mem_table_readers_total;
  uint64_t cache_total;
};

// estimates amount of memory occupied by consumers (dbs and caches)
rocksdb_memory_usage_t* rocksdb_approximate_memory_usage_create(
    rocksdb_memory_consumers_t* consumers, char** errptr) {
  vector<DB*> dbs;
  for (auto db : consumers->dbs) {
    dbs.push_back(db->rep);
  }

  unordered_set<const Cache*> cache_set;
  for (auto cache : consumers->caches) {
    cache_set.insert(const_cast<const Cache*>(cache->rep.get()));
  }

6325
  std::map<ROCKSDB_NAMESPACE::MemoryUtil::UsageType, uint64_t> usage_by_type;
6326 6327 6328 6329 6330 6331 6332 6333 6334 6335

  auto status = MemoryUtil::GetApproximateMemoryUsageByType(dbs, cache_set,
                                                            &usage_by_type);
  if (SaveError(errptr, status)) {
    return nullptr;
  }

  auto result = new rocksdb_memory_usage_t;
  result->mem_table_total = usage_by_type[MemoryUtil::kMemTableTotal];
  result->mem_table_unflushed = usage_by_type[MemoryUtil::kMemTableUnFlushed];
6336 6337
  result->mem_table_readers_total =
      usage_by_type[MemoryUtil::kTableReadersTotal];
6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361
  result->cache_total = usage_by_type[MemoryUtil::kCacheTotal];
  return result;
}

uint64_t rocksdb_approximate_memory_usage_get_mem_table_total(
    rocksdb_memory_usage_t* memory_usage) {
  return memory_usage->mem_table_total;
}

uint64_t rocksdb_approximate_memory_usage_get_mem_table_unflushed(
    rocksdb_memory_usage_t* memory_usage) {
  return memory_usage->mem_table_unflushed;
}

uint64_t rocksdb_approximate_memory_usage_get_mem_table_readers_total(
    rocksdb_memory_usage_t* memory_usage) {
  return memory_usage->mem_table_readers_total;
}

uint64_t rocksdb_approximate_memory_usage_get_cache_total(
    rocksdb_memory_usage_t* memory_usage) {
  return memory_usage->cache_total;
}

6362 6363 6364 6365 6366 6367 6368 6369 6370 6371
void rocksdb_options_set_dump_malloc_stats(rocksdb_options_t* opt,
                                           unsigned char val) {
  opt->rep.dump_malloc_stats = val;
}

void rocksdb_options_set_memtable_whole_key_filtering(rocksdb_options_t* opt,
                                                      unsigned char val) {
  opt->rep.memtable_whole_key_filtering = val;
}

6372 6373 6374 6375 6376 6377 6378 6379 6380 6381
void rocksdb_options_set_avoid_unnecessary_blocking_io(rocksdb_options_t* opt,
                                                       unsigned char val) {
  opt->rep.avoid_unnecessary_blocking_io = val;
}

unsigned char rocksdb_options_get_avoid_unnecessary_blocking_io(
    rocksdb_options_t* opt) {
  return opt->rep.avoid_unnecessary_blocking_io;
}

6382 6383 6384 6385 6386
// deletes container with memory usage estimates
void rocksdb_approximate_memory_usage_destroy(rocksdb_memory_usage_t* usage) {
  delete usage;
}

6387 6388 6389 6390
void rocksdb_cancel_all_background_work(rocksdb_t* db, unsigned char wait) {
  CancelAllBackgroundWork(db->rep, wait);
}

6391 6392 6393 6394 6395 6396 6397 6398
void rocksdb_disable_manual_compaction(rocksdb_t* db) {
  db->rep->DisableManualCompaction();
}

void rocksdb_enable_manual_compaction(rocksdb_t* db) {
  db->rep->EnableManualCompaction();
}

6399
}  // end extern "C"
I
Igor Canadi 已提交
6400