2014-05-16 19:35:41 +02:00
|
|
|
// Copyright (c) 2013, 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.
|
|
|
|
//
|
|
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
|
2014-09-05 08:14:37 +02:00
|
|
|
#ifndef __STDC_FORMAT_MACROS
|
2014-05-16 19:35:41 +02:00
|
|
|
#define __STDC_FORMAT_MACROS
|
2014-09-05 08:14:37 +02:00
|
|
|
#endif
|
|
|
|
|
2014-09-17 21:46:32 +02:00
|
|
|
#include <unordered_map>
|
2014-05-16 19:35:41 +02:00
|
|
|
#include <inttypes.h>
|
|
|
|
|
2014-12-22 22:18:57 +01:00
|
|
|
#include "rocksdb/cache.h"
|
2014-05-16 19:35:41 +02:00
|
|
|
#include "rocksdb/options.h"
|
2014-11-21 04:24:39 +01:00
|
|
|
#include "rocksdb/table.h"
|
2014-12-22 22:18:57 +01:00
|
|
|
#include "rocksdb/utilities/convenience.h"
|
|
|
|
#include "rocksdb/utilities/leveldb_options.h"
|
2014-11-21 04:24:39 +01:00
|
|
|
#include "table/block_based_table_factory.h"
|
2014-05-16 19:35:41 +02:00
|
|
|
#include "util/testharness.h"
|
|
|
|
|
2014-11-24 21:53:23 +01:00
|
|
|
#ifndef GFLAGS
|
|
|
|
bool FLAGS_enable_print = false;
|
|
|
|
#else
|
|
|
|
#include <gflags/gflags.h>
|
2014-05-16 19:35:41 +02:00
|
|
|
using GFLAGS::ParseCommandLineFlags;
|
|
|
|
DEFINE_bool(enable_print, false, "Print options generated to console.");
|
2014-11-24 21:53:23 +01:00
|
|
|
#endif // GFLAGS
|
2014-05-16 19:35:41 +02:00
|
|
|
|
|
|
|
namespace rocksdb {
|
|
|
|
|
2015-03-17 22:08:00 +01:00
|
|
|
class OptionsTest : public testing::Test {};
|
2014-05-16 19:35:41 +02:00
|
|
|
|
|
|
|
class StderrLogger : public Logger {
|
|
|
|
public:
|
2015-02-01 20:08:19 +01:00
|
|
|
using Logger::Logv;
|
2014-05-16 19:35:41 +02:00
|
|
|
virtual void Logv(const char* format, va_list ap) override {
|
|
|
|
vprintf(format, ap);
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
Options PrintAndGetOptions(size_t total_write_buffer_limit,
|
|
|
|
int read_amplification_threshold,
|
|
|
|
int write_amplification_threshold,
|
|
|
|
uint64_t target_db_size = 68719476736) {
|
|
|
|
StderrLogger logger;
|
|
|
|
|
|
|
|
if (FLAGS_enable_print) {
|
|
|
|
printf(
|
|
|
|
"---- total_write_buffer_limit: %zu "
|
|
|
|
"read_amplification_threshold: %d write_amplification_threshold: %d "
|
|
|
|
"target_db_size %" PRIu64 " ----\n",
|
|
|
|
total_write_buffer_limit, read_amplification_threshold,
|
|
|
|
write_amplification_threshold, target_db_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
Options options =
|
|
|
|
GetOptions(total_write_buffer_limit, read_amplification_threshold,
|
|
|
|
write_amplification_threshold, target_db_size);
|
|
|
|
if (FLAGS_enable_print) {
|
|
|
|
options.Dump(&logger);
|
|
|
|
printf("-------------------------------------\n\n\n");
|
|
|
|
}
|
|
|
|
return options;
|
|
|
|
}
|
|
|
|
|
2015-03-17 22:08:00 +01:00
|
|
|
TEST_F(OptionsTest, LooseCondition) {
|
2014-05-16 19:35:41 +02:00
|
|
|
Options options;
|
|
|
|
PrintAndGetOptions(static_cast<size_t>(10) * 1024 * 1024 * 1024, 100, 100);
|
|
|
|
|
|
|
|
// Less mem table memory budget
|
|
|
|
PrintAndGetOptions(32 * 1024 * 1024, 100, 100);
|
|
|
|
|
|
|
|
// Tight read amplification
|
|
|
|
options = PrintAndGetOptions(128 * 1024 * 1024, 8, 100);
|
|
|
|
ASSERT_EQ(options.compaction_style, kCompactionStyleLevel);
|
|
|
|
|
2015-01-23 01:57:16 +01:00
|
|
|
#ifndef ROCKSDB_LITE // Universal compaction is not supported in ROCKSDB_LITE
|
2014-05-16 19:35:41 +02:00
|
|
|
// Tight write amplification
|
|
|
|
options = PrintAndGetOptions(128 * 1024 * 1024, 64, 10);
|
|
|
|
ASSERT_EQ(options.compaction_style, kCompactionStyleUniversal);
|
2015-01-23 01:57:16 +01:00
|
|
|
#endif // !ROCKSDB_LITE
|
2014-05-16 19:35:41 +02:00
|
|
|
|
|
|
|
// Both tight amplifications
|
|
|
|
PrintAndGetOptions(128 * 1024 * 1024, 4, 8);
|
|
|
|
}
|
2014-09-17 21:46:32 +02:00
|
|
|
|
2015-01-23 01:57:16 +01:00
|
|
|
#ifndef ROCKSDB_LITE // GetOptionsFromMap is not supported in ROCKSDB_LITE
|
2015-03-17 22:08:00 +01:00
|
|
|
TEST_F(OptionsTest, GetOptionsFromMapTest) {
|
2014-10-10 19:00:12 +02:00
|
|
|
std::unordered_map<std::string, std::string> cf_options_map = {
|
options.level_compaction_dynamic_level_bytes to allow RocksDB to pick size bases of levels dynamically.
Summary:
When having fixed max_bytes_for_level_base, the ratio of size of largest level and the second one can range from 0 to the multiplier. This makes LSM tree frequently irregular and unpredictable. It can also cause poor space amplification in some cases.
In this improvement (proposed by Igor Kabiljo), we introduce a parameter option.level_compaction_use_dynamic_max_bytes. When turning it on, RocksDB is free to pick a level base in the range of (options.max_bytes_for_level_base/options.max_bytes_for_level_multiplier, options.max_bytes_for_level_base] so that real level ratios are close to options.max_bytes_for_level_multiplier.
Test Plan: New unit tests and pass tests suites including valgrind.
Reviewers: MarkCallaghan, rven, yhchiang, igor, ikabiljo
Reviewed By: ikabiljo
Subscribers: yoshinorim, ikabiljo, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D31437
2015-02-05 20:44:17 +01:00
|
|
|
{"write_buffer_size", "1"},
|
|
|
|
{"max_write_buffer_number", "2"},
|
|
|
|
{"min_write_buffer_number_to_merge", "3"},
|
|
|
|
{"compression", "kSnappyCompression"},
|
|
|
|
{"compression_per_level",
|
|
|
|
"kNoCompression:"
|
|
|
|
"kSnappyCompression:"
|
|
|
|
"kZlibCompression:"
|
|
|
|
"kBZip2Compression:"
|
|
|
|
"kLZ4Compression:"
|
|
|
|
"kLZ4HCCompression"},
|
|
|
|
{"compression_opts", "4:5:6"},
|
|
|
|
{"num_levels", "7"},
|
|
|
|
{"level0_file_num_compaction_trigger", "8"},
|
|
|
|
{"level0_slowdown_writes_trigger", "9"},
|
|
|
|
{"level0_stop_writes_trigger", "10"},
|
|
|
|
{"max_mem_compaction_level", "11"},
|
|
|
|
{"target_file_size_base", "12"},
|
|
|
|
{"target_file_size_multiplier", "13"},
|
|
|
|
{"max_bytes_for_level_base", "14"},
|
|
|
|
{"level_compaction_dynamic_level_bytes", "true"},
|
|
|
|
{"max_bytes_for_level_multiplier", "15"},
|
|
|
|
{"max_bytes_for_level_multiplier_additional", "16:17:18"},
|
|
|
|
{"expanded_compaction_factor", "19"},
|
|
|
|
{"source_compaction_factor", "20"},
|
|
|
|
{"max_grandparent_overlap_factor", "21"},
|
|
|
|
{"soft_rate_limit", "1.1"},
|
|
|
|
{"hard_rate_limit", "2.1"},
|
|
|
|
{"arena_block_size", "22"},
|
|
|
|
{"disable_auto_compactions", "true"},
|
|
|
|
{"purge_redundant_kvs_while_flush", "1"},
|
|
|
|
{"compaction_style", "kCompactionStyleLevel"},
|
|
|
|
{"verify_checksums_in_compaction", "false"},
|
|
|
|
{"compaction_options_fifo", "23"},
|
|
|
|
{"filter_deletes", "0"},
|
|
|
|
{"max_sequential_skip_in_iterations", "24"},
|
|
|
|
{"inplace_update_support", "true"},
|
|
|
|
{"inplace_update_num_locks", "25"},
|
|
|
|
{"memtable_prefix_bloom_bits", "26"},
|
|
|
|
{"memtable_prefix_bloom_probes", "27"},
|
|
|
|
{"memtable_prefix_bloom_huge_page_tlb_size", "28"},
|
|
|
|
{"bloom_locality", "29"},
|
|
|
|
{"max_successive_merges", "30"},
|
|
|
|
{"min_partial_merge_operands", "31"},
|
|
|
|
{"prefix_extractor", "fixed:31"},
|
|
|
|
{"optimize_filters_for_hits", "true"},
|
2014-10-10 19:00:12 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
std::unordered_map<std::string, std::string> db_options_map = {
|
2014-09-17 21:46:32 +02:00
|
|
|
{"create_if_missing", "false"},
|
|
|
|
{"create_missing_column_families", "true"},
|
|
|
|
{"error_if_exists", "false"},
|
|
|
|
{"paranoid_checks", "true"},
|
|
|
|
{"max_open_files", "32"},
|
|
|
|
{"max_total_wal_size", "33"},
|
|
|
|
{"disable_data_sync", "false"},
|
|
|
|
{"use_fsync", "true"},
|
|
|
|
{"db_log_dir", "/db_log_dir"},
|
|
|
|
{"wal_dir", "/wal_dir"},
|
|
|
|
{"delete_obsolete_files_period_micros", "34"},
|
|
|
|
{"max_background_compactions", "35"},
|
|
|
|
{"max_background_flushes", "36"},
|
|
|
|
{"max_log_file_size", "37"},
|
|
|
|
{"log_file_time_to_roll", "38"},
|
|
|
|
{"keep_log_file_num", "39"},
|
|
|
|
{"max_manifest_file_size", "40"},
|
|
|
|
{"table_cache_numshardbits", "41"},
|
|
|
|
{"WAL_ttl_seconds", "43"},
|
|
|
|
{"WAL_size_limit_MB", "44"},
|
|
|
|
{"manifest_preallocation_size", "45"},
|
|
|
|
{"allow_os_buffer", "false"},
|
|
|
|
{"allow_mmap_reads", "true"},
|
|
|
|
{"allow_mmap_writes", "false"},
|
|
|
|
{"is_fd_close_on_exec", "true"},
|
|
|
|
{"skip_log_error_on_recovery", "false"},
|
|
|
|
{"stats_dump_period_sec", "46"},
|
|
|
|
{"advise_random_on_open", "true"},
|
|
|
|
{"use_adaptive_mutex", "false"},
|
|
|
|
{"bytes_per_sync", "47"},
|
|
|
|
};
|
|
|
|
|
2014-10-10 19:00:12 +02:00
|
|
|
ColumnFamilyOptions base_cf_opt;
|
|
|
|
ColumnFamilyOptions new_cf_opt;
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromMap(
|
|
|
|
base_cf_opt, cf_options_map, &new_cf_opt));
|
2014-10-10 19:00:12 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 1U);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_write_buffer_number, 2);
|
|
|
|
ASSERT_EQ(new_cf_opt.min_write_buffer_number_to_merge, 3);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression, kSnappyCompression);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_per_level.size(), 6U);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_per_level[0], kNoCompression);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_per_level[1], kSnappyCompression);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_per_level[2], kZlibCompression);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_per_level[3], kBZip2Compression);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_per_level[4], kLZ4Compression);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_per_level[5], kLZ4HCCompression);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_opts.window_bits, 4);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_opts.level, 5);
|
|
|
|
ASSERT_EQ(new_cf_opt.compression_opts.strategy, 6);
|
|
|
|
ASSERT_EQ(new_cf_opt.num_levels, 7);
|
|
|
|
ASSERT_EQ(new_cf_opt.level0_file_num_compaction_trigger, 8);
|
|
|
|
ASSERT_EQ(new_cf_opt.level0_slowdown_writes_trigger, 9);
|
|
|
|
ASSERT_EQ(new_cf_opt.level0_stop_writes_trigger, 10);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_mem_compaction_level, 11);
|
|
|
|
ASSERT_EQ(new_cf_opt.target_file_size_base, static_cast<uint64_t>(12));
|
|
|
|
ASSERT_EQ(new_cf_opt.target_file_size_multiplier, 13);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_bytes_for_level_base, 14U);
|
options.level_compaction_dynamic_level_bytes to allow RocksDB to pick size bases of levels dynamically.
Summary:
When having fixed max_bytes_for_level_base, the ratio of size of largest level and the second one can range from 0 to the multiplier. This makes LSM tree frequently irregular and unpredictable. It can also cause poor space amplification in some cases.
In this improvement (proposed by Igor Kabiljo), we introduce a parameter option.level_compaction_use_dynamic_max_bytes. When turning it on, RocksDB is free to pick a level base in the range of (options.max_bytes_for_level_base/options.max_bytes_for_level_multiplier, options.max_bytes_for_level_base] so that real level ratios are close to options.max_bytes_for_level_multiplier.
Test Plan: New unit tests and pass tests suites including valgrind.
Reviewers: MarkCallaghan, rven, yhchiang, igor, ikabiljo
Reviewed By: ikabiljo
Subscribers: yoshinorim, ikabiljo, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D31437
2015-02-05 20:44:17 +01:00
|
|
|
ASSERT_EQ(new_cf_opt.level_compaction_dynamic_level_bytes, true);
|
2014-10-10 19:00:12 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier, 15);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier_additional.size(), 3U);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier_additional[0], 16);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier_additional[1], 17);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_bytes_for_level_multiplier_additional[2], 18);
|
|
|
|
ASSERT_EQ(new_cf_opt.expanded_compaction_factor, 19);
|
|
|
|
ASSERT_EQ(new_cf_opt.source_compaction_factor, 20);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_grandparent_overlap_factor, 21);
|
|
|
|
ASSERT_EQ(new_cf_opt.soft_rate_limit, 1.1);
|
|
|
|
ASSERT_EQ(new_cf_opt.hard_rate_limit, 2.1);
|
|
|
|
ASSERT_EQ(new_cf_opt.arena_block_size, 22U);
|
|
|
|
ASSERT_EQ(new_cf_opt.disable_auto_compactions, true);
|
|
|
|
ASSERT_EQ(new_cf_opt.purge_redundant_kvs_while_flush, true);
|
|
|
|
ASSERT_EQ(new_cf_opt.compaction_style, kCompactionStyleLevel);
|
|
|
|
ASSERT_EQ(new_cf_opt.verify_checksums_in_compaction, false);
|
|
|
|
ASSERT_EQ(new_cf_opt.compaction_options_fifo.max_table_files_size,
|
2014-09-18 00:40:25 +02:00
|
|
|
static_cast<uint64_t>(23));
|
2014-10-10 19:00:12 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.filter_deletes, false);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_sequential_skip_in_iterations,
|
2014-09-18 00:40:25 +02:00
|
|
|
static_cast<uint64_t>(24));
|
2014-10-10 19:00:12 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.inplace_update_support, true);
|
|
|
|
ASSERT_EQ(new_cf_opt.inplace_update_num_locks, 25U);
|
|
|
|
ASSERT_EQ(new_cf_opt.memtable_prefix_bloom_bits, 26U);
|
|
|
|
ASSERT_EQ(new_cf_opt.memtable_prefix_bloom_probes, 27U);
|
|
|
|
ASSERT_EQ(new_cf_opt.memtable_prefix_bloom_huge_page_tlb_size, 28U);
|
|
|
|
ASSERT_EQ(new_cf_opt.bloom_locality, 29U);
|
|
|
|
ASSERT_EQ(new_cf_opt.max_successive_merges, 30U);
|
|
|
|
ASSERT_EQ(new_cf_opt.min_partial_merge_operands, 31U);
|
2015-01-16 00:33:12 +01:00
|
|
|
ASSERT_TRUE(new_cf_opt.prefix_extractor != nullptr);
|
2015-02-17 17:03:45 +01:00
|
|
|
ASSERT_EQ(new_cf_opt.optimize_filters_for_hits, true);
|
2015-01-16 00:33:12 +01:00
|
|
|
ASSERT_EQ(std::string(new_cf_opt.prefix_extractor->Name()),
|
|
|
|
"rocksdb.FixedPrefix.31");
|
2014-10-10 19:00:12 +02:00
|
|
|
|
|
|
|
cf_options_map["write_buffer_size"] = "hello";
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromMap(
|
|
|
|
base_cf_opt, cf_options_map, &new_cf_opt));
|
2014-10-10 19:00:12 +02:00
|
|
|
cf_options_map["write_buffer_size"] = "1";
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromMap(
|
|
|
|
base_cf_opt, cf_options_map, &new_cf_opt));
|
2014-10-10 19:00:12 +02:00
|
|
|
cf_options_map["unknown_option"] = "1";
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromMap(
|
|
|
|
base_cf_opt, cf_options_map, &new_cf_opt));
|
2014-10-10 19:00:12 +02:00
|
|
|
|
|
|
|
DBOptions base_db_opt;
|
|
|
|
DBOptions new_db_opt;
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetDBOptionsFromMap(base_db_opt, db_options_map, &new_db_opt));
|
2014-10-10 19:00:12 +02:00
|
|
|
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,
|
2014-09-18 00:40:25 +02:00
|
|
|
static_cast<uint64_t>(34));
|
2014-10-10 19:00:12 +02:00
|
|
|
ASSERT_EQ(new_db_opt.max_background_compactions, 35);
|
|
|
|
ASSERT_EQ(new_db_opt.max_background_flushes, 36);
|
|
|
|
ASSERT_EQ(new_db_opt.max_log_file_size, 37U);
|
|
|
|
ASSERT_EQ(new_db_opt.log_file_time_to_roll, 38U);
|
|
|
|
ASSERT_EQ(new_db_opt.keep_log_file_num, 39U);
|
|
|
|
ASSERT_EQ(new_db_opt.max_manifest_file_size, static_cast<uint64_t>(40));
|
|
|
|
ASSERT_EQ(new_db_opt.table_cache_numshardbits, 41);
|
|
|
|
ASSERT_EQ(new_db_opt.WAL_ttl_seconds, static_cast<uint64_t>(43));
|
|
|
|
ASSERT_EQ(new_db_opt.WAL_size_limit_MB, static_cast<uint64_t>(44));
|
|
|
|
ASSERT_EQ(new_db_opt.manifest_preallocation_size, 45U);
|
|
|
|
ASSERT_EQ(new_db_opt.allow_os_buffer, false);
|
|
|
|
ASSERT_EQ(new_db_opt.allow_mmap_reads, true);
|
|
|
|
ASSERT_EQ(new_db_opt.allow_mmap_writes, false);
|
|
|
|
ASSERT_EQ(new_db_opt.is_fd_close_on_exec, true);
|
|
|
|
ASSERT_EQ(new_db_opt.skip_log_error_on_recovery, false);
|
|
|
|
ASSERT_EQ(new_db_opt.stats_dump_period_sec, 46U);
|
|
|
|
ASSERT_EQ(new_db_opt.advise_random_on_open, true);
|
|
|
|
ASSERT_EQ(new_db_opt.use_adaptive_mutex, false);
|
|
|
|
ASSERT_EQ(new_db_opt.bytes_per_sync, static_cast<uint64_t>(47));
|
|
|
|
}
|
2015-01-23 01:57:16 +01:00
|
|
|
#endif // !ROCKSDB_LITE
|
2014-09-17 21:46:32 +02:00
|
|
|
|
2015-02-20 04:11:14 +01:00
|
|
|
#ifndef ROCKSDB_LITE // GetColumnFamilyOptionsFromString is not supported in
|
|
|
|
// ROCKSDB_LITE
|
2015-03-17 22:08:00 +01:00
|
|
|
TEST_F(OptionsTest, GetColumnFamilyOptionsFromStringTest) {
|
2014-10-10 19:00:12 +02:00
|
|
|
ColumnFamilyOptions base_cf_opt;
|
|
|
|
ColumnFamilyOptions new_cf_opt;
|
2014-12-22 22:18:57 +01:00
|
|
|
base_cf_opt.table_factory.reset();
|
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt, "", &new_cf_opt));
|
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=5", &new_cf_opt));
|
2014-10-10 23:19:51 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 5U);
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_TRUE(new_cf_opt.table_factory == nullptr);
|
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=6;", &new_cf_opt));
|
2014-10-10 23:19:51 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 6U);
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
" write_buffer_size = 7 ", &new_cf_opt));
|
2014-10-10 23:19:51 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 7U);
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
" write_buffer_size = 8 ; ", &new_cf_opt));
|
2014-10-10 23:19:51 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 8U);
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=9;max_write_buffer_number=10", &new_cf_opt));
|
2014-10-10 23:19:51 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 9U);
|
2014-10-10 19:00:12 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.max_write_buffer_number, 10);
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=11; max_write_buffer_number = 12 ;",
|
|
|
|
&new_cf_opt));
|
2014-10-10 23:19:51 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 11U);
|
2014-10-10 19:00:12 +02:00
|
|
|
ASSERT_EQ(new_cf_opt.max_write_buffer_number, 12);
|
|
|
|
// Wrong name "max_write_buffer_number_"
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=13;max_write_buffer_number_=14;",
|
2014-10-10 19:00:12 +02:00
|
|
|
&new_cf_opt));
|
|
|
|
// Wrong key/value pair
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=13;max_write_buffer_number;", &new_cf_opt));
|
2014-10-10 19:00:12 +02:00
|
|
|
// Error Paring value
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=13;max_write_buffer_number=;", &new_cf_opt));
|
2014-10-10 19:00:12 +02:00
|
|
|
// Missing option name
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=13; =100;", &new_cf_opt));
|
2014-11-17 22:47:51 +01:00
|
|
|
// Units (k)
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"memtable_prefix_bloom_bits=14k;max_write_buffer_number=-15K",
|
|
|
|
&new_cf_opt));
|
2014-11-19 05:41:29 +01:00
|
|
|
ASSERT_EQ(new_cf_opt.memtable_prefix_bloom_bits, 14UL*1024UL);
|
2014-11-17 22:47:51 +01:00
|
|
|
ASSERT_EQ(new_cf_opt.max_write_buffer_number, -15*1024);
|
|
|
|
// Units (m)
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"max_write_buffer_number=16m;inplace_update_num_locks=17M",
|
|
|
|
&new_cf_opt));
|
2014-11-17 22:47:51 +01:00
|
|
|
ASSERT_EQ(new_cf_opt.max_write_buffer_number, 16*1024*1024);
|
2014-11-19 05:41:29 +01:00
|
|
|
ASSERT_EQ(new_cf_opt.inplace_update_num_locks, 17*1024UL*1024UL);
|
2014-11-17 22:47:51 +01:00
|
|
|
// Units (g)
|
2015-01-21 20:09:56 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(
|
|
|
|
base_cf_opt,
|
|
|
|
"write_buffer_size=18g;prefix_extractor=capped:8;"
|
|
|
|
"arena_block_size=19G",
|
|
|
|
&new_cf_opt));
|
2014-11-19 05:41:29 +01:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 18*1024UL*1024UL*1024UL);
|
|
|
|
ASSERT_EQ(new_cf_opt.arena_block_size, 19*1024UL*1024UL*1024UL);
|
2015-01-21 20:09:56 +01:00
|
|
|
ASSERT_TRUE(new_cf_opt.prefix_extractor.get() != nullptr);
|
|
|
|
std::string prefix_name(new_cf_opt.prefix_extractor->Name());
|
|
|
|
ASSERT_EQ(prefix_name, "rocksdb.CappedPrefix.8");
|
|
|
|
|
2014-11-17 22:47:51 +01:00
|
|
|
// Units (t)
|
2014-12-22 22:18:57 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=20t;arena_block_size=21T", &new_cf_opt));
|
2014-11-19 05:41:29 +01:00
|
|
|
ASSERT_EQ(new_cf_opt.write_buffer_size, 20*1024UL*1024UL*1024UL*1024UL);
|
|
|
|
ASSERT_EQ(new_cf_opt.arena_block_size, 21*1024UL*1024UL*1024UL*1024UL);
|
2014-12-22 22:18:57 +01:00
|
|
|
|
|
|
|
// Nested block based table options
|
|
|
|
// Emtpy
|
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={};arena_block_size=1024",
|
|
|
|
&new_cf_opt));
|
|
|
|
ASSERT_TRUE(new_cf_opt.table_factory != nullptr);
|
|
|
|
// Non-empty
|
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={block_cache=1M;block_size=4;};"
|
|
|
|
"arena_block_size=1024",
|
|
|
|
&new_cf_opt));
|
|
|
|
ASSERT_TRUE(new_cf_opt.table_factory != nullptr);
|
|
|
|
// Last one
|
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={block_cache=1M;block_size=4;}",
|
|
|
|
&new_cf_opt));
|
|
|
|
ASSERT_TRUE(new_cf_opt.table_factory != nullptr);
|
|
|
|
// Mismatch curly braces
|
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={{{block_size=4;};"
|
|
|
|
"arena_block_size=1024",
|
|
|
|
&new_cf_opt));
|
|
|
|
// Unexpected chars after closing curly brace
|
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={block_size=4;}};"
|
|
|
|
"arena_block_size=1024",
|
|
|
|
&new_cf_opt));
|
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={block_size=4;}xdfa;"
|
|
|
|
"arena_block_size=1024",
|
|
|
|
&new_cf_opt));
|
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={block_size=4;}xdfa",
|
|
|
|
&new_cf_opt));
|
|
|
|
// Invalid block based table option
|
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={xx_block_size=4;}",
|
|
|
|
&new_cf_opt));
|
2015-02-17 17:03:45 +01:00
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"optimize_filters_for_hits=true",
|
|
|
|
&new_cf_opt));
|
|
|
|
ASSERT_OK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"optimize_filters_for_hits=false",
|
|
|
|
&new_cf_opt));
|
|
|
|
ASSERT_NOK(GetColumnFamilyOptionsFromString(base_cf_opt,
|
|
|
|
"optimize_filters_for_hits=junk",
|
|
|
|
&new_cf_opt));
|
2014-12-22 22:18:57 +01:00
|
|
|
}
|
2015-01-23 01:57:16 +01:00
|
|
|
#endif // !ROCKSDB_LITE
|
2014-12-22 22:18:57 +01:00
|
|
|
|
2015-01-23 01:57:16 +01:00
|
|
|
#ifndef ROCKSDB_LITE // GetBlockBasedTableOptionsFromString is not supported
|
2015-03-17 22:08:00 +01:00
|
|
|
TEST_F(OptionsTest, GetBlockBasedTableOptionsFromString) {
|
2014-12-22 22:18:57 +01:00
|
|
|
BlockBasedTableOptions table_opt;
|
|
|
|
BlockBasedTableOptions new_opt;
|
|
|
|
// make sure default values are overwritten by something else
|
|
|
|
ASSERT_OK(GetBlockBasedTableOptionsFromString(table_opt,
|
|
|
|
"cache_index_and_filter_blocks=1;index_type=kHashSearch;"
|
|
|
|
"checksum=kxxHash;hash_index_allow_collision=1;no_block_cache=1;"
|
|
|
|
"block_cache=1M;block_cache_compressed=1k;block_size=1024;"
|
|
|
|
"block_size_deviation=8;block_restart_interval=4;"
|
|
|
|
"filter_policy=bloomfilter:4:true;whole_key_filtering=1",
|
|
|
|
&new_opt));
|
|
|
|
ASSERT_TRUE(new_opt.cache_index_and_filter_blocks);
|
|
|
|
ASSERT_EQ(new_opt.index_type, BlockBasedTableOptions::kHashSearch);
|
|
|
|
ASSERT_EQ(new_opt.checksum, ChecksumType::kxxHash);
|
|
|
|
ASSERT_TRUE(new_opt.hash_index_allow_collision);
|
|
|
|
ASSERT_TRUE(new_opt.no_block_cache);
|
|
|
|
ASSERT_TRUE(new_opt.block_cache != nullptr);
|
|
|
|
ASSERT_EQ(new_opt.block_cache->GetCapacity(), 1024UL*1024UL);
|
|
|
|
ASSERT_TRUE(new_opt.block_cache_compressed != nullptr);
|
|
|
|
ASSERT_EQ(new_opt.block_cache_compressed->GetCapacity(), 1024UL);
|
|
|
|
ASSERT_EQ(new_opt.block_size, 1024UL);
|
|
|
|
ASSERT_EQ(new_opt.block_size_deviation, 8);
|
|
|
|
ASSERT_EQ(new_opt.block_restart_interval, 4);
|
|
|
|
ASSERT_TRUE(new_opt.filter_policy != nullptr);
|
|
|
|
|
|
|
|
// unknown option
|
|
|
|
ASSERT_NOK(GetBlockBasedTableOptionsFromString(table_opt,
|
|
|
|
"cache_index_and_filter_blocks=1;index_type=kBinarySearch;"
|
|
|
|
"bad_option=1",
|
|
|
|
&new_opt));
|
|
|
|
|
|
|
|
// unrecognized index type
|
|
|
|
ASSERT_NOK(GetBlockBasedTableOptionsFromString(table_opt,
|
|
|
|
"cache_index_and_filter_blocks=1;index_type=kBinarySearchXX",
|
|
|
|
&new_opt));
|
|
|
|
|
|
|
|
// unrecognized checksum type
|
|
|
|
ASSERT_NOK(GetBlockBasedTableOptionsFromString(table_opt,
|
|
|
|
"cache_index_and_filter_blocks=1;checksum=kxxHashXX",
|
|
|
|
&new_opt));
|
|
|
|
|
|
|
|
// unrecognized filter policy name
|
|
|
|
ASSERT_NOK(GetBlockBasedTableOptionsFromString(table_opt,
|
|
|
|
"cache_index_and_filter_blocks=1;"
|
|
|
|
"filter_policy=bloomfilterxx:4:true",
|
|
|
|
&new_opt));
|
|
|
|
// unrecognized filter policy config
|
|
|
|
ASSERT_NOK(GetBlockBasedTableOptionsFromString(table_opt,
|
|
|
|
"cache_index_and_filter_blocks=1;"
|
|
|
|
"filter_policy=bloomfilter:4",
|
|
|
|
&new_opt));
|
|
|
|
}
|
2015-01-23 01:57:16 +01:00
|
|
|
#endif // !ROCKSDB_LITE
|
2014-12-22 22:18:57 +01:00
|
|
|
|
2015-02-20 04:11:14 +01:00
|
|
|
#ifndef ROCKSDB_LITE // GetOptionsFromString is not supported in RocksDB Lite
|
2015-03-17 22:08:00 +01:00
|
|
|
TEST_F(OptionsTest, GetOptionsFromStringTest) {
|
2015-02-20 04:11:14 +01:00
|
|
|
Options base_options, new_options;
|
|
|
|
base_options.write_buffer_size = 20;
|
|
|
|
base_options.min_write_buffer_number_to_merge = 15;
|
|
|
|
BlockBasedTableOptions block_based_table_options;
|
|
|
|
block_based_table_options.cache_index_and_filter_blocks = true;
|
|
|
|
base_options.table_factory.reset(
|
|
|
|
NewBlockBasedTableFactory(block_based_table_options));
|
|
|
|
ASSERT_OK(GetOptionsFromString(
|
|
|
|
base_options,
|
|
|
|
"write_buffer_size=10;max_write_buffer_number=16;"
|
|
|
|
"block_based_table_factory={block_cache=1M;block_size=4;};"
|
2015-03-06 23:21:15 +01:00
|
|
|
"create_if_missing=true;max_open_files=1;rate_limiter_bytes_per_sec=1024",
|
2015-02-20 04:11:14 +01:00
|
|
|
&new_options));
|
|
|
|
|
|
|
|
ASSERT_EQ(new_options.write_buffer_size, 10U);
|
2015-02-20 04:26:38 +01:00
|
|
|
ASSERT_EQ(new_options.max_write_buffer_number, 16);
|
2015-02-20 04:11:14 +01:00
|
|
|
BlockBasedTableOptions new_block_based_table_options =
|
|
|
|
dynamic_cast<BlockBasedTableFactory*>(new_options.table_factory.get())
|
|
|
|
->GetTableOptions();
|
|
|
|
ASSERT_EQ(new_block_based_table_options.block_cache->GetCapacity(), 1U << 20);
|
2015-02-20 04:26:38 +01:00
|
|
|
ASSERT_EQ(new_block_based_table_options.block_size, 4U);
|
2015-02-20 04:11:14 +01:00
|
|
|
// don't overwrite block based table options
|
|
|
|
ASSERT_TRUE(new_block_based_table_options.cache_index_and_filter_blocks);
|
|
|
|
|
|
|
|
ASSERT_EQ(new_options.create_if_missing, true);
|
|
|
|
ASSERT_EQ(new_options.max_open_files, 1);
|
2015-03-06 23:21:15 +01:00
|
|
|
ASSERT_TRUE(new_options.rate_limiter.get() != nullptr);
|
2015-02-20 04:11:14 +01:00
|
|
|
}
|
|
|
|
#endif // !ROCKSDB_LITE
|
|
|
|
|
|
|
|
|
2014-12-22 22:18:57 +01:00
|
|
|
Status StringToMap(
|
|
|
|
const std::string& opts_str,
|
|
|
|
std::unordered_map<std::string, std::string>* opts_map);
|
|
|
|
|
2015-01-23 01:57:16 +01:00
|
|
|
#ifndef ROCKSDB_LITE // StringToMap is not supported in ROCKSDB_LITE
|
2015-03-17 22:08:00 +01:00
|
|
|
TEST_F(OptionsTest, StringToMapTest) {
|
2014-12-22 22:18:57 +01:00
|
|
|
std::unordered_map<std::string, std::string> opts_map;
|
|
|
|
// Regular options
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2=v2;k3=v3", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "v2");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "v3");
|
|
|
|
// Value with '='
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1==v1;k2=v2=;", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "=v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "v2=");
|
|
|
|
// Overwrriten option
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k1=v2;k3=v3", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v2");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "v3");
|
|
|
|
// Empty value
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2=;k3=v3;k4=", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_TRUE(opts_map.find("k2") != opts_map.end());
|
|
|
|
ASSERT_EQ(opts_map["k2"], "");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "v3");
|
|
|
|
ASSERT_TRUE(opts_map.find("k4") != opts_map.end());
|
|
|
|
ASSERT_EQ(opts_map["k4"], "");
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2=;k3=v3;k4= ", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_TRUE(opts_map.find("k2") != opts_map.end());
|
|
|
|
ASSERT_EQ(opts_map["k2"], "");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "v3");
|
|
|
|
ASSERT_TRUE(opts_map.find("k4") != opts_map.end());
|
|
|
|
ASSERT_EQ(opts_map["k4"], "");
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2=;k3=", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_TRUE(opts_map.find("k2") != opts_map.end());
|
|
|
|
ASSERT_EQ(opts_map["k2"], "");
|
|
|
|
ASSERT_TRUE(opts_map.find("k3") != opts_map.end());
|
|
|
|
ASSERT_EQ(opts_map["k3"], "");
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2=;k3=;", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_TRUE(opts_map.find("k2") != opts_map.end());
|
|
|
|
ASSERT_EQ(opts_map["k2"], "");
|
|
|
|
ASSERT_TRUE(opts_map.find("k3") != opts_map.end());
|
|
|
|
ASSERT_EQ(opts_map["k3"], "");
|
|
|
|
// Regular nested options
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2={nk1=nv1;nk2=nv2};k3=v3", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "nk1=nv1;nk2=nv2");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "v3");
|
|
|
|
// Multi-level nested options
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2={nk1=nv1;nk2={nnk1=nnk2}};"
|
|
|
|
"k3={nk1={nnk1={nnnk1=nnnv1;nnnk2;nnnv2}}};k4=v4",
|
|
|
|
&opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "nk1=nv1;nk2={nnk1=nnk2}");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "nk1={nnk1={nnnk1=nnnv1;nnnk2;nnnv2}}");
|
|
|
|
ASSERT_EQ(opts_map["k4"], "v4");
|
|
|
|
// Garbage inside curly braces
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2={dfad=};k3={=};k4=v4",
|
|
|
|
&opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "dfad=");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "=");
|
|
|
|
ASSERT_EQ(opts_map["k4"], "v4");
|
|
|
|
// Empty nested options
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2={};", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "");
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2={{{{}}}{}{}};", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "{{{}}}{}{}");
|
|
|
|
// With random spaces
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap(" k1 = v1 ; k2= {nk1=nv1; nk2={nnk1=nnk2}} ; "
|
|
|
|
"k3={ { } }; k4= v4 ",
|
|
|
|
&opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "nk1=nv1; nk2={nnk1=nnk2}");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "{ }");
|
|
|
|
ASSERT_EQ(opts_map["k4"], "v4");
|
|
|
|
|
|
|
|
// Empty key
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2=v2;=", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("=v1;k2=v2", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2v2;", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2=v2;fadfa", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2=v2;;", &opts_map));
|
|
|
|
// Mismatch curly braces
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={;k3=v3", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={{};k3=v3", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={}};k3=v3", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={{}{}}};k3=v3", &opts_map));
|
|
|
|
// However this is valid!
|
|
|
|
opts_map.clear();
|
|
|
|
ASSERT_OK(StringToMap("k1=v1;k2=};k3=v3", &opts_map));
|
|
|
|
ASSERT_EQ(opts_map["k1"], "v1");
|
|
|
|
ASSERT_EQ(opts_map["k2"], "}");
|
|
|
|
ASSERT_EQ(opts_map["k3"], "v3");
|
|
|
|
|
|
|
|
// Invalid chars after closing curly brace
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={{}}{};k3=v3", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={{}}cfda;k3=v3", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={{}} cfda;k3=v3", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={{}} cfda", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={{}}{}", &opts_map));
|
|
|
|
ASSERT_NOK(StringToMap("k1=v1;k2={{dfdl}adfa}{}", &opts_map));
|
|
|
|
}
|
2015-01-23 01:57:16 +01:00
|
|
|
#endif // ROCKSDB_LITE
|
2014-12-22 22:18:57 +01:00
|
|
|
|
2015-01-23 01:57:16 +01:00
|
|
|
#ifndef ROCKSDB_LITE // StringToMap is not supported in ROCKSDB_LITE
|
2015-03-17 22:08:00 +01:00
|
|
|
TEST_F(OptionsTest, StringToMapRandomTest) {
|
2014-12-22 22:18:57 +01:00
|
|
|
std::unordered_map<std::string, std::string> opts_map;
|
|
|
|
// Make sure segfault is not hit by semi-random strings
|
|
|
|
|
|
|
|
std::vector<std::string> bases = {
|
|
|
|
"a={aa={};tt={xxx={}}};c=defff",
|
|
|
|
"a={aa={};tt={xxx={}}};c=defff;d={{}yxx{}3{xx}}",
|
|
|
|
"abc={{}{}{}{{{}}}{{}{}{}{}{}{}{}"};
|
|
|
|
|
|
|
|
for (std::string base : bases) {
|
|
|
|
for (int rand_seed = 301; rand_seed < 401; rand_seed++) {
|
|
|
|
Random rnd(rand_seed);
|
|
|
|
for (int attempt = 0; attempt < 10; attempt++) {
|
|
|
|
std::string str = base;
|
|
|
|
// Replace random position to space
|
|
|
|
size_t pos = static_cast<size_t>(
|
|
|
|
rnd.Uniform(static_cast<int>(base.size())));
|
|
|
|
str[pos] = ' ';
|
|
|
|
Status s = StringToMap(str, &opts_map);
|
|
|
|
ASSERT_TRUE(s.ok() || s.IsInvalidArgument());
|
|
|
|
opts_map.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Random Construct a string
|
|
|
|
std::vector<char> chars = {'{', '}', ' ', '=', ';', 'c'};
|
|
|
|
for (int rand_seed = 301; rand_seed < 1301; rand_seed++) {
|
|
|
|
Random rnd(rand_seed);
|
|
|
|
int len = rnd.Uniform(30);
|
|
|
|
std::string str = "";
|
|
|
|
for (int attempt = 0; attempt < len; attempt++) {
|
|
|
|
// Add a random character
|
|
|
|
size_t pos = static_cast<size_t>(
|
|
|
|
rnd.Uniform(static_cast<int>(chars.size())));
|
|
|
|
str.append(1, chars[pos]);
|
|
|
|
}
|
|
|
|
Status s = StringToMap(str, &opts_map);
|
|
|
|
ASSERT_TRUE(s.ok() || s.IsInvalidArgument());
|
|
|
|
s = StringToMap("name=" + str, &opts_map);
|
|
|
|
ASSERT_TRUE(s.ok() || s.IsInvalidArgument());
|
|
|
|
opts_map.clear();
|
|
|
|
}
|
2014-09-17 21:46:32 +02:00
|
|
|
}
|
2015-01-23 01:57:16 +01:00
|
|
|
#endif // !ROCKSDB_LITE
|
2014-09-17 21:46:32 +02:00
|
|
|
|
2015-03-17 22:08:00 +01:00
|
|
|
TEST_F(OptionsTest, ConvertOptionsTest) {
|
2014-11-21 04:24:39 +01:00
|
|
|
LevelDBOptions leveldb_opt;
|
|
|
|
Options converted_opt = ConvertOptions(leveldb_opt);
|
|
|
|
|
|
|
|
ASSERT_EQ(converted_opt.create_if_missing, leveldb_opt.create_if_missing);
|
|
|
|
ASSERT_EQ(converted_opt.error_if_exists, leveldb_opt.error_if_exists);
|
|
|
|
ASSERT_EQ(converted_opt.paranoid_checks, leveldb_opt.paranoid_checks);
|
|
|
|
ASSERT_EQ(converted_opt.env, leveldb_opt.env);
|
|
|
|
ASSERT_EQ(converted_opt.info_log.get(), leveldb_opt.info_log);
|
|
|
|
ASSERT_EQ(converted_opt.write_buffer_size, leveldb_opt.write_buffer_size);
|
|
|
|
ASSERT_EQ(converted_opt.max_open_files, leveldb_opt.max_open_files);
|
|
|
|
ASSERT_EQ(converted_opt.compression, leveldb_opt.compression);
|
|
|
|
|
|
|
|
std::shared_ptr<BlockBasedTableFactory> table_factory =
|
|
|
|
std::dynamic_pointer_cast<BlockBasedTableFactory>(
|
|
|
|
converted_opt.table_factory);
|
|
|
|
|
|
|
|
ASSERT_TRUE(table_factory.get() != nullptr);
|
|
|
|
|
|
|
|
const BlockBasedTableOptions table_opt = table_factory->GetTableOptions();
|
|
|
|
|
|
|
|
ASSERT_EQ(table_opt.block_cache->GetCapacity(), 8UL << 20);
|
|
|
|
ASSERT_EQ(table_opt.block_size, leveldb_opt.block_size);
|
|
|
|
ASSERT_EQ(table_opt.block_restart_interval,
|
|
|
|
leveldb_opt.block_restart_interval);
|
|
|
|
ASSERT_EQ(table_opt.filter_policy.get(), leveldb_opt.filter_policy);
|
|
|
|
}
|
|
|
|
|
2014-05-16 19:35:41 +02:00
|
|
|
} // namespace rocksdb
|
|
|
|
|
|
|
|
int main(int argc, char** argv) {
|
2015-03-17 22:08:00 +01:00
|
|
|
::testing::InitGoogleTest(&argc, argv);
|
2014-11-24 21:53:23 +01:00
|
|
|
#ifdef GFLAGS
|
2014-05-16 19:35:41 +02:00
|
|
|
ParseCommandLineFlags(&argc, &argv, true);
|
2014-11-24 21:53:23 +01:00
|
|
|
#endif // GFLAGS
|
2015-03-17 22:08:00 +01:00
|
|
|
return RUN_ALL_TESTS();
|
2014-05-16 19:35:41 +02:00
|
|
|
}
|