NextGraph
/
rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

convert Options from string

Browse Source 
Summary: Allow accepting Options as a string of key/value pairs

Test Plan: unit test

Reviewers: yhchiang, sdong, igor

Reviewed By: igor

Subscribers: dhruba, leveldb

Differential Revision: https://reviews.facebook.net/D24597
main
Lei Jin 10 years ago
parent f18b4a4847
commit cd0d581ff5
5 changed files with 284 additions and 102 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 6
      HISTORY.md
  2. 5
      include/rocksdb/options.h
  3. 101
      util/options_helper.cc
  4. 234
      util/options_test.cc
  5. 40
      utilities/options/convenience.h

6
HISTORY.md
Unescape View File

@ -1,5 +1,11 @@
# Rocksdb Change Log # Rocksdb Change Log
## Unreleased
### Public API changes
* Introduce 4 new convenient functions for converting Options from string: GetColumnFamilyOptionsFromMap(), GetColumnFamilyOptionsFromString(), GetDBOptionsFromMap(), GetDBOptionsFromString()
## 3.6.0 (10/7/2014) ## 3.6.0 (10/7/2014)
### Disk format changes ### Disk format changes
* If you're using RocksDB on ARM platforms and you're using default bloom filter, there is a disk format change you need to be aware of. There are three steps you need to do when you convert to new release: 1. turn off filter policy, 2. compact the whole database, 3. turn on filter policy * If you're using RocksDB on ARM platforms and you're using default bloom filter, there is a disk format change you need to be aware of. There are three steps you need to do when you convert to new release: 1. turn off filter policy, 2. compact the whole database, 3. turn on filter policy

5
include/rocksdb/options.h
Unescape View File

@ -1012,11 +1012,6 @@ extern Options GetOptions(size_t total_write_buffer_limit,
int write_amplification_threshold = 32, int write_amplification_threshold = 32,
uint64_t target_db_size = 68719476736 /* 64GB */); uint64_t target_db_size = 68719476736 /* 64GB */);
bool GetOptionsFromStrings(
const Options& base_options,
const std::unordered_map<std::string, std::string>& options_map,
Options* new_options);
} // namespace rocksdb } // namespace rocksdb
#endif // STORAGE_ROCKSDB_INCLUDE_OPTIONS_H_ #endif // STORAGE_ROCKSDB_INCLUDE_OPTIONS_H_

101
util/options_helper.cc
Unescape View File

@ -4,6 +4,7 @@
// of patent rights can be found in the PATENTS file in the same directory. // of patent rights can be found in the PATENTS file in the same directory.
#include <cassert> #include <cassert>
#include <cctype>
#include <unordered_set> #include <unordered_set>
#include "rocksdb/options.h" #include "rocksdb/options.h"
#include "util/options_helper.h" #include "util/options_helper.h"
@ -161,13 +162,61 @@ bool GetMutableOptionsFromStrings(
return true; return true;
} }
bool GetOptionsFromStrings( namespace {
const Options& base_options,
const std::unordered_map<std::string, std::string>& options_map, std::string trim(const std::string& str) {
Options* new_options) { size_t start = 0;
size_t end = str.size() - 1;
while (isspace(str[start]) != 0 && start <= end) {
++start;
}
while (isspace(str[end]) != 0 && start <= end) {
--end;
}
if (start <= end) {
return str.substr(start, end - start + 1);
}
return std::string();
}
bool StringToMap(const std::string& opts_str,
std::unordered_map<std::string, std::string>* opts_map) {
assert(opts_map);
// Example:
// opts_str = "write_buffer_size=1024;max_write_buffer_number=2"
size_t pos = 0;
std::string opts = trim(opts_str);
while (pos < opts.size()) {
size_t eq_pos = opts.find('=', pos);
if (eq_pos == std::string::npos) {
return false;
}
std::string key = trim(opts.substr(pos, eq_pos - pos));
size_t sc_pos = opts.find(';', eq_pos + 1);
if (sc_pos == std::string::npos) {
(*opts_map)[key] = trim(opts.substr(eq_pos + 1));
// It either ends with a trailing semi-colon or the last key-value pair
break;
} else {
(*opts_map)[key] = trim(opts.substr(eq_pos + 1, sc_pos - eq_pos - 1));
}
pos = sc_pos + 1;
}
return true;
}
} // anonymous namespace
bool GetColumnFamilyOptionsFromMap(
const ColumnFamilyOptions& base_options,
const std::unordered_map<std::string, std::string>& opts_map,
ColumnFamilyOptions* new_options) {
assert(new_options); assert(new_options);
*new_options = base_options; *new_options = base_options;
for (const auto& o : options_map) { for (const auto& o : opts_map) {
try { try {
if (ParseMemtableOptions(o.first, o.second, new_options)) { if (ParseMemtableOptions(o.first, o.second, new_options)) {
} else if (ParseCompactionOptions(o.first, o.second, new_options)) { } else if (ParseCompactionOptions(o.first, o.second, new_options)) {
@ -247,7 +296,36 @@ bool GetOptionsFromStrings(
new_options->bloom_locality = ParseUint32(o.second); new_options->bloom_locality = ParseUint32(o.second);
} else if (o.first == "min_partial_merge_operands") { } else if (o.first == "min_partial_merge_operands") {
new_options->min_partial_merge_operands = ParseUint32(o.second); new_options->min_partial_merge_operands = ParseUint32(o.second);
} else if (o.first == "create_if_missing") { } else {
return false;
}
} catch (std::exception) {
return false;
}
}
return true;
}
bool GetColumnFamilyOptionsFromString(
const ColumnFamilyOptions& base_options,
const std::string& opts_str,
ColumnFamilyOptions* new_options) {
std::unordered_map<std::string, std::string> opts_map;
if (!StringToMap(opts_str, &opts_map)) {
return false;
}
return GetColumnFamilyOptionsFromMap(base_options, opts_map, new_options);
}
bool GetDBOptionsFromMap(
const DBOptions& base_options,
const std::unordered_map<std::string, std::string>& opts_map,
DBOptions* new_options) {
assert(new_options);
*new_options = base_options;
for (const auto& o : opts_map) {
try {
if (o.first == "create_if_missing") {
new_options->create_if_missing = ParseBoolean(o.first, o.second); new_options->create_if_missing = ParseBoolean(o.first, o.second);
} else if (o.first == "create_missing_column_families") { } else if (o.first == "create_missing_column_families") {
new_options->create_missing_column_families = new_options->create_missing_column_families =
@ -325,4 +403,15 @@ bool GetOptionsFromStrings(
return true; return true;
} }
bool GetDBOptionsFromString(
const DBOptions& base_options,
const std::string& opts_str,
DBOptions* new_options) {
std::unordered_map<std::string, std::string> opts_map;
if (!StringToMap(opts_str, &opts_map)) {
return false;
}
return GetDBOptionsFromMap(base_options, opts_map, new_options);
}
} // namespace rocksdb } // namespace rocksdb

234
util/options_test.cc
Unescape View File

@ -17,6 +17,7 @@
#include "rocksdb/options.h" #include "rocksdb/options.h"
#include "util/testharness.h" #include "util/testharness.h"
#include "utilities/options/convenience.h"
using GFLAGS::ParseCommandLineFlags; using GFLAGS::ParseCommandLineFlags;
DEFINE_bool(enable_print, false, "Print options generated to console."); DEFINE_bool(enable_print, false, "Print options generated to console.");
@ -77,8 +78,8 @@ TEST(OptionsTest, LooseCondition) {
PrintAndGetOptions(128 * 1024 * 1024, 4, 8); PrintAndGetOptions(128 * 1024 * 1024, 4, 8);
} }
TEST(OptionsTest, GetOptionsFromStringsTest) { TEST(OptionsTest, GetOptionsFromMapTest) {
std::unordered_map<std::string, std::string> options_map = { std::unordered_map<std::string, std::string> cf_options_map = {
{"write_buffer_size", "1"}, {"write_buffer_size", "1"},
{"max_write_buffer_number", "2"}, {"max_write_buffer_number", "2"},
{"min_write_buffer_number_to_merge", "3"}, {"min_write_buffer_number_to_merge", "3"},
@ -120,7 +121,10 @@ TEST(OptionsTest, GetOptionsFromStringsTest) {
{"memtable_prefix_bloom_huge_page_tlb_size", "28"}, {"memtable_prefix_bloom_huge_page_tlb_size", "28"},
{"bloom_locality", "29"}, {"bloom_locality", "29"},
{"max_successive_merges", "30"}, {"max_successive_merges", "30"},
{"min_partial_merge_operands", "31"}, {"min_partial_merge_operands", "31"}
};
std::unordered_map<std::string, std::string> db_options_map = {
{"create_if_missing", "false"}, {"create_if_missing", "false"},
{"create_missing_column_families", "true"}, {"create_missing_column_families", "true"},
{"error_if_exists", "false"}, {"error_if_exists", "false"},
@ -154,98 +158,146 @@ TEST(OptionsTest, GetOptionsFromStringsTest) {
{"bytes_per_sync", "47"}, {"bytes_per_sync", "47"},
}; };
Options base_opt; ColumnFamilyOptions base_cf_opt;
Options new_opt; ColumnFamilyOptions new_cf_opt;
ASSERT_TRUE(GetOptionsFromStrings(base_opt, options_map, &new_opt)); ASSERT_TRUE(GetColumnFamilyOptionsFromMap(
ASSERT_EQ(new_opt.write_buffer_size, 1U); base_cf_opt, cf_options_map, &new_cf_opt));
ASSERT_EQ(new_opt.max_write_buffer_number, 2); ASSERT_EQ(new_cf_opt.write_buffer_size, 1U);
ASSERT_EQ(new_opt.min_write_buffer_number_to_merge, 3); ASSERT_EQ(new_cf_opt.max_write_buffer_number, 2);
ASSERT_EQ(new_opt.compression, kSnappyCompression); ASSERT_EQ(new_cf_opt.min_write_buffer_number_to_merge, 3);
ASSERT_EQ(new_opt.compression_per_level.size(), 6U); ASSERT_EQ(new_cf_opt.compression, kSnappyCompression);
ASSERT_EQ(new_opt.compression_per_level[0], kNoCompression); ASSERT_EQ(new_cf_opt.compression_per_level.size(), 6U);
ASSERT_EQ(new_opt.compression_per_level[1], kSnappyCompression); ASSERT_EQ(new_cf_opt.compression_per_level[0], kNoCompression);
ASSERT_EQ(new_opt.compression_per_level[2], kZlibCompression); ASSERT_EQ(new_cf_opt.compression_per_level[1], kSnappyCompression);
ASSERT_EQ(new_opt.compression_per_level[3], kBZip2Compression); ASSERT_EQ(new_cf_opt.compression_per_level[2], kZlibCompression);
ASSERT_EQ(new_opt.compression_per_level[4], kLZ4Compression); ASSERT_EQ(new_cf_opt.compression_per_level[3], kBZip2Compression);
ASSERT_EQ(new_opt.compression_per_level[5], kLZ4HCCompression); ASSERT_EQ(new_cf_opt.compression_per_level[4], kLZ4Compression);
ASSERT_EQ(new_opt.compression_opts.window_bits, 4); ASSERT_EQ(new_cf_opt.compression_per_level[5], kLZ4HCCompression);
ASSERT_EQ(new_opt.compression_opts.level, 5); ASSERT_EQ(new_cf_opt.compression_opts.window_bits, 4);
ASSERT_EQ(new_opt.compression_opts.strategy, 6); ASSERT_EQ(new_cf_opt.compression_opts.level, 5);
ASSERT_EQ(new_opt.num_levels, 7); ASSERT_EQ(new_cf_opt.compression_opts.strategy, 6);
ASSERT_EQ(new_opt.level0_file_num_compaction_trigger, 8); ASSERT_EQ(new_cf_opt.num_levels, 7);
ASSERT_EQ(new_opt.level0_slowdown_writes_trigger, 9); ASSERT_EQ(new_cf_opt.level0_file_num_compaction_trigger, 8);
ASSERT_EQ(new_opt.level0_stop_writes_trigger, 10); ASSERT_EQ(new_cf_opt.level0_slowdown_writes_trigger, 9);
ASSERT_EQ(new_opt.max_mem_compaction_level, 11); ASSERT_EQ(new_cf_opt.level0_stop_writes_trigger, 10);
ASSERT_EQ(new_opt.target_file_size_base, static_cast<uint64_t>(12)); ASSERT_EQ(new_cf_opt.max_mem_compaction_level, 11);
ASSERT_EQ(new_opt.target_file_size_multiplier, 13); ASSERT_EQ(new_cf_opt.target_file_size_base, static_cast<uint64_t>(12));
ASSERT_EQ(new_opt.max_bytes_for_level_base, 14U); ASSERT_EQ(new_cf_opt.target_file_size_multiplier, 13);
ASSERT_EQ(new_opt.max_bytes_for_level_multiplier, 15); ASSERT_EQ(new_cf_opt.max_bytes_for_level_base, 14U);
ASSERT_EQ(new_opt.max_bytes_for_level_multiplier_additional.size(), 3U); ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier, 15);
ASSERT_EQ(new_opt.max_bytes_for_level_multiplier_additional[0], 16); ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier_additional.size(), 3U);
ASSERT_EQ(new_opt.max_bytes_for_level_multiplier_additional[1], 17); ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier_additional[0], 16);
ASSERT_EQ(new_opt.max_bytes_for_level_multiplier_additional[2], 18); ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier_additional[1], 17);
ASSERT_EQ(new_opt.expanded_compaction_factor, 19); ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier_additional[2], 18);
ASSERT_EQ(new_opt.source_compaction_factor, 20); ASSERT_EQ(new_cf_opt.expanded_compaction_factor, 19);
ASSERT_EQ(new_opt.max_grandparent_overlap_factor, 21); ASSERT_EQ(new_cf_opt.source_compaction_factor, 20);
ASSERT_EQ(new_opt.soft_rate_limit, 1.1); ASSERT_EQ(new_cf_opt.max_grandparent_overlap_factor, 21);
ASSERT_EQ(new_opt.hard_rate_limit, 2.1); ASSERT_EQ(new_cf_opt.soft_rate_limit, 1.1);
ASSERT_EQ(new_opt.arena_block_size, 22U); ASSERT_EQ(new_cf_opt.hard_rate_limit, 2.1);
ASSERT_EQ(new_opt.disable_auto_compactions, true); ASSERT_EQ(new_cf_opt.arena_block_size, 22U);
ASSERT_EQ(new_opt.purge_redundant_kvs_while_flush, true); ASSERT_EQ(new_cf_opt.disable_auto_compactions, true);
ASSERT_EQ(new_opt.compaction_style, kCompactionStyleLevel); ASSERT_EQ(new_cf_opt.purge_redundant_kvs_while_flush, true);
ASSERT_EQ(new_opt.verify_checksums_in_compaction, false); ASSERT_EQ(new_cf_opt.compaction_style, kCompactionStyleLevel);
ASSERT_EQ(new_opt.compaction_options_fifo.max_table_files_size, ASSERT_EQ(new_cf_opt.verify_checksums_in_compaction, false);
ASSERT_EQ(new_cf_opt.compaction_options_fifo.max_table_files_size,
static_cast<uint64_t>(23)); static_cast<uint64_t>(23));
ASSERT_EQ(new_opt.filter_deletes, false); ASSERT_EQ(new_cf_opt.filter_deletes, false);
ASSERT_EQ(new_opt.max_sequential_skip_in_iterations, ASSERT_EQ(new_cf_opt.max_sequential_skip_in_iterations,
static_cast<uint64_t>(24)); static_cast<uint64_t>(24));
ASSERT_EQ(new_opt.inplace_update_support, true); ASSERT_EQ(new_cf_opt.inplace_update_support, true);
ASSERT_EQ(new_opt.inplace_update_num_locks, 25U); ASSERT_EQ(new_cf_opt.inplace_update_num_locks, 25U);
ASSERT_EQ(new_opt.memtable_prefix_bloom_bits, 26U); ASSERT_EQ(new_cf_opt.memtable_prefix_bloom_bits, 26U);
ASSERT_EQ(new_opt.memtable_prefix_bloom_probes, 27U); ASSERT_EQ(new_cf_opt.memtable_prefix_bloom_probes, 27U);
ASSERT_EQ(new_opt.memtable_prefix_bloom_huge_page_tlb_size, 28U); ASSERT_EQ(new_cf_opt.memtable_prefix_bloom_huge_page_tlb_size, 28U);
ASSERT_EQ(new_opt.bloom_locality, 29U); ASSERT_EQ(new_cf_opt.bloom_locality, 29U);
ASSERT_EQ(new_opt.max_successive_merges, 30U); ASSERT_EQ(new_cf_opt.max_successive_merges, 30U);
ASSERT_EQ(new_opt.min_partial_merge_operands, 31U); ASSERT_EQ(new_cf_opt.min_partial_merge_operands, 31U);
ASSERT_EQ(new_opt.create_if_missing, false);
ASSERT_EQ(new_opt.create_missing_column_families, true); cf_options_map["write_buffer_size"] = "hello";
ASSERT_EQ(new_opt.error_if_exists, false); ASSERT_TRUE(!GetColumnFamilyOptionsFromMap(
ASSERT_EQ(new_opt.paranoid_checks, true); base_cf_opt, cf_options_map, &new_cf_opt));
ASSERT_EQ(new_opt.max_open_files, 32); cf_options_map["write_buffer_size"] = "1";
ASSERT_EQ(new_opt.max_total_wal_size, static_cast<uint64_t>(33)); ASSERT_TRUE(GetColumnFamilyOptionsFromMap(
ASSERT_EQ(new_opt.disableDataSync, false); base_cf_opt, cf_options_map, &new_cf_opt));
ASSERT_EQ(new_opt.use_fsync, true); cf_options_map["unknown_option"] = "1";
ASSERT_EQ(new_opt.db_log_dir, "/db_log_dir"); ASSERT_TRUE(!GetColumnFamilyOptionsFromMap(
ASSERT_EQ(new_opt.wal_dir, "/wal_dir"); base_cf_opt, cf_options_map, &new_cf_opt));
ASSERT_EQ(new_opt.delete_obsolete_files_period_micros,
DBOptions base_db_opt;
DBOptions new_db_opt;
ASSERT_TRUE(GetDBOptionsFromMap(base_db_opt, db_options_map, &new_db_opt));
ASSERT_EQ(new_db_opt.create_if_missing, false);
ASSERT_EQ(new_db_opt.create_missing_column_families, true);
ASSERT_EQ(new_db_opt.error_if_exists, false);
ASSERT_EQ(new_db_opt.paranoid_checks, true);
ASSERT_EQ(new_db_opt.max_open_files, 32);
ASSERT_EQ(new_db_opt.max_total_wal_size, static_cast<uint64_t>(33));
ASSERT_EQ(new_db_opt.disableDataSync, false);
ASSERT_EQ(new_db_opt.use_fsync, true);
ASSERT_EQ(new_db_opt.db_log_dir, "/db_log_dir");
ASSERT_EQ(new_db_opt.wal_dir, "/wal_dir");
ASSERT_EQ(new_db_opt.delete_obsolete_files_period_micros,
static_cast<uint64_t>(34)); static_cast<uint64_t>(34));
ASSERT_EQ(new_opt.max_background_compactions, 35); ASSERT_EQ(new_db_opt.max_background_compactions, 35);
ASSERT_EQ(new_opt.max_background_flushes, 36); ASSERT_EQ(new_db_opt.max_background_flushes, 36);
ASSERT_EQ(new_opt.max_log_file_size, 37U); ASSERT_EQ(new_db_opt.max_log_file_size, 37U);
ASSERT_EQ(new_opt.log_file_time_to_roll, 38U); ASSERT_EQ(new_db_opt.log_file_time_to_roll, 38U);
ASSERT_EQ(new_opt.keep_log_file_num, 39U); ASSERT_EQ(new_db_opt.keep_log_file_num, 39U);
ASSERT_EQ(new_opt.max_manifest_file_size, static_cast<uint64_t>(40)); ASSERT_EQ(new_db_opt.max_manifest_file_size, static_cast<uint64_t>(40));
ASSERT_EQ(new_opt.table_cache_numshardbits, 41); ASSERT_EQ(new_db_opt.table_cache_numshardbits, 41);
ASSERT_EQ(new_opt.table_cache_remove_scan_count_limit, 42); ASSERT_EQ(new_db_opt.table_cache_remove_scan_count_limit, 42);
ASSERT_EQ(new_opt.WAL_ttl_seconds, static_cast<uint64_t>(43)); ASSERT_EQ(new_db_opt.WAL_ttl_seconds, static_cast<uint64_t>(43));
ASSERT_EQ(new_opt.WAL_size_limit_MB, static_cast<uint64_t>(44)); ASSERT_EQ(new_db_opt.WAL_size_limit_MB, static_cast<uint64_t>(44));
ASSERT_EQ(new_opt.manifest_preallocation_size, 45U); ASSERT_EQ(new_db_opt.manifest_preallocation_size, 45U);
ASSERT_EQ(new_opt.allow_os_buffer, false); ASSERT_EQ(new_db_opt.allow_os_buffer, false);
ASSERT_EQ(new_opt.allow_mmap_reads, true); ASSERT_EQ(new_db_opt.allow_mmap_reads, true);
ASSERT_EQ(new_opt.allow_mmap_writes, false); ASSERT_EQ(new_db_opt.allow_mmap_writes, false);
ASSERT_EQ(new_opt.is_fd_close_on_exec, true); ASSERT_EQ(new_db_opt.is_fd_close_on_exec, true);
ASSERT_EQ(new_opt.skip_log_error_on_recovery, false); ASSERT_EQ(new_db_opt.skip_log_error_on_recovery, false);
ASSERT_EQ(new_opt.stats_dump_period_sec, 46U); ASSERT_EQ(new_db_opt.stats_dump_period_sec, 46U);
ASSERT_EQ(new_opt.advise_random_on_open, true); ASSERT_EQ(new_db_opt.advise_random_on_open, true);
ASSERT_EQ(new_opt.use_adaptive_mutex, false); ASSERT_EQ(new_db_opt.use_adaptive_mutex, false);
ASSERT_EQ(new_opt.bytes_per_sync, static_cast<uint64_t>(47)); ASSERT_EQ(new_db_opt.bytes_per_sync, static_cast<uint64_t>(47));
}
options_map["write_buffer_size"] = "hello"; TEST(OptionsTest, GetOptionsFromStringTest) {
ASSERT_TRUE(!GetOptionsFromStrings(base_opt, options_map, &new_opt)); ColumnFamilyOptions base_cf_opt;
options_map["write_buffer_size"] = "1"; ColumnFamilyOptions new_cf_opt;
ASSERT_TRUE(GetOptionsFromStrings(base_opt, options_map, &new_opt)); ASSERT_TRUE(GetColumnFamilyOptionsFromString(base_cf_opt, "", &new_cf_opt));
options_map["unknown_option"] = "1"; ASSERT_TRUE(GetColumnFamilyOptionsFromString(base_cf_opt,
ASSERT_TRUE(!GetOptionsFromStrings(base_opt, options_map, &new_opt)); "write_buffer_size=5", &new_cf_opt));
ASSERT_EQ(new_cf_opt.write_buffer_size, 5);
ASSERT_TRUE(GetColumnFamilyOptionsFromString(base_cf_opt,
"write_buffer_size=6;", &new_cf_opt));
ASSERT_EQ(new_cf_opt.write_buffer_size, 6);
ASSERT_TRUE(GetColumnFamilyOptionsFromString(base_cf_opt,
" write_buffer_size = 7 ", &new_cf_opt));
ASSERT_EQ(new_cf_opt.write_buffer_size, 7);
ASSERT_TRUE(GetColumnFamilyOptionsFromString(base_cf_opt,
" write_buffer_size = 8 ; ", &new_cf_opt));
ASSERT_EQ(new_cf_opt.write_buffer_size, 8);
ASSERT_TRUE(GetColumnFamilyOptionsFromString(base_cf_opt,
"write_buffer_size=9;max_write_buffer_number=10", &new_cf_opt));
ASSERT_EQ(new_cf_opt.write_buffer_size, 9);
ASSERT_EQ(new_cf_opt.max_write_buffer_number, 10);
ASSERT_TRUE(GetColumnFamilyOptionsFromString(base_cf_opt,
"write_buffer_size=11; max_write_buffer_number = 12 ;",
&new_cf_opt));
ASSERT_EQ(new_cf_opt.write_buffer_size, 11);
ASSERT_EQ(new_cf_opt.max_write_buffer_number, 12);
// Wrong name "max_write_buffer_number_"
ASSERT_TRUE(!GetColumnFamilyOptionsFromString(base_cf_opt,
"write_buffer_size=13;max_write_buffer_number_=14;",
&new_cf_opt));
// Wrong key/value pair
ASSERT_TRUE(!GetColumnFamilyOptionsFromString(base_cf_opt,
"write_buffer_size=13;max_write_buffer_number;", &new_cf_opt));
// Error Paring value
ASSERT_TRUE(!GetColumnFamilyOptionsFromString(base_cf_opt,
"write_buffer_size=13;max_write_buffer_number=;", &new_cf_opt));
// Missing option name
ASSERT_TRUE(!GetColumnFamilyOptionsFromString(base_cf_opt,
"write_buffer_size=13; =100;", &new_cf_opt));
} }
} // namespace rocksdb } // namespace rocksdb

40
utilities/options/convenience.h
Unescape View File

@ -0,0 +1,40 @@
// Copyright (c) 2014, Facebook, Inc. All rights reserved.
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree. An additional grant
// of patent rights can be found in the PATENTS file in the same directory.
#pragma once
#include <unordered_map>
#include <string>
#include "rocksdb/options.h"
namespace rocksdb {
// Take a map of option name and option value, apply them into the
// base_options, and return the new options as a result
bool GetColumnFamilyOptionsFromMap(
const ColumnFamilyOptions& base_options,
const std::unordered_map<std::string, std::string>& opts_map,
ColumnFamilyOptions* new_options);
bool GetDBOptionsFromMap(
const DBOptions& base_options,
const std::unordered_map<std::string, std::string>& opts_map,
DBOptions* new_options);
// Take a string representation of option names and values, apply them into the
// base_options, and return the new options as a result. The string has the
// following format:
// "write_buffer_size=1024;max_write_buffer_number=2"
bool GetColumnFamilyOptionsFromString(
const ColumnFamilyOptions& base_options,
const std::string& opts_str,
ColumnFamilyOptions* new_options);
bool GetDBOptionsFromString(
const DBOptions& base_options,
const std::string& opts_str,
DBOptions* new_options);
} // namespace rocksdb
Write Preview
Loading…
Cancel
Save