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