1 // Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
2 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file. See the AUTHORS file for names of contributors.
5
6 #ifndef ROCKSDB_LITE
7 #include "table/adaptive/adaptive_table_factory.h"
8
9 #include "table/table_builder.h"
10 #include "table/format.h"
11 #include "port/port.h"
12
13 namespace ROCKSDB_NAMESPACE {
14
AdaptiveTableFactory(std::shared_ptr<TableFactory> table_factory_to_write,std::shared_ptr<TableFactory> block_based_table_factory,std::shared_ptr<TableFactory> plain_table_factory,std::shared_ptr<TableFactory> cuckoo_table_factory)15 AdaptiveTableFactory::AdaptiveTableFactory(
16 std::shared_ptr<TableFactory> table_factory_to_write,
17 std::shared_ptr<TableFactory> block_based_table_factory,
18 std::shared_ptr<TableFactory> plain_table_factory,
19 std::shared_ptr<TableFactory> cuckoo_table_factory)
20 : table_factory_to_write_(table_factory_to_write),
21 block_based_table_factory_(block_based_table_factory),
22 plain_table_factory_(plain_table_factory),
23 cuckoo_table_factory_(cuckoo_table_factory) {
24 if (!plain_table_factory_) {
25 plain_table_factory_.reset(NewPlainTableFactory());
26 }
27 if (!block_based_table_factory_) {
28 block_based_table_factory_.reset(NewBlockBasedTableFactory());
29 }
30 if (!cuckoo_table_factory_) {
31 cuckoo_table_factory_.reset(NewCuckooTableFactory());
32 }
33 if (!table_factory_to_write_) {
34 table_factory_to_write_ = block_based_table_factory_;
35 }
36 }
37
38 extern const uint64_t kPlainTableMagicNumber;
39 extern const uint64_t kLegacyPlainTableMagicNumber;
40 extern const uint64_t kBlockBasedTableMagicNumber;
41 extern const uint64_t kLegacyBlockBasedTableMagicNumber;
42 extern const uint64_t kCuckooTableMagicNumber;
43
NewTableReader(const TableReaderOptions & table_reader_options,std::unique_ptr<RandomAccessFileReader> && file,uint64_t file_size,std::unique_ptr<TableReader> * table,bool) const44 Status AdaptiveTableFactory::NewTableReader(
45 const TableReaderOptions& table_reader_options,
46 std::unique_ptr<RandomAccessFileReader>&& file, uint64_t file_size,
47 std::unique_ptr<TableReader>* table,
48 bool /*prefetch_index_and_filter_in_cache*/) const {
49 Footer footer;
50 auto s = ReadFooterFromFile(file.get(), nullptr /* prefetch_buffer */,
51 file_size, &footer);
52 if (!s.ok()) {
53 return s;
54 }
55 if (footer.table_magic_number() == kPlainTableMagicNumber ||
56 footer.table_magic_number() == kLegacyPlainTableMagicNumber) {
57 return plain_table_factory_->NewTableReader(
58 table_reader_options, std::move(file), file_size, table);
59 } else if (footer.table_magic_number() == kBlockBasedTableMagicNumber ||
60 footer.table_magic_number() == kLegacyBlockBasedTableMagicNumber) {
61 return block_based_table_factory_->NewTableReader(
62 table_reader_options, std::move(file), file_size, table);
63 } else if (footer.table_magic_number() == kCuckooTableMagicNumber) {
64 return cuckoo_table_factory_->NewTableReader(
65 table_reader_options, std::move(file), file_size, table);
66 } else {
67 return Status::NotSupported("Unidentified table format");
68 }
69 }
70
NewTableBuilder(const TableBuilderOptions & table_builder_options,uint32_t column_family_id,WritableFileWriter * file) const71 TableBuilder* AdaptiveTableFactory::NewTableBuilder(
72 const TableBuilderOptions& table_builder_options, uint32_t column_family_id,
73 WritableFileWriter* file) const {
74 return table_factory_to_write_->NewTableBuilder(table_builder_options,
75 column_family_id, file);
76 }
77
GetPrintableTableOptions() const78 std::string AdaptiveTableFactory::GetPrintableTableOptions() const {
79 std::string ret;
80 ret.reserve(20000);
81 const int kBufferSize = 200;
82 char buffer[kBufferSize];
83
84 if (table_factory_to_write_) {
85 snprintf(buffer, kBufferSize, " write factory (%s) options:\n%s\n",
86 (table_factory_to_write_->Name() ? table_factory_to_write_->Name()
87 : ""),
88 table_factory_to_write_->GetPrintableTableOptions().c_str());
89 ret.append(buffer);
90 }
91 if (plain_table_factory_) {
92 snprintf(buffer, kBufferSize, " %s options:\n%s\n",
93 plain_table_factory_->Name() ? plain_table_factory_->Name() : "",
94 plain_table_factory_->GetPrintableTableOptions().c_str());
95 ret.append(buffer);
96 }
97 if (block_based_table_factory_) {
98 snprintf(
99 buffer, kBufferSize, " %s options:\n%s\n",
100 (block_based_table_factory_->Name() ? block_based_table_factory_->Name()
101 : ""),
102 block_based_table_factory_->GetPrintableTableOptions().c_str());
103 ret.append(buffer);
104 }
105 if (cuckoo_table_factory_) {
106 snprintf(buffer, kBufferSize, " %s options:\n%s\n",
107 cuckoo_table_factory_->Name() ? cuckoo_table_factory_->Name() : "",
108 cuckoo_table_factory_->GetPrintableTableOptions().c_str());
109 ret.append(buffer);
110 }
111 return ret;
112 }
113
NewAdaptiveTableFactory(std::shared_ptr<TableFactory> table_factory_to_write,std::shared_ptr<TableFactory> block_based_table_factory,std::shared_ptr<TableFactory> plain_table_factory,std::shared_ptr<TableFactory> cuckoo_table_factory)114 extern TableFactory* NewAdaptiveTableFactory(
115 std::shared_ptr<TableFactory> table_factory_to_write,
116 std::shared_ptr<TableFactory> block_based_table_factory,
117 std::shared_ptr<TableFactory> plain_table_factory,
118 std::shared_ptr<TableFactory> cuckoo_table_factory) {
119 return new AdaptiveTableFactory(table_factory_to_write,
120 block_based_table_factory, plain_table_factory, cuckoo_table_factory);
121 }
122
123 } // namespace ROCKSDB_NAMESPACE
124 #endif // ROCKSDB_LITE
125