int db_open() { char *error = NULL; char *filename = option_get_str("db_file"); ldb_options = leveldb_options_create(); ldb_cache = leveldb_cache_create_lru(option_get_int("cache_size")); leveldb_options_set_create_if_missing(ldb_options, option_get_int("create_db_if_missing")); leveldb_options_set_error_if_exists(ldb_options, option_get_int("error_if_db_exists")); leveldb_options_set_paranoid_checks(ldb_options, option_get_int("paranoid_checks")); leveldb_options_set_write_buffer_size(ldb_options, option_get_int("write_buffer_size")); leveldb_options_set_block_size(ldb_options, option_get_int("block_size")); leveldb_options_set_cache(ldb_options, ldb_cache); leveldb_options_set_max_open_files(ldb_options, option_get_int("leveldb_max_open_files")); leveldb_options_set_block_restart_interval(ldb_options, 8); leveldb_options_set_compression(ldb_options, option_get_int("compression")); // leveldb_options_set_env(options, self->_env); leveldb_options_set_info_log(ldb_options, NULL); ldb = leveldb_open(ldb_options, filename, &error); if (error) { fprintf(stderr, "ERROR opening db:%s\n", error); return 0; } return 1; }
static struct Queue * readoptions (va_list argp) { struct Queue * q = malloc(sizeof (struct Queue)); memset(q, 0, sizeof(struct Queue)); q->options = leveldb_options_create(); q->cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName); leveldb_options_set_comparator(q->options, q->cmp); leveldb_options_set_create_if_missing(q->options, 1); q->rop = leveldb_readoptions_create(); q->wop = leveldb_writeoptions_create(); const char * p; for (p = va_arg(argp, char *); p != NULL; p = va_arg(argp,char *)) { if (0 == strcmp(p, "failIfMissing")) { leveldb_options_set_create_if_missing(q->options,0); } if (0 == strcmp(p,"paranoidChecks")) { leveldb_options_set_paranoid_checks(q->options,1); } if (0 == strcmp(p,"writeBufferSize")) { size_t bufferSize= va_arg(argp, size_t); leveldb_options_set_write_buffer_size(q->options,bufferSize); } if (0 == strcmp(p,"blockSize")) { size_t blockSize= va_arg(argp, size_t); leveldb_options_set_block_size(q->options,blockSize); } if (0 == strcmp(p,"blockRestartInterval")) { size_t blockRestartInterval= va_arg(argp, size_t); leveldb_options_set_block_restart_interval(q->options,blockRestartInterval); } if (0 == strcmp(p,"maxOpenFiles")) { int maxOpenFiles= va_arg(argp, int ); leveldb_options_set_max_open_files(q->options,maxOpenFiles); } if (0 == strcmp(p,"noCompress")) { leveldb_options_set_compression(q->options,0); } if (0 == strcmp(p,"syncWrte")) { leveldb_writeoptions_set_sync(q->wop , 1); } }
void ds_init() { char *err = NULL; server.ds_cache = leveldb_cache_create_lru(server.ds_lru_cache * 1048576); server.ds_options = leveldb_options_create(); server.policy = leveldb_filterpolicy_create_bloom(10); //leveldb_options_set_comparator(server.ds_options, cmp); leveldb_options_set_filter_policy(server.ds_options, server.policy); leveldb_options_set_create_if_missing(server.ds_options, server.ds_create_if_missing); leveldb_options_set_error_if_exists(server.ds_options, server.ds_error_if_exists); leveldb_options_set_cache(server.ds_options, server.ds_cache); leveldb_options_set_info_log(server.ds_options, NULL); leveldb_options_set_write_buffer_size(server.ds_options, server.ds_write_buffer_size * 1048576); leveldb_options_set_paranoid_checks(server.ds_options, server.ds_paranoid_checks); leveldb_options_set_max_open_files(server.ds_options, server.ds_max_open_files); leveldb_options_set_block_size(server.ds_options, server.ds_block_size * 1024); leveldb_options_set_block_restart_interval(server.ds_options, server.ds_block_restart_interval); leveldb_options_set_compression(server.ds_options, leveldb_snappy_compression); server.ds_db = leveldb_open(server.ds_options, server.ds_path, &err); if (err != NULL) { fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, err); leveldb_free(err); exit(1); } server.woptions = leveldb_writeoptions_create(); server.roptions = leveldb_readoptions_create(); leveldb_readoptions_set_verify_checksums(server.roptions, 0); leveldb_readoptions_set_fill_cache(server.roptions, 1); leveldb_writeoptions_set_sync(server.woptions, 0); }
int main(int argc, char** argv) { leveldb_t* db; leveldb_comparator_t* cmp; leveldb_cache_t* cache; leveldb_env_t* env; leveldb_options_t* options; leveldb_readoptions_t* roptions; leveldb_writeoptions_t* woptions; char* err = NULL; int run = -1; CheckCondition(leveldb_major_version() >= 1); CheckCondition(leveldb_minor_version() >= 1); snprintf(dbname, sizeof(dbname), "%s/leveldb_c_test-%di/meta/0", GetTempDir(), ((int) geteuid())); StartPhase("create_objects"); cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName); env = leveldb_create_default_env(); cache = leveldb_cache_create_lru(100000); options = leveldb_options_create(); leveldb_options_set_comparator(options, cmp); leveldb_options_set_error_if_exists(options, 1); leveldb_options_set_cache(options, cache); leveldb_options_set_env(options, env); leveldb_options_set_info_log(options, NULL); leveldb_options_set_write_buffer_size(options, 100000); leveldb_options_set_paranoid_checks(options, 1); leveldb_options_set_max_open_files(options, 10); leveldb_options_set_block_size(options, 1024); leveldb_options_set_block_restart_interval(options, 8); leveldb_options_set_compression(options, leveldb_no_compression); roptions = leveldb_readoptions_create(); leveldb_readoptions_set_verify_checksums(roptions, 1); leveldb_readoptions_set_fill_cache(roptions, 0); woptions = leveldb_writeoptions_create(); leveldb_writeoptions_set_sync(woptions, 1); StartPhase("destroy"); leveldb_destroy_db(options, dbname, &err); Free(&err); StartPhase("open"); db = leveldb_open(options, dbname, &err); CheckNoError(err); CheckGet(db, roptions, "foo", NULL); StartPhase("put"); leveldb_put(db, woptions, "foo", 3, "hello", 5, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); StartPhase("compactall"); leveldb_compact_range(db, NULL, 0, NULL, 0); CheckGet(db, roptions, "foo", "hello"); StartPhase("compactrange"); leveldb_compact_range(db, "a", 1, "z", 1); CheckGet(db, roptions, "foo", "hello"); StartPhase("writebatch"); { leveldb_writebatch_t* wb = leveldb_writebatch_create(); leveldb_writebatch_put(wb, "foo", 3, "a", 1); leveldb_writebatch_clear(wb); leveldb_writebatch_put(wb, "bar", 3, "b", 1); leveldb_writebatch_put(wb, "box", 3, "c", 1); leveldb_writebatch_delete(wb, "bar", 3); leveldb_write(db, woptions, wb, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "box", "c"); int pos = 0; leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel); CheckCondition(pos == 3); leveldb_writebatch_destroy(wb); } StartPhase("iter"); { leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions); CheckCondition(!leveldb_iter_valid(iter)); leveldb_iter_seek_to_first(iter); CheckCondition(leveldb_iter_valid(iter)); CheckIter(iter, "box", "c"); leveldb_iter_next(iter); CheckIter(iter, "foo", "hello"); leveldb_iter_prev(iter); CheckIter(iter, "box", "c"); leveldb_iter_prev(iter); CheckCondition(!leveldb_iter_valid(iter)); leveldb_iter_seek_to_last(iter); CheckIter(iter, "foo", "hello"); leveldb_iter_seek(iter, "b", 1); CheckIter(iter, "box", "c"); leveldb_iter_get_error(iter, &err); CheckNoError(err); leveldb_iter_destroy(iter); } StartPhase("approximate_sizes"); { int i; int n = 20000; char keybuf[100]; char valbuf[100]; uint64_t sizes[2]; const char* start[2] = { "a", "k00000000000000010000" }; size_t start_len[2] = { 1, 21 }; const char* limit[2] = { "k00000000000000010000", "z" }; size_t limit_len[2] = { 21, 1 }; leveldb_writeoptions_set_sync(woptions, 0); for (i = 0; i < n; i++) { snprintf(keybuf, sizeof(keybuf), "k%020d", i); snprintf(valbuf, sizeof(valbuf), "v%020d", i); leveldb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf), &err); CheckNoError(err); } leveldb_approximate_sizes(db, 2, start, start_len, limit, limit_len, sizes); CheckCondition(sizes[0] > 0); CheckCondition(sizes[1] > 0); } StartPhase("property"); { char* prop = leveldb_property_value(db, "nosuchprop"); /* CheckCondition(prop == NULL);*/ prop = leveldb_property_value(db, "leveldb.stats"); CheckCondition(prop != NULL); Free(&prop); } StartPhase("snapshot"); { const leveldb_snapshot_t* snap; snap = leveldb_create_snapshot(db); leveldb_delete(db, woptions, "foo", 3, &err); CheckNoError(err); leveldb_readoptions_set_snapshot(roptions, snap); CheckGet(db, roptions, "foo", "hello"); leveldb_readoptions_set_snapshot(roptions, NULL); CheckGet(db, roptions, "foo", NULL); leveldb_release_snapshot(db, snap); } StartPhase("repair"); { leveldb_close(db); leveldb_options_set_error_if_exists(options, 0); leveldb_repair_db(options, dbname, &err); CheckNoError(err); db = leveldb_open(options, dbname, &err); CheckNoError(err); CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "box", "c"); leveldb_options_set_error_if_exists(options, 1); } StartPhase("filter"); for (run = 0; run < 2; run++) { // First run uses custom filter, second run uses bloom filter CheckNoError(err); leveldb_filterpolicy_t* policy; if (run == 0) { policy = leveldb_filterpolicy_create( NULL, FilterDestroy, FilterCreate, FilterKeyMatch, FilterName); } else { policy = leveldb_filterpolicy_create_bloom(10); } // Create new database leveldb_close(db); leveldb_destroy_db(options, dbname, &err); leveldb_options_set_filter_policy(options, policy); db = leveldb_open(options, dbname, &err); CheckNoError(err); leveldb_put(db, woptions, "foo", 3, "foovalue", 8, &err); CheckNoError(err); leveldb_put(db, woptions, "bar", 3, "barvalue", 8, &err); CheckNoError(err); leveldb_compact_range(db, NULL, 0, NULL, 0); fake_filter_result = 1; CheckGet(db, roptions, "foo", "foovalue"); CheckGet(db, roptions, "bar", "barvalue"); if (phase == 0) { // Must not find value when custom filter returns false fake_filter_result = 0; CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "bar", NULL); fake_filter_result = 1; CheckGet(db, roptions, "foo", "foovalue"); CheckGet(db, roptions, "bar", "barvalue"); } leveldb_options_set_filter_policy(options, NULL); leveldb_filterpolicy_destroy(policy); } StartPhase("cleanup"); leveldb_close(db); leveldb_options_destroy(options); leveldb_readoptions_destroy(roptions); leveldb_writeoptions_destroy(woptions); leveldb_cache_destroy(cache); leveldb_comparator_destroy(cmp); leveldb_env_destroy(env); fprintf(stderr, "PASS\n"); return 0; }
int main(int argc, char** argv) { leveldb_t* db; leveldb_comparator_t* cmp; leveldb_cache_t* cache; leveldb_env_t* env; leveldb_options_t* options; leveldb_readoptions_t* roptions; leveldb_writeoptions_t* woptions; char* err = NULL; #if defined(LEVELDB_PLATFORM_WINDOWS) snprintf(dbname, sizeof(dbname), "tmp\\leveldb_c_test"); #else snprintf(dbname, sizeof(dbname), "/tmp/leveldb_c_test-%d", ((int) geteuid())); #endif StartPhase("create_objects"); cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName); env = leveldb_create_default_env(); cache = leveldb_cache_create_lru(100000); options = leveldb_options_create(); leveldb_options_set_comparator(options, cmp); leveldb_options_set_error_if_exists(options, 1); leveldb_options_set_cache(options, cache); leveldb_options_set_env(options, env); leveldb_options_set_info_log(options, NULL); leveldb_options_set_write_buffer_size(options, 100000); leveldb_options_set_paranoid_checks(options, 1); leveldb_options_set_max_open_files(options, 10); leveldb_options_set_block_size(options, 1024); leveldb_options_set_block_restart_interval(options, 8); leveldb_options_set_compression(options, leveldb_no_compression); roptions = leveldb_readoptions_create(); leveldb_readoptions_set_verify_checksums(roptions, 1); leveldb_readoptions_set_fill_cache(roptions, 0); woptions = leveldb_writeoptions_create(); leveldb_writeoptions_set_sync(woptions, 1); StartPhase("destroy"); leveldb_destroy_db(options, dbname, &err); leveldb_free(&err); StartPhase("open_error"); db = leveldb_open(options, dbname, &err); CheckCondition(err != NULL); leveldb_free(&err); StartPhase("open"); leveldb_options_set_create_if_missing(options, 1); db = leveldb_open(options, dbname, &err); CheckNoError(err); CheckGet(db, roptions, "foo", NULL); StartPhase("put"); leveldb_put(db, woptions, "foo", 3, "hello", 5, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); StartPhase("writebatch"); { int pos = 0; leveldb_writebatch_t* wb = leveldb_writebatch_create(); leveldb_writebatch_put(wb, "foo", 3, "a", 1); leveldb_writebatch_clear(wb); leveldb_writebatch_put(wb, "bar", 3, "b", 1); leveldb_writebatch_put(wb, "box", 3, "c", 1); leveldb_writebatch_delete(wb, "bar", 3); leveldb_write(db, woptions, wb, &err); CheckNoError(err); CheckGet(db, roptions, "foo", "hello"); CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "box", "c"); leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel); CheckCondition(pos == 3); leveldb_writebatch_destroy(wb); } StartPhase("iter"); { leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions); CheckCondition(!leveldb_iter_valid(iter)); leveldb_iter_seek_to_first(iter); CheckCondition(leveldb_iter_valid(iter)); CheckIter(iter, "box", "c"); leveldb_iter_next(iter); CheckIter(iter, "foo", "hello"); leveldb_iter_prev(iter); CheckIter(iter, "box", "c"); leveldb_iter_prev(iter); CheckCondition(!leveldb_iter_valid(iter)); leveldb_iter_seek_to_last(iter); CheckIter(iter, "foo", "hello"); leveldb_iter_seek(iter, "b", 1); CheckIter(iter, "box", "c"); leveldb_iter_get_error(iter, &err); CheckNoError(err); leveldb_iter_destroy(iter); } StartPhase("approximate_sizes"); { int i; int n = 20000; char keybuf[100]; char valbuf[100]; uint64_t sizes[2]; const char* start[2] = { "a", "k00000000000000010000" }; size_t start_len[2] = { 1, 21 }; const char* limit[2] = { "k00000000000000010000", "z" }; size_t limit_len[2] = { 21, 1 }; leveldb_writeoptions_set_sync(woptions, 0); for (i = 0; i < n; i++) { snprintf(keybuf, sizeof(keybuf), "k%020d", i); snprintf(valbuf, sizeof(valbuf), "v%020d", i); leveldb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf), &err); CheckNoError(err); } leveldb_approximate_sizes(db, 2, start, start_len, limit, limit_len, sizes); CheckCondition(sizes[0] > 0); CheckCondition(sizes[1] > 0); } StartPhase("property"); { char* prop = leveldb_property_value(db, "nosuchprop"); CheckCondition(prop == NULL); prop = leveldb_property_value(db, "leveldb.stats"); CheckCondition(prop != NULL); leveldb_free(&prop); } StartPhase("snapshot"); { const leveldb_snapshot_t* snap; snap = leveldb_create_snapshot(db); leveldb_delete(db, woptions, "foo", 3, &err); CheckNoError(err); leveldb_readoptions_set_snapshot(roptions, snap); CheckGet(db, roptions, "foo", "hello"); leveldb_readoptions_set_snapshot(roptions, NULL); CheckGet(db, roptions, "foo", NULL); leveldb_release_snapshot(db, snap); } StartPhase("repair"); { leveldb_close(db); leveldb_options_set_create_if_missing(options, 0); leveldb_options_set_error_if_exists(options, 0); leveldb_repair_db(options, dbname, &err); CheckNoError(err); db = leveldb_open(options, dbname, &err); CheckNoError(err); CheckGet(db, roptions, "foo", NULL); CheckGet(db, roptions, "bar", NULL); CheckGet(db, roptions, "box", "c"); } StartPhase("cleanup"); leveldb_close(db); leveldb_options_destroy(options); leveldb_readoptions_destroy(roptions); leveldb_writeoptions_destroy(woptions); leveldb_cache_destroy(cache); leveldb_comparator_destroy(cmp); leveldb_env_destroy(env); fprintf(stderr, "PASS\n"); return 0; }
//TODO: add "bool create_if_missing" to this API! int leveldb_client_start(leveldb **db, const char *name, size_t write_buffer_size, bool use_compression, bool sync_writes) { int namelen; char *db_name; char *err = NULL; leveldb_t* db_t; leveldb_comparator_t *cmp; leveldb_cache_t *cache; leveldb_env_t *env; leveldb_options_t *options; leveldb_readoptions_t *roptions; leveldb_writeoptions_t *woptions; *db = (leveldb *)malloc(sizeof(leveldb)); if (*db == NULL) { kp_error("malloc(leveldb) failed!\n"); return -1; } /* Check arguments: */ if (strlen(name) < 1) { kp_error("name has no length!\n"); return -1; } if (write_buffer_size == 0) { write_buffer_size = WRITE_BUFFER_DEFAULT; } if (write_buffer_size < WRITE_BUFFER_MIN) { kp_error("write_buffer_size=%zu too small; min=%u\n", write_buffer_size, WRITE_BUFFER_MIN); return -1; } kp_debug("got args: name=%s, write_buffer_size=%zu, use_compression=%s, " "sync_writes=%s\n", name, write_buffer_size, use_compression ? "true" : "false", sync_writes ? "true" : "false"); /* Format of db name: LEVELDB_DIR + / + name */ namelen = strlen(name); db_name = malloc(namelen + 1); if (!db_name) { kp_error("malloc(db_name) failed!\n"); return -1; } strncpy(db_name, name, namelen+1); //copy null-zero (*db)->name = db_name; kp_debug("constructed db->name=[%s]\n", (*db)->name); /* Set up the database's comparator, environment, cache, etc. According * to leveldb/include/leveldb/c.h, all functions that can raise an error * must be passed a "char **errptr" (set to NULL!) as the last argument; * I guess functions that don't take this pointer can't return errors. */ cmp = leveldb_comparator_create(NULL, cmp_destroy, cmp_compare, cmp_name); //first arg is "state" env = leveldb_create_default_env(); cache = leveldb_cache_create_lru(CACHE_CAPACITY); // cache = NULL; (*db)->cmp = cmp; (*db)->env = env; (*db)->cache = cache; /* Set up the database's various options. Many of these will affect the * database's performance! (see leveldb/include/leveldb/options.h). */ options = leveldb_options_create(); leveldb_options_set_create_if_missing(options, 1); leveldb_options_set_comparator(options, cmp); leveldb_options_set_error_if_exists(options, 1); //raise error if db already exists leveldb_options_set_cache(options, cache); // leveldb_options_set_cache(options, NULL); //disable cache?? leveldb_options_set_env(options, env); leveldb_options_set_info_log(options, NULL); //NULL: write info to file in db's dir leveldb_options_set_write_buffer_size(options, write_buffer_size); /* Amount of data to build up in memory (backed by an unsorted log * on disk) before converting to a sorted on-disk file. * Larger values increase performance, especially during bulk loads. * Up to two write buffers may be held in memory at the same time, * so you may wish to adjust this parameter to control memory usage. * Also, a larger write buffer will result in a longer recovery time * the next time the database is opened. * Default: 4MB (test file uses 100000 bytes) */ leveldb_options_set_paranoid_checks(options, 0); //default false; test file uses true leveldb_options_set_max_open_files(options, MAX_OPEN_FILES); leveldb_options_set_block_size(options, BLOCK_SIZE); leveldb_options_set_block_restart_interval(options, BLOCK_RESTART_INTERVAL); leveldb_options_set_compression(options, use_compression ? leveldb_snappy_compression : leveldb_no_compression); (*db)->options = options; roptions = leveldb_readoptions_create(); leveldb_readoptions_set_verify_checksums(roptions, 0); /* If true, all data read from underlying storage will be * verified against corresponding checksums. * Default false; test file uses true. */ leveldb_readoptions_set_fill_cache(roptions, true); /* Should the data read for this iteration be cached in memory? * Callers may wish to set this field to false for bulk scans. * Default true; test file uses false. */ (*db)->roptions = roptions; woptions = leveldb_writeoptions_create(); leveldb_writeoptions_set_sync(woptions, sync_writes ? 1 : 0); /* If true, the write will be flushed from the operating system * buffer cache (by calling WritableFile::Sync()) before the write * is considered complete. If this flag is true, writes will be * slower. * If this flag is false, and the machine crashes, some recent * writes may be lost. Note that if it is just the process that * crashes (i.e., the machine does not reboot), no writes will be * lost even if sync==false. * In other words, a DB write with sync==false has similar * crash semantics as the "write()" system call. A DB write * with sync==true has similar crash semantics to a "write()" * system call followed by "fsync()". */ (*db)->woptions = woptions; kp_debug("destroying previous copy of database, if it exists\n"); leveldb_destroy_db((*db)->options, (*db)->name, &err); free_err(&err); kp_debug("opening/creating database [%s]\n", (*db)->name); db_t = leveldb_open((*db)->options, (*db)->name, &err); if (err) { kp_error("opening db returned error: %s\n", err); return -1; } free_err(&err); (*db)->db = db_t; kp_debug("successfully started leveldb [%s]\n", (*db)->name); return 0; }