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"
563