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