ceph/src/rocksdb/table/adaptive_table_factory.cc

   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