ceph/src/rocksdb/table/adaptive/adaptive_table_factory.cc

   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
  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
  44 Status AdaptiveTableFactory::NewTableReader(
  45     const ReadOptions& ro, 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   IOOptions opts;
  51   auto s = ReadFooterFromFile(opts, file.get(), nullptr /* prefetch_buffer */,
  52                               file_size, &footer);
  53   if (!s.ok()) {
  54     return s;
  55   }
  56   if (footer.table_magic_number() == kPlainTableMagicNumber ||
  57       footer.table_magic_number() == kLegacyPlainTableMagicNumber) {
  58     return plain_table_factory_->NewTableReader(
  59         table_reader_options, std::move(file), file_size, table);
  60   } else if (footer.table_magic_number() == kBlockBasedTableMagicNumber ||
  61       footer.table_magic_number() == kLegacyBlockBasedTableMagicNumber) {
  62     return block_based_table_factory_->NewTableReader(
  63         ro, table_reader_options, std::move(file), file_size, table,
  64         prefetch_index_and_filter_in_cache);
  65   } else if (footer.table_magic_number() == kCuckooTableMagicNumber) {
  66     return cuckoo_table_factory_->NewTableReader(
  67         table_reader_options, std::move(file), file_size, table);
  68   } else {
  69     return Status::NotSupported("Unidentified table format");
  70   }
  71 }
  72
  73 TableBuilder* AdaptiveTableFactory::NewTableBuilder(
  74     const TableBuilderOptions& table_builder_options, uint32_t column_family_id,
  75     WritableFileWriter* file) const {
  76   return table_factory_to_write_->NewTableBuilder(table_builder_options,
  77                                                   column_family_id, file);
  78 }
  79
  80 std::string AdaptiveTableFactory::GetPrintableOptions() const {
  81   std::string ret;
  82   ret.reserve(20000);
  83   const int kBufferSize = 200;
  84   char buffer[kBufferSize];
  85
  86   if (table_factory_to_write_) {
  87     snprintf(buffer, kBufferSize, "  write factory (%s) options:\n%s\n",
  88              (table_factory_to_write_->Name() ? table_factory_to_write_->Name()
  89                                               : ""),
  90              table_factory_to_write_->GetPrintableOptions().c_str());
  91     ret.append(buffer);
  92   }
  93   if (plain_table_factory_) {
  94     snprintf(buffer, kBufferSize, "  %s options:\n%s\n",
  95              plain_table_factory_->Name() ? plain_table_factory_->Name() : "",
  96              plain_table_factory_->GetPrintableOptions().c_str());
  97     ret.append(buffer);
  98   }
  99   if (block_based_table_factory_) {
 100     snprintf(
 101         buffer, kBufferSize, "  %s options:\n%s\n",
 102         (block_based_table_factory_->Name() ? block_based_table_factory_->Name()
 103                                             : ""),
 104         block_based_table_factory_->GetPrintableOptions().c_str());
 105     ret.append(buffer);
 106   }
 107   if (cuckoo_table_factory_) {
 108     snprintf(buffer, kBufferSize, "  %s options:\n%s\n",
 109              cuckoo_table_factory_->Name() ? cuckoo_table_factory_->Name() : "",
 110              cuckoo_table_factory_->GetPrintableOptions().c_str());
 111     ret.append(buffer);
 112   }
 113   return ret;
 114 }
 115
 116 extern TableFactory* NewAdaptiveTableFactory(
 117     std::shared_ptr<TableFactory> table_factory_to_write,
 118     std::shared_ptr<TableFactory> block_based_table_factory,
 119     std::shared_ptr<TableFactory> plain_table_factory,
 120     std::shared_ptr<TableFactory> cuckoo_table_factory) {
 121   return new AdaptiveTableFactory(table_factory_to_write,
 122       block_based_table_factory, plain_table_factory, cuckoo_table_factory);
 123 }
 124
 125 }  // namespace ROCKSDB_NAMESPACE
 126 #endif  // ROCKSDB_LITE