thirdparty/rocksdb/table/plain_table_factory.cc - nifi-minifi-cpp - Git at Google

 // 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.

 #ifndef ROCKSDB_LITE
 #include "table/plain_table_factory.h"

 #include <stdint.h>
 #include <memory>
 #include "db/dbformat.h"
 #include "options/options_helper.h"
 #include "port/port.h"
 #include "rocksdb/convenience.h"
 #include "table/plain_table_builder.h"
 #include "table/plain_table_reader.h"
 #include "util/string_util.h"

 namespace rocksdb {

 Status PlainTableFactory::NewTableReader(
     const TableReaderOptions& table_reader_options,
     unique_ptr<RandomAccessFileReader>&& file, uint64_t file_size,
     unique_ptr<TableReader>* table,
     bool prefetch_index_and_filter_in_cache) const {
   return PlainTableReader::Open(
       table_reader_options.ioptions, table_reader_options.env_options,
       table_reader_options.internal_comparator, std::move(file), file_size,
       table, table_options_.bloom_bits_per_key, table_options_.hash_table_ratio,
       table_options_.index_sparseness, table_options_.huge_page_tlb_size,
       table_options_.full_scan_mode);
 }

 TableBuilder* PlainTableFactory::NewTableBuilder(
     const TableBuilderOptions& table_builder_options, uint32_t column_family_id,
     WritableFileWriter* file) const {
   // Ignore the skip_filters flag. PlainTable format is optimized for small
   // in-memory dbs. The skip_filters optimization is not useful for plain
   // tables
   //
   return new PlainTableBuilder(
       table_builder_options.ioptions,
       table_builder_options.int_tbl_prop_collector_factories, column_family_id,
       file, table_options_.user_key_len, table_options_.encoding_type,
       table_options_.index_sparseness, table_options_.bloom_bits_per_key,
       table_builder_options.column_family_name, 6,
       table_options_.huge_page_tlb_size, table_options_.hash_table_ratio,
       table_options_.store_index_in_file);
 }

 std::string PlainTableFactory::GetPrintableTableOptions() const {
   std::string ret;
   ret.reserve(20000);
   const int kBufferSize = 200;
   char buffer[kBufferSize];

   snprintf(buffer, kBufferSize, "  user_key_len: %u\n",
            table_options_.user_key_len);
   ret.append(buffer);
   snprintf(buffer, kBufferSize, "  bloom_bits_per_key: %d\n",
            table_options_.bloom_bits_per_key);
   ret.append(buffer);
   snprintf(buffer, kBufferSize, "  hash_table_ratio: %lf\n",
            table_options_.hash_table_ratio);
   ret.append(buffer);
   snprintf(buffer, kBufferSize, "  index_sparseness: %" ROCKSDB_PRIszt "\n",
            table_options_.index_sparseness);
   ret.append(buffer);
   snprintf(buffer, kBufferSize, "  huge_page_tlb_size: %" ROCKSDB_PRIszt "\n",
            table_options_.huge_page_tlb_size);
   ret.append(buffer);
   snprintf(buffer, kBufferSize, "  encoding_type: %d\n",
            table_options_.encoding_type);
   ret.append(buffer);
   snprintf(buffer, kBufferSize, "  full_scan_mode: %d\n",
            table_options_.full_scan_mode);
   ret.append(buffer);
   snprintf(buffer, kBufferSize, "  store_index_in_file: %d\n",
            table_options_.store_index_in_file);
   ret.append(buffer);
   return ret;
 }

 const PlainTableOptions& PlainTableFactory::table_options() const {
   return table_options_;
 }

 Status GetPlainTableOptionsFromString(const PlainTableOptions& table_options,
                                       const std::string& opts_str,
                                       PlainTableOptions* new_table_options) {
   std::unordered_map<std::string, std::string> opts_map;
   Status s = StringToMap(opts_str, &opts_map);
   if (!s.ok()) {
     return s;
   }
   return GetPlainTableOptionsFromMap(table_options, opts_map,
                                      new_table_options);
 }

 Status GetMemTableRepFactoryFromString(
     const std::string& opts_str,
     std::unique_ptr<MemTableRepFactory>* new_mem_factory) {
   std::vector<std::string> opts_list = StringSplit(opts_str, ':');
   size_t len = opts_list.size();

   if (opts_list.size() <= 0 || opts_list.size() > 2) {
     return Status::InvalidArgument("Can't parse memtable_factory option ",
                                    opts_str);
   }

   MemTableRepFactory* mem_factory = nullptr;

   if (opts_list[0] == "skip_list") {
     // Expecting format
     // skip_list:<lookahead>
     if (2 == len) {
       size_t lookahead = ParseSizeT(opts_list[1]);
       mem_factory = new SkipListFactory(lookahead);
     } else if (1 == len) {
       mem_factory = new SkipListFactory();
     }
   } else if (opts_list[0] == "prefix_hash") {
     // Expecting format
     // prfix_hash:<hash_bucket_count>
     if (2 == len) {
       size_t hash_bucket_count = ParseSizeT(opts_list[1]);
       mem_factory = NewHashSkipListRepFactory(hash_bucket_count);
     } else if (1 == len) {
       mem_factory = NewHashSkipListRepFactory();
     }
   } else if (opts_list[0] == "hash_linkedlist") {
     // Expecting format
     // hash_linkedlist:<hash_bucket_count>
     if (2 == len) {
       size_t hash_bucket_count = ParseSizeT(opts_list[1]);
       mem_factory = NewHashLinkListRepFactory(hash_bucket_count);
     } else if (1 == len) {
       mem_factory = NewHashLinkListRepFactory();
     }
   } else if (opts_list[0] == "vector") {
     // Expecting format
     // vector:<count>
     if (2 == len) {
       size_t count = ParseSizeT(opts_list[1]);
       mem_factory = new VectorRepFactory(count);
     } else if (1 == len) {
       mem_factory = new VectorRepFactory();
     }
   } else if (opts_list[0] == "cuckoo") {
     // Expecting format
     // cuckoo:<write_buffer_size>
     if (2 == len) {
       size_t write_buffer_size = ParseSizeT(opts_list[1]);
       mem_factory = NewHashCuckooRepFactory(write_buffer_size);
     } else if (1 == len) {
       return Status::InvalidArgument("Can't parse memtable_factory option ",
                                      opts_str);
     }
   } else {
     return Status::InvalidArgument("Unrecognized memtable_factory option ",
                                    opts_str);
   }

   if (mem_factory != nullptr) {
     new_mem_factory->reset(mem_factory);
   }

   return Status::OK();
 }

 std::string ParsePlainTableOptions(const std::string& name,
                                    const std::string& org_value,
                                    PlainTableOptions* new_options,
                                    bool input_strings_escaped = false,
                                    bool ignore_unknown_options = false) {
   const std::string& value =
       input_strings_escaped ? UnescapeOptionString(org_value) : org_value;
   const auto iter = plain_table_type_info.find(name);
   if (iter == plain_table_type_info.end()) {
     if (ignore_unknown_options) {
       return "";
     } else {
       return "Unrecognized option";
     }
   }
   const auto& opt_info = iter->second;
   if (opt_info.verification != OptionVerificationType::kDeprecated &&
       !ParseOptionHelper(reinterpret_cast<char*>(new_options) + opt_info.offset,
                          opt_info.type, value)) {
     return "Invalid value";
   }
   return "";
 }

 Status GetPlainTableOptionsFromMap(
     const PlainTableOptions& table_options,
     const std::unordered_map<std::string, std::string>& opts_map,
     PlainTableOptions* new_table_options, bool input_strings_escaped,
     bool ignore_unknown_options) {
   assert(new_table_options);
   *new_table_options = table_options;
   for (const auto& o : opts_map) {
     auto error_message = ParsePlainTableOptions(
         o.first, o.second, new_table_options, input_strings_escaped);
     if (error_message != "") {
       const auto iter = plain_table_type_info.find(o.first);
       if (iter == plain_table_type_info.end() ||
           !input_strings_escaped ||  // !input_strings_escaped indicates
                                      // the old API, where everything is
                                      // parsable.
           (iter->second.verification != OptionVerificationType::kByName &&
            iter->second.verification !=
                OptionVerificationType::kByNameAllowNull &&
            iter->second.verification != OptionVerificationType::kDeprecated)) {
         // Restore "new_options" to the default "base_options".
         *new_table_options = table_options;
         return Status::InvalidArgument("Can't parse PlainTableOptions:",
                                        o.first + " " + error_message);
       }
     }
   }
   return Status::OK();
 }

 extern TableFactory* NewPlainTableFactory(const PlainTableOptions& options) {
   return new PlainTableFactory(options);
 }

 const std::string PlainTablePropertyNames::kEncodingType =
     "rocksdb.plain.table.encoding.type";

 const std::string PlainTablePropertyNames::kBloomVersion =
     "rocksdb.plain.table.bloom.version";

 const std::string PlainTablePropertyNames::kNumBloomBlocks =
     "rocksdb.plain.table.bloom.numblocks";

 }  // namespace rocksdb
 #endif  // ROCKSDB_LITE
	// 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.

	#ifndef ROCKSDB_LITE
	#include "table/plain_table_factory.h"

	#include <stdint.h>
	#include <memory>
	#include "db/dbformat.h"
	#include "options/options_helper.h"
	#include "port/port.h"
	#include "rocksdb/convenience.h"
	#include "table/plain_table_builder.h"
	#include "table/plain_table_reader.h"
	#include "util/string_util.h"

	namespace rocksdb {

	Status PlainTableFactory::NewTableReader(
	const TableReaderOptions& table_reader_options,
	unique_ptr<RandomAccessFileReader>&& file, uint64_t file_size,
	unique_ptr<TableReader>* table,
	bool prefetch_index_and_filter_in_cache) const {
	return PlainTableReader::Open(
	table_reader_options.ioptions, table_reader_options.env_options,
	table_reader_options.internal_comparator, std::move(file), file_size,
	table, table_options_.bloom_bits_per_key, table_options_.hash_table_ratio,
	table_options_.index_sparseness, table_options_.huge_page_tlb_size,
	table_options_.full_scan_mode);
	}

	TableBuilder* PlainTableFactory::NewTableBuilder(
	const TableBuilderOptions& table_builder_options, uint32_t column_family_id,
	WritableFileWriter* file) const {
	// Ignore the skip_filters flag. PlainTable format is optimized for small
	// in-memory dbs. The skip_filters optimization is not useful for plain
	// tables
	//
	return new PlainTableBuilder(
	table_builder_options.ioptions,
	table_builder_options.int_tbl_prop_collector_factories, column_family_id,
	file, table_options_.user_key_len, table_options_.encoding_type,
	table_options_.index_sparseness, table_options_.bloom_bits_per_key,
	table_builder_options.column_family_name, 6,
	table_options_.huge_page_tlb_size, table_options_.hash_table_ratio,
	table_options_.store_index_in_file);
	}

	std::string PlainTableFactory::GetPrintableTableOptions() const {
	std::string ret;
	ret.reserve(20000);
	const int kBufferSize = 200;
	char buffer[kBufferSize];

	snprintf(buffer, kBufferSize, " user_key_len: %u\n",
	table_options_.user_key_len);
	ret.append(buffer);
	snprintf(buffer, kBufferSize, " bloom_bits_per_key: %d\n",
	table_options_.bloom_bits_per_key);
	ret.append(buffer);
	snprintf(buffer, kBufferSize, " hash_table_ratio: %lf\n",
	table_options_.hash_table_ratio);
	ret.append(buffer);
	snprintf(buffer, kBufferSize, " index_sparseness: %" ROCKSDB_PRIszt "\n",
	table_options_.index_sparseness);
	ret.append(buffer);
	snprintf(buffer, kBufferSize, " huge_page_tlb_size: %" ROCKSDB_PRIszt "\n",
	table_options_.huge_page_tlb_size);
	ret.append(buffer);
	snprintf(buffer, kBufferSize, " encoding_type: %d\n",
	table_options_.encoding_type);
	ret.append(buffer);
	snprintf(buffer, kBufferSize, " full_scan_mode: %d\n",
	table_options_.full_scan_mode);
	ret.append(buffer);
	snprintf(buffer, kBufferSize, " store_index_in_file: %d\n",
	table_options_.store_index_in_file);
	ret.append(buffer);
	return ret;
	}

	const PlainTableOptions& PlainTableFactory::table_options() const {
	return table_options_;
	}

	Status GetPlainTableOptionsFromString(const PlainTableOptions& table_options,
	const std::string& opts_str,
	PlainTableOptions* new_table_options) {
	std::unordered_map<std::string, std::string> opts_map;
	Status s = StringToMap(opts_str, &opts_map);
	if (!s.ok()) {
	return s;
	}
	return GetPlainTableOptionsFromMap(table_options, opts_map,
	new_table_options);
	}

	Status GetMemTableRepFactoryFromString(
	const std::string& opts_str,
	std::unique_ptr<MemTableRepFactory>* new_mem_factory) {
	std::vector<std::string> opts_list = StringSplit(opts_str, ':');
	size_t len = opts_list.size();

	if (opts_list.size() <= 0 \|\| opts_list.size() > 2) {
	return Status::InvalidArgument("Can't parse memtable_factory option ",
	opts_str);
	}

	MemTableRepFactory* mem_factory = nullptr;

	if (opts_list[0] == "skip_list") {
	// Expecting format
	// skip_list:<lookahead>
	if (2 == len) {
	size_t lookahead = ParseSizeT(opts_list[1]);
	mem_factory = new SkipListFactory(lookahead);
	} else if (1 == len) {
	mem_factory = new SkipListFactory();
	}
	} else if (opts_list[0] == "prefix_hash") {
	// Expecting format
	// prfix_hash:<hash_bucket_count>
	if (2 == len) {
	size_t hash_bucket_count = ParseSizeT(opts_list[1]);
	mem_factory = NewHashSkipListRepFactory(hash_bucket_count);
	} else if (1 == len) {
	mem_factory = NewHashSkipListRepFactory();
	}
	} else if (opts_list[0] == "hash_linkedlist") {
	// Expecting format
	// hash_linkedlist:<hash_bucket_count>
	if (2 == len) {
	size_t hash_bucket_count = ParseSizeT(opts_list[1]);
	mem_factory = NewHashLinkListRepFactory(hash_bucket_count);
	} else if (1 == len) {
	mem_factory = NewHashLinkListRepFactory();
	}
	} else if (opts_list[0] == "vector") {
	// Expecting format
	// vector:<count>
	if (2 == len) {
	size_t count = ParseSizeT(opts_list[1]);
	mem_factory = new VectorRepFactory(count);
	} else if (1 == len) {
	mem_factory = new VectorRepFactory();
	}
	} else if (opts_list[0] == "cuckoo") {
	// Expecting format
	// cuckoo:<write_buffer_size>
	if (2 == len) {
	size_t write_buffer_size = ParseSizeT(opts_list[1]);
	mem_factory = NewHashCuckooRepFactory(write_buffer_size);
	} else if (1 == len) {
	return Status::InvalidArgument("Can't parse memtable_factory option ",
	opts_str);
	}
	} else {
	return Status::InvalidArgument("Unrecognized memtable_factory option ",
	opts_str);
	}

	if (mem_factory != nullptr) {
	new_mem_factory->reset(mem_factory);
	}

	return Status::OK();
	}

	std::string ParsePlainTableOptions(const std::string& name,
	const std::string& org_value,
	PlainTableOptions* new_options,
	bool input_strings_escaped = false,
	bool ignore_unknown_options = false) {
	const std::string& value =
	input_strings_escaped ? UnescapeOptionString(org_value) : org_value;
	const auto iter = plain_table_type_info.find(name);
	if (iter == plain_table_type_info.end()) {
	if (ignore_unknown_options) {
	return "";
	} else {
	return "Unrecognized option";
	}
	}
	const auto& opt_info = iter->second;
	if (opt_info.verification != OptionVerificationType::kDeprecated &&
	!ParseOptionHelper(reinterpret_cast<char*>(new_options) + opt_info.offset,
	opt_info.type, value)) {
	return "Invalid value";
	}
	return "";
	}

	Status GetPlainTableOptionsFromMap(
	const PlainTableOptions& table_options,
	const std::unordered_map<std::string, std::string>& opts_map,
	PlainTableOptions* new_table_options, bool input_strings_escaped,
	bool ignore_unknown_options) {
	assert(new_table_options);
	*new_table_options = table_options;
	for (const auto& o : opts_map) {
	auto error_message = ParsePlainTableOptions(
	o.first, o.second, new_table_options, input_strings_escaped);
	if (error_message != "") {
	const auto iter = plain_table_type_info.find(o.first);
	if (iter == plain_table_type_info.end() \|\|
	!input_strings_escaped \|\| // !input_strings_escaped indicates
	// the old API, where everything is
	// parsable.
	(iter->second.verification != OptionVerificationType::kByName &&
	iter->second.verification !=
	OptionVerificationType::kByNameAllowNull &&
	iter->second.verification != OptionVerificationType::kDeprecated)) {
	// Restore "new_options" to the default "base_options".
	*new_table_options = table_options;
	return Status::InvalidArgument("Can't parse PlainTableOptions:",
	o.first + " " + error_message);
	}
	}
	}
	return Status::OK();
	}

	extern TableFactory* NewPlainTableFactory(const PlainTableOptions& options) {
	return new PlainTableFactory(options);
	}

	const std::string PlainTablePropertyNames::kEncodingType =
	"rocksdb.plain.table.encoding.type";

	const std::string PlainTablePropertyNames::kBloomVersion =
	"rocksdb.plain.table.bloom.version";

	const std::string PlainTablePropertyNames::kNumBloomBlocks =
	"rocksdb.plain.table.bloom.numblocks";

	} // namespace rocksdb
	#endif // ROCKSDB_LITE