@nxtedition/rocksdb 8.1.7 → 8.1.8

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader.cc

@@ -576,15 +576,13 @@ Status BlockBasedTable::Open(
   Footer footer;
   std::unique_ptr<FilePrefetchBuffer> prefetch_buffer;
 
-  // From read_options, retain deadline, io_timeout, and rate_limiter_priority.
-  // In future, we may retain more
-  // options. Specifically, we ignore verify_checksums and default to
-  // checksum verification anyway when creating the index and filter
-  // readers.
+  // From read_options, retain deadline, io_timeout, rate_limiter_priority, and
+  // verify_checksums. In future, we may retain more options.
   ReadOptions ro;
   ro.deadline = read_options.deadline;
   ro.io_timeout = read_options.io_timeout;
   ro.rate_limiter_priority = read_options.rate_limiter_priority;
+  ro.verify_checksums = read_options.verify_checksums;
 
   // prefetch both index and filters, down to all partitions
   const bool prefetch_all = prefetch_index_and_filter_in_cache || level == 0;
@@ -734,7 +732,6 @@ Status BlockBasedTable::Open(
     rep->table_prefix_extractor = prefix_extractor;
   } else {
     // Current prefix_extractor doesn't match table
-#ifndef ROCKSDB_LITE
     if (rep->table_properties) {
       //**TODO: If/When the DBOptions has a registry in it, the ConfigOptions
       // will need to use it
@@ -750,7 +747,6 @@ Status BlockBasedTable::Open(
                         st.ToString().c_str());
       }
     }
-#endif  // ROCKSDB_LITE
   }
 
   // With properties loaded, we can set up portable/stable cache keys
@@ -1257,10 +1253,7 @@ Status BlockBasedTable::ReadMetaIndexBlock(
 template <typename TBlocklike>
 WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::GetDataBlockFromCache(
     const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
-    CompressedBlockCacheInterface block_cache_compressed,
-    const ReadOptions& read_options,
-    CachableEntry<TBlocklike>* out_parsed_block,
-    const UncompressionDict& uncompression_dict, const bool wait,
+    CachableEntry<TBlocklike>* out_parsed_block, const bool wait,
     GetContext* get_context) const {
   assert(out_parsed_block);
   assert(out_parsed_block->IsEmpty());
@@ -1306,73 +1299,12 @@ WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::GetDataBlockFromCache(
   // If not found, search from the compressed block cache.
   assert(out_parsed_block->IsEmpty());
 
-  if (!block_cache_compressed) {
-    return s;
-  }
-
-  assert(!cache_key.empty());
-  BlockContents contents;
-  auto block_cache_compressed_handle =
-      block_cache_compressed.Lookup(cache_key, statistics);
-
-  // if we found in the compressed cache, then uncompress and insert into
-  // uncompressed cache
-  if (block_cache_compressed_handle == nullptr) {
-    RecordTick(statistics, BLOCK_CACHE_COMPRESSED_MISS);
-    return s;
-  }
-
-  // found compressed block
-  RecordTick(statistics, BLOCK_CACHE_COMPRESSED_HIT);
-  BlockContents* compressed_block =
-      block_cache_compressed.Value(block_cache_compressed_handle);
-  CompressionType compression_type = GetBlockCompressionType(*compressed_block);
-  assert(compression_type != kNoCompression);
-
-  // Retrieve the uncompressed contents into a new buffer
-  UncompressionContext context(compression_type);
-  UncompressionInfo info(context, uncompression_dict, compression_type);
-  s = UncompressSerializedBlock(
-      info, compressed_block->data.data(), compressed_block->data.size(),
-      &contents, rep_->table_options.format_version, rep_->ioptions,
-      GetMemoryAllocator(rep_->table_options));
-
-  // Insert parsed block into block cache, the priority is based on the
-  // data block type.
-  if (s.ok()) {
-    std::unique_ptr<TBlocklike> block_holder;
-    rep_->create_context.Create(&block_holder, std::move(contents));
-
-    if (block_cache && block_holder->own_bytes() && read_options.fill_cache) {
-      size_t charge = block_holder->ApproximateMemoryUsage();
-      BlockCacheTypedHandle<TBlocklike>* cache_handle = nullptr;
-      s = block_cache.InsertFull(cache_key, block_holder.get(), charge,
-                                 &cache_handle, priority,
-                                 rep_->ioptions.lowest_used_cache_tier);
-      if (s.ok()) {
-        assert(cache_handle != nullptr);
-        out_parsed_block->SetCachedValue(block_holder.release(),
-                                         block_cache.get(), cache_handle);
-
-        UpdateCacheInsertionMetrics(TBlocklike::kBlockType, get_context, charge,
-                                    s.IsOkOverwritten(), rep_->ioptions.stats);
-      } else {
-        RecordTick(statistics, BLOCK_CACHE_ADD_FAILURES);
-      }
-    } else {
-      out_parsed_block->SetOwnedValue(std::move(block_holder));
-    }
-  }
-
-  // Release hold on compressed cache entry
-  block_cache_compressed.Release(block_cache_compressed_handle);
   return s;
 }
 
 template <typename TBlocklike>
 WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::PutDataBlockToCache(
     const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
-    CompressedBlockCacheInterface block_cache_compressed,
     CachableEntry<TBlocklike>* out_parsed_block, BlockContents&& block_contents,
     CompressionType block_comp_type,
     const UncompressionDict& uncompression_dict,
@@ -1409,32 +1341,6 @@ WithBlocklikeCheck<Status, TBlocklike> BlockBasedTable::PutDataBlockToCache(
     rep_->create_context.Create(&block_holder, std::move(block_contents));
   }
 
-  // Insert compressed block into compressed block cache.
-  // Release the hold on the compressed cache entry immediately.
-  if (block_cache_compressed && block_comp_type != kNoCompression &&
-      block_contents.own_bytes()) {
-    assert(block_contents.has_trailer);
-    assert(!cache_key.empty());
-
-    // We cannot directly put block_contents because this could point to
-    // an object in the stack.
-    auto block_cont_for_comp_cache =
-        std::make_unique<BlockContents>(std::move(block_contents));
-    size_t charge = block_cont_for_comp_cache->ApproximateMemoryUsage();
-
-    s = block_cache_compressed.Insert(cache_key,
-                                      block_cont_for_comp_cache.get(), charge,
-                                      nullptr /*handle*/, Cache::Priority::LOW);
-
-    if (s.ok()) {
-      // Cache took ownership
-      block_cont_for_comp_cache.release();
-      RecordTick(statistics, BLOCK_CACHE_COMPRESSED_ADD);
-    } else {
-      RecordTick(statistics, BLOCK_CACHE_COMPRESSED_ADD_FAILURES);
-    }
-  }
-
   // insert into uncompressed block cache
   if (block_cache && block_holder->own_bytes()) {
     size_t charge = block_holder->ApproximateMemoryUsage();
@@ -1545,8 +1451,6 @@ BlockBasedTable::MaybeReadBlockAndLoadToCache(
   const bool no_io = (ro.read_tier == kBlockCacheTier);
   BlockCacheInterface<TBlocklike> block_cache{
       rep_->table_options.block_cache.get()};
-  CompressedBlockCacheInterface block_cache_compressed{
-      rep_->table_options.block_cache_compressed.get()};
 
   // First, try to get the block from the cache
   //
@@ -1555,14 +1459,13 @@ BlockBasedTable::MaybeReadBlockAndLoadToCache(
   CacheKey key_data;
   Slice key;
   bool is_cache_hit = false;
-  if (block_cache || block_cache_compressed) {
+  if (block_cache) {
     // create key for block cache
     key_data = GetCacheKey(rep_->base_cache_key, handle);
     key = key_data.AsSlice();
 
     if (!contents) {
-      s = GetDataBlockFromCache(key, block_cache, block_cache_compressed, ro,
-                                out_parsed_block, uncompression_dict, wait,
+      s = GetDataBlockFromCache(key, block_cache, out_parsed_block, wait,
                                 get_context);
       // Value could still be null at this point, so check the cache handle
       // and update the read pattern for prefetching
@@ -1591,7 +1494,7 @@ BlockBasedTable::MaybeReadBlockAndLoadToCache(
           TBlocklike::kBlockType != BlockType::kFilter &&
           TBlocklike::kBlockType != BlockType::kCompressionDictionary &&
           rep_->blocks_maybe_compressed;
-      const bool do_uncompress = maybe_compressed && !block_cache_compressed;
+      const bool do_uncompress = maybe_compressed;
       CompressionType contents_comp_type;
       // Maybe serialized or uncompressed
       BlockContents tmp_contents;
@@ -1605,7 +1508,7 @@ BlockBasedTable::MaybeReadBlockAndLoadToCache(
             TBlocklike::kBlockType, uncompression_dict,
             rep_->persistent_cache_options,
             GetMemoryAllocator(rep_->table_options),
-            GetMemoryAllocatorForCompressedBlock(rep_->table_options));
+            /*allocator=*/nullptr);
 
         // If prefetch_buffer is not allocated, it will fallback to synchronous
         // reading of block contents.
@@ -1641,8 +1544,8 @@ BlockBasedTable::MaybeReadBlockAndLoadToCache(
         // If filling cache is allowed and a cache is configured, try to put the
         // block to the cache.
         s = PutDataBlockToCache(
-            key, block_cache, block_cache_compressed, out_parsed_block,
-            std::move(*contents), contents_comp_type, uncompression_dict,
+            key, block_cache, out_parsed_block, std::move(*contents),
+            contents_comp_type, uncompression_dict,
             GetMemoryAllocator(rep_->table_options), get_context);
       }
     }
@@ -2026,6 +1929,16 @@ Status BlockBasedTable::ApproximateKeyAnchors(const ReadOptions& read_options,
   // likely not to be a problem. We are compacting the whole file, so all
   // keys will be read out anyway. An extra read to index block might be
   // a small share of the overhead. We can try to optimize if needed.
+  //
+  // `CacheDependencies()` brings all the blocks into cache using one I/O. That
+  // way the full index scan usually finds the index data it is looking for in
+  // cache rather than doing an I/O for each "dependency" (partition).
+  Status s =
+      rep_->index_reader->CacheDependencies(read_options, false /* pin */);
+  if (!s.ok()) {
+    return s;
+  }
+
   IndexBlockIter iiter_on_stack;
   auto iiter = NewIndexIterator(
       read_options, /*disable_prefix_seek=*/false, &iiter_on_stack,

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader.h

@@ -379,8 +379,7 @@ class BlockBasedTable : public TableReader {
       IndexBlockIter* input_iter, GetContext* get_context,
       BlockCacheLookupContext* lookup_context) const;
 
-  // Read block cache from block caches (if set): block_cache and
-  // block_cache_compressed.
+  // Read block cache from block caches (if set): block_cache.
   // On success, Status::OK with be returned and @block will be populated with
   // pointer to the block as well as its block handle.
   // @param uncompression_dict Data for presetting the compression library's
@@ -388,9 +387,7 @@ class BlockBasedTable : public TableReader {
   template <typename TBlocklike>
   WithBlocklikeCheck<Status, TBlocklike> GetDataBlockFromCache(
       const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
-      CompressedBlockCacheInterface block_cache_compressed,
-      const ReadOptions& read_options, CachableEntry<TBlocklike>* block,
-      const UncompressionDict& uncompression_dict, const bool wait,
+      CachableEntry<TBlocklike>* block, const bool wait,
       GetContext* get_context) const;
 
   // Put a maybe compressed block to the corresponding block caches.
@@ -406,7 +403,6 @@ class BlockBasedTable : public TableReader {
   template <typename TBlocklike>
   WithBlocklikeCheck<Status, TBlocklike> PutDataBlockToCache(
       const Slice& cache_key, BlockCacheInterface<TBlocklike> block_cache,
-      CompressedBlockCacheInterface block_cache_compressed,
       CachableEntry<TBlocklike>* cached_block, BlockContents&& block_contents,
       CompressionType block_comp_type,
       const UncompressionDict& uncompression_dict,

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_sync_and_async.h

@@ -244,9 +244,7 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
       // heap buffer or there is no cache at all.
       CompressionType compression_type =
           GetBlockCompressionType(serialized_block);
-      if (use_shared_buffer && (compression_type == kNoCompression ||
-                                (compression_type != kNoCompression &&
-                                 rep_->table_options.block_cache_compressed))) {
+      if (use_shared_buffer && compression_type == kNoCompression) {
         Slice serialized =
             Slice(req.result.data() + req_offset, BlockSizeWithTrailer(handle));
         serialized_block = BlockContents(
@@ -523,7 +521,6 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::MultiGet)
         // 3. If blocks are compressed and no compressed block cache, use
         //    stack buf
         if (!rep_->file->use_direct_io() &&
-            rep_->table_options.block_cache_compressed == nullptr &&
             rep_->blocks_maybe_compressed) {
           if (total_len <= kMultiGetReadStackBufSize) {
             scratch = stack_buf;

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_test.cc

@@ -253,7 +253,7 @@ TEST_P(BlockBasedTableReaderTest, MultiGet) {
                              nullptr, nullptr, nullptr, nullptr,
                              true /* do_merge */, nullptr, nullptr, nullptr,
                              nullptr, nullptr, nullptr);
-    key_context.emplace_back(nullptr, keys[i], &values[i], nullptr,
+    key_context.emplace_back(nullptr, keys[i], &values[i], nullptr, nullptr,
                              &statuses.back());
     key_context.back().get_context = &get_context.back();
   }
@@ -537,23 +537,12 @@ TEST_P(BlockBasedTableReaderTestVerifyChecksum, ChecksumMismatch) {
 // Param 2: whether to use direct reads
 // Param 3: Block Based Table Index type
 // Param 4: BBTO no_block_cache option
-#ifdef ROCKSDB_LITE
-// Skip direct I/O tests in lite mode since direct I/O is unsupported.
-INSTANTIATE_TEST_CASE_P(
-    MultiGet, BlockBasedTableReaderTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(GetSupportedCompressions()),
-        ::testing::Values(false),
-        ::testing::Values(BlockBasedTableOptions::IndexType::kBinarySearch),
-        ::testing::Values(false)));
-#else   // ROCKSDB_LITE
 INSTANTIATE_TEST_CASE_P(
     MultiGet, BlockBasedTableReaderTest,
     ::testing::Combine(
         ::testing::ValuesIn(GetSupportedCompressions()), ::testing::Bool(),
         ::testing::Values(BlockBasedTableOptions::IndexType::kBinarySearch),
         ::testing::Values(false)));
-#endif  // ROCKSDB_LITE
 INSTANTIATE_TEST_CASE_P(
     VerifyChecksum, BlockBasedTableReaderTestVerifyChecksum,
     ::testing::Combine(

package/deps/rocksdb/rocksdb/table/block_based/block_cache.h

@@ -103,10 +103,6 @@ struct BlockCreateContext : public Cache::CreateContext {
               BlockContents&& block);
 };
 
-// Convenient cache interface to use with block_cache_compressed
-using CompressedBlockCacheInterface =
-    BasicTypedCacheInterface<BlockContents, CacheEntryRole::kOtherBlock>;
-
 // Convenient cache interface to use for block_cache, with support for
 // SecondaryCache.
 template <typename TBlocklike>

package/deps/rocksdb/rocksdb/table/block_based/cachable_entry.h

@@ -13,7 +13,7 @@
 #include <type_traits>
 
 #include "port/likely.h"
-#include "rocksdb/cache.h"
+#include "rocksdb/advanced_cache.h"
 #include "rocksdb/cleanable.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/table/block_based/data_block_hash_index.h

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <string>
 #include <vector>
 

package/deps/rocksdb/rocksdb/table/block_based/filter_policy.cc

@@ -1809,7 +1809,6 @@ std::shared_ptr<const FilterPolicy> BloomLikeFilterPolicy::Create(
   }
 }
 
-#ifndef ROCKSDB_LITE
 namespace {
 static ObjectLibrary::PatternEntry FilterPatternEntryWithBits(
     const char* name) {
@@ -1918,7 +1917,6 @@ static int RegisterBuiltinFilterPolicies(ObjectLibrary& library,
   return static_cast<int>(library.GetFactoryCount(&num_types));
 }
 }  // namespace
-#endif  // ROCKSDB_LITE
 
 Status FilterPolicy::CreateFromString(
     const ConfigOptions& options, const std::string& value,
@@ -1940,16 +1938,11 @@ Status FilterPolicy::CreateFromString(
   } else if (id.empty()) {  // We have no Id but have options.  Not good
     return Status::NotSupported("Cannot reset object ", id);
   } else {
-#ifndef ROCKSDB_LITE
     static std::once_flag loaded;
     std::call_once(loaded, [&]() {
       RegisterBuiltinFilterPolicies(*(ObjectLibrary::Default().get()), "");
     });
     status = options.registry->NewSharedObject(id, policy);
-#else
-    status =
-        Status::NotSupported("Cannot load filter policy in LITE mode ", value);
-#endif  // ROCKSDB_LITE
   }
   if (options.ignore_unsupported_options && status.IsNotSupported()) {
     return Status::OK();

package/deps/rocksdb/rocksdb/table/block_based/flush_block_policy.cc

@@ -89,7 +89,6 @@ FlushBlockPolicy* FlushBlockBySizePolicyFactory::NewFlushBlockPolicy(
   return new FlushBlockBySizePolicy(size, deviation, false, data_block_builder);
 }
 
-#ifndef ROCKSDB_LITE
 static int RegisterFlushBlockPolicyFactories(ObjectLibrary& library,
                                              const std::string& /*arg*/) {
   library.AddFactory<FlushBlockPolicyFactory>(
@@ -110,23 +109,6 @@ static int RegisterFlushBlockPolicyFactories(ObjectLibrary& library,
       });
   return 2;
 }
-#endif  // ROCKSDB_LITE
-
-static bool LoadFlushPolicyFactory(
-    const std::string& id, std::shared_ptr<FlushBlockPolicyFactory>* result) {
-  if (id.empty()) {
-    result->reset(new FlushBlockBySizePolicyFactory());
-#ifdef ROCKSDB_LITE
-  } else if (id == FlushBlockBySizePolicyFactory::kClassName()) {
-    result->reset(new FlushBlockBySizePolicyFactory());
-  } else if (id == FlushBlockEveryKeyPolicyFactory::kClassName()) {
-    result->reset(new FlushBlockEveryKeyPolicyFactory());
-#endif  // ROCKSDB_LITE
-  } else {
-    return false;
-  }
-  return true;
-}
 
 FlushBlockBySizePolicyFactory::FlushBlockBySizePolicyFactory()
     : FlushBlockPolicyFactory() {}
@@ -134,13 +116,17 @@ FlushBlockBySizePolicyFactory::FlushBlockBySizePolicyFactory()
 Status FlushBlockPolicyFactory::CreateFromString(
     const ConfigOptions& config_options, const std::string& value,
     std::shared_ptr<FlushBlockPolicyFactory>* factory) {
-#ifndef ROCKSDB_LITE
   static std::once_flag once;
   std::call_once(once, [&]() {
     RegisterFlushBlockPolicyFactories(*(ObjectLibrary::Default().get()), "");
   });
-#endif  // ROCKSDB_LITE
-  return LoadSharedObject<FlushBlockPolicyFactory>(
-      config_options, value, LoadFlushPolicyFactory, factory);
+
+  if (value.empty()) {
+    factory->reset(new FlushBlockBySizePolicyFactory());
+    return Status::OK();
+  } else {
+    return LoadSharedObject<FlushBlockPolicyFactory>(config_options, value,
+                                                     factory);
+  }
 }
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/block_based/partitioned_index_reader.cc

@@ -113,6 +113,11 @@ InternalIteratorBase<IndexValue>* PartitionIndexReader::NewIterator(
 }
 Status PartitionIndexReader::CacheDependencies(const ReadOptions& ro,
                                                bool pin) {
+  if (!partition_map_.empty()) {
+    // The dependencies are already cached since `partition_map_` is filled in
+    // an all-or-nothing manner.
+    return Status::OK();
+  }
   // Before read partitions, prefetch them to avoid lots of IOs
   BlockCacheLookupContext lookup_context{TableReaderCaller::kPrefetch};
   const BlockBasedTable::Rep* rep = table()->rep_;

package/deps/rocksdb/rocksdb/table/block_based/reader_common.h

@@ -8,7 +8,7 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 #pragma once
 
-#include "rocksdb/cache.h"
+#include "rocksdb/advanced_cache.h"
 #include "rocksdb/table.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -22,13 +22,6 @@ inline MemoryAllocator* GetMemoryAllocator(
              : nullptr;
 }
 
-inline MemoryAllocator* GetMemoryAllocatorForCompressedBlock(
-    const BlockBasedTableOptions& table_options) {
-  return table_options.block_cache_compressed.get()
-             ? table_options.block_cache_compressed->memory_allocator()
-             : nullptr;
-}
-
 // Assumes block has a trailer as in format.h. file_name and offset provided
 // for generating a diagnostic message in returned status.
 extern Status VerifyBlockChecksum(ChecksumType type, const char* data,

package/deps/rocksdb/rocksdb/table/block_fetcher_test.cc

@@ -363,7 +363,6 @@ class BlockFetcherTest : public testing::Test {
 };
 
 // Skip the following tests in lite mode since direct I/O is unsupported.
-#ifndef ROCKSDB_LITE
 
 // Fetch index block under both direct IO and non-direct IO.
 // Expects:
@@ -509,7 +508,6 @@ TEST_F(BlockFetcherTest, FetchAndUncompressCompressedDataBlock) {
                      expected_stats_by_mode);
 }
 
-#endif  // ROCKSDB_LITE
 
 }  // namespace
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_builder.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 #include "table/cuckoo/cuckoo_table_builder.h"
 
 #include <assert.h>
@@ -550,4 +549,3 @@ const char* CuckooTableBuilder::GetFileChecksumFuncName() const {
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_builder.h

@@ -4,7 +4,6 @@
 //  (found in the LICENSE.Apache file in the root directory).
 
 #pragma once
-#ifndef ROCKSDB_LITE
 #include <stdint.h>
 
 #include <limits>
@@ -135,4 +134,3 @@ class CuckooTableBuilder : public TableBuilder {
 
 }  // namespace ROCKSDB_NAMESPACE
 
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_builder_test.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "table/cuckoo/cuckoo_table_builder.h"
 
@@ -629,12 +628,3 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr, "SKIPPED as Cuckoo table is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_factory.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 #include "table/cuckoo/cuckoo_table_factory.h"
 
 #include "db/dbformat.h"
@@ -67,7 +66,6 @@ std::string CuckooTableFactory::GetPrintableOptions() const {
 
 static std::unordered_map<std::string, OptionTypeInfo> cuckoo_table_type_info =
     {
-#ifndef ROCKSDB_LITE
         {"hash_table_ratio",
          {offsetof(struct CuckooTableOptions, hash_table_ratio),
           OptionType::kDouble, OptionVerificationType::kNormal,
@@ -88,7 +86,6 @@ static std::unordered_map<std::string, OptionTypeInfo> cuckoo_table_type_info =
          {offsetof(struct CuckooTableOptions, use_module_hash),
           OptionType::kBoolean, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 
 CuckooTableFactory::CuckooTableFactory(const CuckooTableOptions& table_options)
@@ -101,4 +98,3 @@ TableFactory* NewCuckooTableFactory(const CuckooTableOptions& table_options) {
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_factory.h

@@ -4,7 +4,6 @@
 //  (found in the LICENSE.Apache file in the root directory).
 
 #pragma once
-#ifndef ROCKSDB_LITE
 
 #include <string>
 
@@ -79,4 +78,3 @@ class CuckooTableFactory : public TableFactory {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_reader.cc

@@ -7,7 +7,6 @@
 // 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/cuckoo/cuckoo_table_reader.h"
 
 #include <algorithm>
@@ -408,4 +407,3 @@ InternalIterator* CuckooTableReader::NewIterator(
 size_t CuckooTableReader::ApproximateMemoryUsage() const { return 0; }
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_reader.h

@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #pragma once
-#ifndef ROCKSDB_LITE
 #include <memory>
 #include <string>
 #include <utility>
@@ -97,4 +96,3 @@ class CuckooTableReader : public TableReader {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_reader_test.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #ifndef GFLAGS
 #include <cstdio>
@@ -573,12 +572,3 @@ int main(int argc, char** argv) {
 
 #endif  // GFLAGS.
 
-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr, "SKIPPED as Cuckoo table is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/table/format.cc

@@ -38,14 +38,8 @@ namespace ROCKSDB_NAMESPACE {
 extern const uint64_t kLegacyBlockBasedTableMagicNumber;
 extern const uint64_t kBlockBasedTableMagicNumber;
 
-#ifndef ROCKSDB_LITE
 extern const uint64_t kLegacyPlainTableMagicNumber;
 extern const uint64_t kPlainTableMagicNumber;
-#else
-// ROCKSDB_LITE doesn't have plain table
-const uint64_t kLegacyPlainTableMagicNumber = 0;
-const uint64_t kPlainTableMagicNumber = 0;
-#endif
 const char* kHostnameForDbHostId = "__hostname__";
 
 bool ShouldReportDetailedTime(Env* env, Statistics* stats) {