c.cc
1 // Copyright (c) 2011 The LevelDB Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. See the AUTHORS file for names of contributors. 4 5 #include "leveldb/c.h" 6 7 #include <cstdint> 8 #include <cstdlib> 9 10 #include "leveldb/cache.h" 11 #include "leveldb/comparator.h" 12 #include "leveldb/db.h" 13 #include "leveldb/env.h" 14 #include "leveldb/filter_policy.h" 15 #include "leveldb/iterator.h" 16 #include "leveldb/options.h" 17 #include "leveldb/status.h" 18 #include "leveldb/write_batch.h" 19 20 using leveldb::Cache; 21 using leveldb::Comparator; 22 using leveldb::CompressionType; 23 using leveldb::DB; 24 using leveldb::Env; 25 using leveldb::FileLock; 26 using leveldb::FilterPolicy; 27 using leveldb::Iterator; 28 using leveldb::kMajorVersion; 29 using leveldb::kMinorVersion; 30 using leveldb::Logger; 31 using leveldb::NewBloomFilterPolicy; 32 using leveldb::NewLRUCache; 33 using leveldb::Options; 34 using leveldb::RandomAccessFile; 35 using leveldb::Range; 36 using leveldb::ReadOptions; 37 using leveldb::SequentialFile; 38 using leveldb::Slice; 39 using leveldb::Snapshot; 40 using leveldb::Status; 41 using leveldb::WritableFile; 42 using leveldb::WriteBatch; 43 using leveldb::WriteOptions; 44 45 extern "C" { 46 47 struct leveldb_t { 48 DB* rep; 49 }; 50 struct leveldb_iterator_t { 51 Iterator* rep; 52 }; 53 struct leveldb_writebatch_t { 54 WriteBatch rep; 55 }; 56 struct leveldb_snapshot_t { 57 const Snapshot* rep; 58 }; 59 struct leveldb_readoptions_t { 60 ReadOptions rep; 61 }; 62 struct leveldb_writeoptions_t { 63 WriteOptions rep; 64 }; 65 struct leveldb_options_t { 66 Options rep; 67 }; 68 struct leveldb_cache_t { 69 Cache* rep; 70 }; 71 struct leveldb_seqfile_t { 72 SequentialFile* rep; 73 }; 74 struct leveldb_randomfile_t { 75 RandomAccessFile* rep; 76 }; 77 struct leveldb_writablefile_t { 78 WritableFile* rep; 79 }; 80 struct leveldb_logger_t { 81 Logger* rep; 82 }; 83 struct leveldb_filelock_t { 84 FileLock* rep; 85 }; 86 87 struct leveldb_comparator_t : public Comparator { 88 ~leveldb_comparator_t() override { (*destructor_)(state_); } 89 90 int Compare(const Slice& a, const Slice& b) const override { 91 return (*compare_)(state_, a.data(), a.size(), b.data(), b.size()); 92 } 93 94 const char* Name() const override { return (*name_)(state_); } 95 96 // No-ops since the C binding does not support key shortening methods. 97 void FindShortestSeparator(std::string*, const Slice&) const override {} 98 void FindShortSuccessor(std::string* key) const override {} 99 100 void* state_; 101 void (*destructor_)(void*); 102 int (*compare_)(void*, const char* a, size_t alen, const char* b, 103 size_t blen); 104 const char* (*name_)(void*); 105 }; 106 107 struct leveldb_filterpolicy_t : public FilterPolicy { 108 ~leveldb_filterpolicy_t() override { (*destructor_)(state_); } 109 110 const char* Name() const override { return (*name_)(state_); } 111 112 void CreateFilter(const Slice* keys, int n, std::string* dst) const override { 113 std::vector<const char*> key_pointers(n); 114 std::vector<size_t> key_sizes(n); 115 for (int i = 0; i < n; i++) { 116 key_pointers[i] = keys[i].data(); 117 key_sizes[i] = keys[i].size(); 118 } 119 size_t len; 120 char* filter = (*create_)(state_, &key_pointers[0], &key_sizes[0], n, &len); 121 dst->append(filter, len); 122 free(filter); 123 } 124 125 bool KeyMayMatch(const Slice& key, const Slice& filter) const override { 126 return (*key_match_)(state_, key.data(), key.size(), filter.data(), 127 filter.size()); 128 } 129 130 void* state_; 131 void (*destructor_)(void*); 132 const char* (*name_)(void*); 133 char* (*create_)(void*, const char* const* key_array, 134 const size_t* key_length_array, int num_keys, 135 size_t* filter_length); 136 uint8_t (*key_match_)(void*, const char* key, size_t length, 137 const char* filter, size_t filter_length); 138 }; 139 140 struct leveldb_env_t { 141 Env* rep; 142 bool is_default; 143 }; 144 145 static bool SaveError(char** errptr, const Status& s) { 146 assert(errptr != nullptr); 147 if (s.ok()) { 148 return false; 149 } else if (*errptr == nullptr) { 150 *errptr = strdup(s.ToString().c_str()); 151 } else { 152 // TODO(sanjay): Merge with existing error? 153 free(*errptr); 154 *errptr = strdup(s.ToString().c_str()); 155 } 156 return true; 157 } 158 159 static char* CopyString(const std::string& str) { 160 char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size())); 161 memcpy(result, str.data(), sizeof(char) * str.size()); 162 return result; 163 } 164 165 leveldb_t* leveldb_open(const leveldb_options_t* options, const char* name, 166 char** errptr) { 167 DB* db; 168 if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) { 169 return nullptr; 170 } 171 leveldb_t* result = new leveldb_t; 172 result->rep = db; 173 return result; 174 } 175 176 void leveldb_close(leveldb_t* db) { 177 delete db->rep; 178 delete db; 179 } 180 181 void leveldb_put(leveldb_t* db, const leveldb_writeoptions_t* options, 182 const char* key, size_t keylen, const char* val, size_t vallen, 183 char** errptr) { 184 SaveError(errptr, 185 db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen))); 186 } 187 188 void leveldb_delete(leveldb_t* db, const leveldb_writeoptions_t* options, 189 const char* key, size_t keylen, char** errptr) { 190 SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen))); 191 } 192 193 void leveldb_write(leveldb_t* db, const leveldb_writeoptions_t* options, 194 leveldb_writebatch_t* batch, char** errptr) { 195 SaveError(errptr, db->rep->Write(options->rep, &batch->rep)); 196 } 197 198 char* leveldb_get(leveldb_t* db, const leveldb_readoptions_t* options, 199 const char* key, size_t keylen, size_t* vallen, 200 char** errptr) { 201 char* result = nullptr; 202 std::string tmp; 203 Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp); 204 if (s.ok()) { 205 *vallen = tmp.size(); 206 result = CopyString(tmp); 207 } else { 208 *vallen = 0; 209 if (!s.IsNotFound()) { 210 SaveError(errptr, s); 211 } 212 } 213 return result; 214 } 215 216 leveldb_iterator_t* leveldb_create_iterator( 217 leveldb_t* db, const leveldb_readoptions_t* options) { 218 leveldb_iterator_t* result = new leveldb_iterator_t; 219 result->rep = db->rep->NewIterator(options->rep); 220 return result; 221 } 222 223 const leveldb_snapshot_t* leveldb_create_snapshot(leveldb_t* db) { 224 leveldb_snapshot_t* result = new leveldb_snapshot_t; 225 result->rep = db->rep->GetSnapshot(); 226 return result; 227 } 228 229 void leveldb_release_snapshot(leveldb_t* db, 230 const leveldb_snapshot_t* snapshot) { 231 db->rep->ReleaseSnapshot(snapshot->rep); 232 delete snapshot; 233 } 234 235 char* leveldb_property_value(leveldb_t* db, const char* propname) { 236 std::string tmp; 237 if (db->rep->GetProperty(Slice(propname), &tmp)) { 238 // We use strdup() since we expect human readable output. 239 return strdup(tmp.c_str()); 240 } else { 241 return nullptr; 242 } 243 } 244 245 void leveldb_approximate_sizes(leveldb_t* db, int num_ranges, 246 const char* const* range_start_key, 247 const size_t* range_start_key_len, 248 const char* const* range_limit_key, 249 const size_t* range_limit_key_len, 250 uint64_t* sizes) { 251 Range* ranges = new Range[num_ranges]; 252 for (int i = 0; i < num_ranges; i++) { 253 ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]); 254 ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]); 255 } 256 db->rep->GetApproximateSizes(ranges, num_ranges, sizes); 257 delete[] ranges; 258 } 259 260 void leveldb_compact_range(leveldb_t* db, const char* start_key, 261 size_t start_key_len, const char* limit_key, 262 size_t limit_key_len) { 263 Slice a, b; 264 db->rep->CompactRange( 265 // Pass null Slice if corresponding "const char*" is null 266 (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr), 267 (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr)); 268 } 269 270 void leveldb_destroy_db(const leveldb_options_t* options, const char* name, 271 char** errptr) { 272 SaveError(errptr, DestroyDB(name, options->rep)); 273 } 274 275 void leveldb_repair_db(const leveldb_options_t* options, const char* name, 276 char** errptr) { 277 SaveError(errptr, RepairDB(name, options->rep)); 278 } 279 280 void leveldb_iter_destroy(leveldb_iterator_t* iter) { 281 delete iter->rep; 282 delete iter; 283 } 284 285 uint8_t leveldb_iter_valid(const leveldb_iterator_t* iter) { 286 return iter->rep->Valid(); 287 } 288 289 void leveldb_iter_seek_to_first(leveldb_iterator_t* iter) { 290 iter->rep->SeekToFirst(); 291 } 292 293 void leveldb_iter_seek_to_last(leveldb_iterator_t* iter) { 294 iter->rep->SeekToLast(); 295 } 296 297 void leveldb_iter_seek(leveldb_iterator_t* iter, const char* k, size_t klen) { 298 iter->rep->Seek(Slice(k, klen)); 299 } 300 301 void leveldb_iter_next(leveldb_iterator_t* iter) { iter->rep->Next(); } 302 303 void leveldb_iter_prev(leveldb_iterator_t* iter) { iter->rep->Prev(); } 304 305 const char* leveldb_iter_key(const leveldb_iterator_t* iter, size_t* klen) { 306 Slice s = iter->rep->key(); 307 *klen = s.size(); 308 return s.data(); 309 } 310 311 const char* leveldb_iter_value(const leveldb_iterator_t* iter, size_t* vlen) { 312 Slice s = iter->rep->value(); 313 *vlen = s.size(); 314 return s.data(); 315 } 316 317 void leveldb_iter_get_error(const leveldb_iterator_t* iter, char** errptr) { 318 SaveError(errptr, iter->rep->status()); 319 } 320 321 leveldb_writebatch_t* leveldb_writebatch_create() { 322 return new leveldb_writebatch_t; 323 } 324 325 void leveldb_writebatch_destroy(leveldb_writebatch_t* b) { delete b; } 326 327 void leveldb_writebatch_clear(leveldb_writebatch_t* b) { b->rep.Clear(); } 328 329 void leveldb_writebatch_put(leveldb_writebatch_t* b, const char* key, 330 size_t klen, const char* val, size_t vlen) { 331 b->rep.Put(Slice(key, klen), Slice(val, vlen)); 332 } 333 334 void leveldb_writebatch_delete(leveldb_writebatch_t* b, const char* key, 335 size_t klen) { 336 b->rep.Delete(Slice(key, klen)); 337 } 338 339 void leveldb_writebatch_iterate(const leveldb_writebatch_t* b, void* state, 340 void (*put)(void*, const char* k, size_t klen, 341 const char* v, size_t vlen), 342 void (*deleted)(void*, const char* k, 343 size_t klen)) { 344 class H : public WriteBatch::Handler { 345 public: 346 void* state_; 347 void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen); 348 void (*deleted_)(void*, const char* k, size_t klen); 349 void Put(const Slice& key, const Slice& value) override { 350 (*put_)(state_, key.data(), key.size(), value.data(), value.size()); 351 } 352 void Delete(const Slice& key) override { 353 (*deleted_)(state_, key.data(), key.size()); 354 } 355 }; 356 H handler; 357 handler.state_ = state; 358 handler.put_ = put; 359 handler.deleted_ = deleted; 360 b->rep.Iterate(&handler); 361 } 362 363 void leveldb_writebatch_append(leveldb_writebatch_t* destination, 364 const leveldb_writebatch_t* source) { 365 destination->rep.Append(source->rep); 366 } 367 368 leveldb_options_t* leveldb_options_create() { return new leveldb_options_t; } 369 370 void leveldb_options_destroy(leveldb_options_t* options) { delete options; } 371 372 void leveldb_options_set_comparator(leveldb_options_t* opt, 373 leveldb_comparator_t* cmp) { 374 opt->rep.comparator = cmp; 375 } 376 377 void leveldb_options_set_filter_policy(leveldb_options_t* opt, 378 leveldb_filterpolicy_t* policy) { 379 opt->rep.filter_policy = policy; 380 } 381 382 void leveldb_options_set_create_if_missing(leveldb_options_t* opt, uint8_t v) { 383 opt->rep.create_if_missing = v; 384 } 385 386 void leveldb_options_set_error_if_exists(leveldb_options_t* opt, uint8_t v) { 387 opt->rep.error_if_exists = v; 388 } 389 390 void leveldb_options_set_paranoid_checks(leveldb_options_t* opt, uint8_t v) { 391 opt->rep.paranoid_checks = v; 392 } 393 394 void leveldb_options_set_env(leveldb_options_t* opt, leveldb_env_t* env) { 395 opt->rep.env = (env ? env->rep : nullptr); 396 } 397 398 void leveldb_options_set_info_log(leveldb_options_t* opt, leveldb_logger_t* l) { 399 opt->rep.info_log = (l ? l->rep : nullptr); 400 } 401 402 void leveldb_options_set_write_buffer_size(leveldb_options_t* opt, size_t s) { 403 opt->rep.write_buffer_size = s; 404 } 405 406 void leveldb_options_set_max_open_files(leveldb_options_t* opt, int n) { 407 opt->rep.max_open_files = n; 408 } 409 410 void leveldb_options_set_cache(leveldb_options_t* opt, leveldb_cache_t* c) { 411 opt->rep.block_cache = c->rep; 412 } 413 414 void leveldb_options_set_block_size(leveldb_options_t* opt, size_t s) { 415 opt->rep.block_size = s; 416 } 417 418 void leveldb_options_set_block_restart_interval(leveldb_options_t* opt, int n) { 419 opt->rep.block_restart_interval = n; 420 } 421 422 void leveldb_options_set_max_file_size(leveldb_options_t* opt, size_t s) { 423 opt->rep.max_file_size = s; 424 } 425 426 void leveldb_options_set_compression(leveldb_options_t* opt, int t) { 427 opt->rep.compression = static_cast<CompressionType>(t); 428 } 429 430 leveldb_comparator_t* leveldb_comparator_create( 431 void* state, void (*destructor)(void*), 432 int (*compare)(void*, const char* a, size_t alen, const char* b, 433 size_t blen), 434 const char* (*name)(void*)) { 435 leveldb_comparator_t* result = new leveldb_comparator_t; 436 result->state_ = state; 437 result->destructor_ = destructor; 438 result->compare_ = compare; 439 result->name_ = name; 440 return result; 441 } 442 443 void leveldb_comparator_destroy(leveldb_comparator_t* cmp) { delete cmp; } 444 445 leveldb_filterpolicy_t* leveldb_filterpolicy_create( 446 void* state, void (*destructor)(void*), 447 char* (*create_filter)(void*, const char* const* key_array, 448 const size_t* key_length_array, int num_keys, 449 size_t* filter_length), 450 uint8_t (*key_may_match)(void*, const char* key, size_t length, 451 const char* filter, size_t filter_length), 452 const char* (*name)(void*)) { 453 leveldb_filterpolicy_t* result = new leveldb_filterpolicy_t; 454 result->state_ = state; 455 result->destructor_ = destructor; 456 result->create_ = create_filter; 457 result->key_match_ = key_may_match; 458 result->name_ = name; 459 return result; 460 } 461 462 void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t* filter) { 463 delete filter; 464 } 465 466 leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_key) { 467 // Make a leveldb_filterpolicy_t, but override all of its methods so 468 // they delegate to a NewBloomFilterPolicy() instead of user 469 // supplied C functions. 470 struct Wrapper : public leveldb_filterpolicy_t { 471 static void DoNothing(void*) {} 472 473 ~Wrapper() { delete rep_; } 474 const char* Name() const override { return rep_->Name(); } 475 void CreateFilter(const Slice* keys, int n, std::string* dst) const override { 476 return rep_->CreateFilter(keys, n, dst); 477 } 478 bool KeyMayMatch(const Slice& key, const Slice& filter) const override { 479 return rep_->KeyMayMatch(key, filter); 480 } 481 482 const FilterPolicy* rep_; 483 }; 484 Wrapper* wrapper = new Wrapper; 485 wrapper->rep_ = NewBloomFilterPolicy(bits_per_key); 486 wrapper->state_ = nullptr; 487 wrapper->destructor_ = &Wrapper::DoNothing; 488 return wrapper; 489 } 490 491 leveldb_readoptions_t* leveldb_readoptions_create() { 492 return new leveldb_readoptions_t; 493 } 494 495 void leveldb_readoptions_destroy(leveldb_readoptions_t* opt) { delete opt; } 496 497 void leveldb_readoptions_set_verify_checksums(leveldb_readoptions_t* opt, 498 uint8_t v) { 499 opt->rep.verify_checksums = v; 500 } 501 502 void leveldb_readoptions_set_fill_cache(leveldb_readoptions_t* opt, uint8_t v) { 503 opt->rep.fill_cache = v; 504 } 505 506 void leveldb_readoptions_set_snapshot(leveldb_readoptions_t* opt, 507 const leveldb_snapshot_t* snap) { 508 opt->rep.snapshot = (snap ? snap->rep : nullptr); 509 } 510 511 leveldb_writeoptions_t* leveldb_writeoptions_create() { 512 return new leveldb_writeoptions_t; 513 } 514 515 void leveldb_writeoptions_destroy(leveldb_writeoptions_t* opt) { delete opt; } 516 517 void leveldb_writeoptions_set_sync(leveldb_writeoptions_t* opt, uint8_t v) { 518 opt->rep.sync = v; 519 } 520 521 leveldb_cache_t* leveldb_cache_create_lru(size_t capacity) { 522 leveldb_cache_t* c = new leveldb_cache_t; 523 c->rep = NewLRUCache(capacity); 524 return c; 525 } 526 527 void leveldb_cache_destroy(leveldb_cache_t* cache) { 528 delete cache->rep; 529 delete cache; 530 } 531 532 leveldb_env_t* leveldb_create_default_env() { 533 leveldb_env_t* result = new leveldb_env_t; 534 result->rep = Env::Default(); 535 result->is_default = true; 536 return result; 537 } 538 539 void leveldb_env_destroy(leveldb_env_t* env) { 540 if (!env->is_default) delete env->rep; 541 delete env; 542 } 543 544 char* leveldb_env_get_test_directory(leveldb_env_t* env) { 545 std::string result; 546 if (!env->rep->GetTestDirectory(&result).ok()) { 547 return nullptr; 548 } 549 550 char* buffer = static_cast<char*>(malloc(result.size() + 1)); 551 memcpy(buffer, result.data(), result.size()); 552 buffer[result.size()] = '\0'; 553 return buffer; 554 } 555 556 void leveldb_free(void* ptr) { free(ptr); } 557 558 int leveldb_major_version() { return kMajorVersion; } 559 560 int leveldb_minor_version() { return kMinorVersion; } 561 562 } // end extern "C"