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