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