2014-06-17 05:06:18 +02:00
|
|
|
// 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/adaptive_table_factory.h"
|
|
|
|
|
2015-09-11 20:36:33 +02:00
|
|
|
#include "table/table_builder.h"
|
2014-06-17 05:06:18 +02:00
|
|
|
#include "table/format.h"
|
2015-07-16 21:10:16 +02:00
|
|
|
#include "port/port.h"
|
2014-06-17 05:06:18 +02:00
|
|
|
|
|
|
|
namespace rocksdb {
|
|
|
|
|
|
|
|
AdaptiveTableFactory::AdaptiveTableFactory(
|
2014-06-18 07:04:37 +02:00
|
|
|
std::shared_ptr<TableFactory> table_factory_to_write,
|
2014-06-17 05:06:18 +02:00
|
|
|
std::shared_ptr<TableFactory> block_based_table_factory,
|
2014-08-12 05:21:07 +02:00
|
|
|
std::shared_ptr<TableFactory> plain_table_factory,
|
|
|
|
std::shared_ptr<TableFactory> cuckoo_table_factory)
|
2014-06-18 07:04:37 +02:00
|
|
|
: table_factory_to_write_(table_factory_to_write),
|
|
|
|
block_based_table_factory_(block_based_table_factory),
|
2014-08-12 05:21:07 +02:00
|
|
|
plain_table_factory_(plain_table_factory),
|
|
|
|
cuckoo_table_factory_(cuckoo_table_factory) {
|
2014-06-17 05:06:18 +02:00
|
|
|
if (!plain_table_factory_) {
|
|
|
|
plain_table_factory_.reset(NewPlainTableFactory());
|
|
|
|
}
|
|
|
|
if (!block_based_table_factory_) {
|
|
|
|
block_based_table_factory_.reset(NewBlockBasedTableFactory());
|
|
|
|
}
|
2014-08-12 05:21:07 +02:00
|
|
|
if (!cuckoo_table_factory_) {
|
|
|
|
cuckoo_table_factory_.reset(NewCuckooTableFactory());
|
|
|
|
}
|
2016-09-20 19:11:51 +02:00
|
|
|
if (!table_factory_to_write_) {
|
|
|
|
table_factory_to_write_ = block_based_table_factory_;
|
|
|
|
}
|
2014-06-17 05:06:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
extern const uint64_t kPlainTableMagicNumber;
|
|
|
|
extern const uint64_t kLegacyPlainTableMagicNumber;
|
|
|
|
extern const uint64_t kBlockBasedTableMagicNumber;
|
|
|
|
extern const uint64_t kLegacyBlockBasedTableMagicNumber;
|
2014-08-12 05:21:07 +02:00
|
|
|
extern const uint64_t kCuckooTableMagicNumber;
|
2014-06-17 05:06:18 +02:00
|
|
|
|
|
|
|
Status AdaptiveTableFactory::NewTableReader(
|
2015-09-11 20:36:33 +02:00
|
|
|
const TableReaderOptions& table_reader_options,
|
2018-11-09 20:17:34 +01:00
|
|
|
std::unique_ptr<RandomAccessFileReader>&& file, uint64_t file_size,
|
|
|
|
std::unique_ptr<TableReader>* table,
|
2018-03-05 22:08:17 +01:00
|
|
|
bool /*prefetch_index_and_filter_in_cache*/) const {
|
2014-06-17 05:06:18 +02:00
|
|
|
Footer footer;
|
2017-08-11 20:59:13 +02:00
|
|
|
auto s = ReadFooterFromFile(file.get(), nullptr /* prefetch_buffer */,
|
|
|
|
file_size, &footer);
|
2014-06-17 05:06:18 +02:00
|
|
|
if (!s.ok()) {
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
if (footer.table_magic_number() == kPlainTableMagicNumber ||
|
|
|
|
footer.table_magic_number() == kLegacyPlainTableMagicNumber) {
|
|
|
|
return plain_table_factory_->NewTableReader(
|
2015-09-11 20:36:33 +02:00
|
|
|
table_reader_options, std::move(file), file_size, table);
|
2014-06-17 05:06:18 +02:00
|
|
|
} else if (footer.table_magic_number() == kBlockBasedTableMagicNumber ||
|
|
|
|
footer.table_magic_number() == kLegacyBlockBasedTableMagicNumber) {
|
|
|
|
return block_based_table_factory_->NewTableReader(
|
2015-09-11 20:36:33 +02:00
|
|
|
table_reader_options, std::move(file), file_size, table);
|
2014-08-12 05:21:07 +02:00
|
|
|
} else if (footer.table_magic_number() == kCuckooTableMagicNumber) {
|
|
|
|
return cuckoo_table_factory_->NewTableReader(
|
2015-09-11 20:36:33 +02:00
|
|
|
table_reader_options, std::move(file), file_size, table);
|
2014-06-17 05:06:18 +02:00
|
|
|
} else {
|
|
|
|
return Status::NotSupported("Unidentified table format");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
TableBuilder* AdaptiveTableFactory::NewTableBuilder(
|
2015-10-09 01:57:35 +02:00
|
|
|
const TableBuilderOptions& table_builder_options, uint32_t column_family_id,
|
Move rate_limiter, write buffering, most perf context instrumentation and most random kill out of Env
Summary: We want to keep Env a think layer for better portability. Less platform dependent codes should be moved out of Env. In this patch, I create a wrapper of file readers and writers, and put rate limiting, write buffering, as well as most perf context instrumentation and random kill out of Env. It will make it easier to maintain multiple Env in the future.
Test Plan: Run all existing unit tests.
Reviewers: anthony, kradhakrishnan, IslamAbdelRahman, yhchiang, igor
Reviewed By: igor
Subscribers: leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D42321
2015-07-18 01:16:11 +02:00
|
|
|
WritableFileWriter* file) const {
|
2015-10-09 01:57:35 +02:00
|
|
|
return table_factory_to_write_->NewTableBuilder(table_builder_options,
|
|
|
|
column_family_id, file);
|
2014-06-17 05:06:18 +02:00
|
|
|
}
|
|
|
|
|
2014-08-25 23:24:09 +02:00
|
|
|
std::string AdaptiveTableFactory::GetPrintableTableOptions() const {
|
|
|
|
std::string ret;
|
|
|
|
ret.reserve(20000);
|
|
|
|
const int kBufferSize = 200;
|
|
|
|
char buffer[kBufferSize];
|
|
|
|
|
2016-04-19 22:57:05 +02:00
|
|
|
if (table_factory_to_write_) {
|
2014-08-25 23:24:09 +02:00
|
|
|
snprintf(buffer, kBufferSize, " write factory (%s) options:\n%s\n",
|
2016-04-25 15:27:27 +02:00
|
|
|
(table_factory_to_write_->Name() ? table_factory_to_write_->Name()
|
|
|
|
: ""),
|
2014-08-25 23:24:09 +02:00
|
|
|
table_factory_to_write_->GetPrintableTableOptions().c_str());
|
|
|
|
ret.append(buffer);
|
|
|
|
}
|
2016-04-19 22:57:05 +02:00
|
|
|
if (plain_table_factory_) {
|
2014-08-25 23:24:09 +02:00
|
|
|
snprintf(buffer, kBufferSize, " %s options:\n%s\n",
|
2016-04-25 15:27:27 +02:00
|
|
|
plain_table_factory_->Name() ? plain_table_factory_->Name() : "",
|
2014-08-25 23:24:09 +02:00
|
|
|
plain_table_factory_->GetPrintableTableOptions().c_str());
|
|
|
|
ret.append(buffer);
|
|
|
|
}
|
2016-04-19 22:57:05 +02:00
|
|
|
if (block_based_table_factory_) {
|
2016-04-25 15:27:27 +02:00
|
|
|
snprintf(
|
|
|
|
buffer, kBufferSize, " %s options:\n%s\n",
|
|
|
|
(block_based_table_factory_->Name() ? block_based_table_factory_->Name()
|
|
|
|
: ""),
|
|
|
|
block_based_table_factory_->GetPrintableTableOptions().c_str());
|
2014-08-25 23:24:09 +02:00
|
|
|
ret.append(buffer);
|
|
|
|
}
|
2016-04-19 22:57:05 +02:00
|
|
|
if (cuckoo_table_factory_) {
|
2014-08-25 23:24:09 +02:00
|
|
|
snprintf(buffer, kBufferSize, " %s options:\n%s\n",
|
2016-04-25 15:27:27 +02:00
|
|
|
cuckoo_table_factory_->Name() ? cuckoo_table_factory_->Name() : "",
|
2014-08-25 23:24:09 +02:00
|
|
|
cuckoo_table_factory_->GetPrintableTableOptions().c_str());
|
|
|
|
ret.append(buffer);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-06-17 05:06:18 +02:00
|
|
|
extern TableFactory* NewAdaptiveTableFactory(
|
2014-06-18 07:04:37 +02:00
|
|
|
std::shared_ptr<TableFactory> table_factory_to_write,
|
2014-06-17 05:06:18 +02:00
|
|
|
std::shared_ptr<TableFactory> block_based_table_factory,
|
2014-08-12 05:21:07 +02:00
|
|
|
std::shared_ptr<TableFactory> plain_table_factory,
|
|
|
|
std::shared_ptr<TableFactory> cuckoo_table_factory) {
|
|
|
|
return new AdaptiveTableFactory(table_factory_to_write,
|
|
|
|
block_based_table_factory, plain_table_factory, cuckoo_table_factory);
|
2014-06-17 05:06:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace rocksdb
|
|
|
|
#endif // ROCKSDB_LITE
|