rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/db/table_cache.h

@@ -1,298 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// 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.
-//
-// Thread-safe (provides internal synchronization)
-
-#pragma once
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "cache/typed_cache.h"
-#include "db/dbformat.h"
-#include "db/range_del_aggregator.h"
-#include "options/cf_options.h"
-#include "port/port.h"
-#include "rocksdb/cache.h"
-#include "rocksdb/env.h"
-#include "rocksdb/options.h"
-#include "rocksdb/table.h"
-#include "table/table_reader.h"
-#include "trace_replay/block_cache_tracer.h"
-#include "util/coro_utils.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Env;
-class Arena;
-struct FileDescriptor;
-class GetContext;
-class HistogramImpl;
-
-// Manages caching for TableReader objects for a column family. The actual
-// cache is allocated separately and passed to the constructor. TableCache
-// wraps around the underlying SST file readers by providing Get(),
-// MultiGet() and NewIterator() methods that hide the instantiation,
-// caching and access to the TableReader. The main purpose of this is
-// performance - by caching the TableReader, it avoids unnecessary file opens
-// and object allocation and instantiation. One exception is compaction, where
-// a new TableReader may be instantiated - see NewIterator() comments
-//
-// Another service provided by TableCache is managing the row cache - if the
-// DB is configured with a row cache, and the lookup key is present in the row
-// cache, lookup is very fast. The row cache is obtained from
-// ioptions.row_cache
-class TableCache {
- public:
-  TableCache(const ImmutableOptions& ioptions,
-             const FileOptions* storage_options, Cache* cache,
-             BlockCacheTracer* const block_cache_tracer,
-             const std::shared_ptr<IOTracer>& io_tracer,
-             const std::string& db_session_id);
-  ~TableCache();
-
-  // Cache interface for table cache
-  using CacheInterface =
-      BasicTypedCacheInterface<TableReader, CacheEntryRole::kMisc>;
-  using TypedHandle = CacheInterface::TypedHandle;
-
-  // Cache interface for row cache
-  using RowCacheInterface =
-      BasicTypedCacheInterface<std::string, CacheEntryRole::kMisc>;
-  using RowHandle = RowCacheInterface::TypedHandle;
-
-  // Return an iterator for the specified file number (the corresponding
-  // file length must be exactly "file_size" bytes).  If "table_reader_ptr"
-  // is non-nullptr, also sets "*table_reader_ptr" to point to the Table object
-  // underlying the returned iterator, or nullptr if no Table object underlies
-  // the returned iterator.  The returned "*table_reader_ptr" object is owned
-  // by the cache and should not be deleted, and is valid for as long as the
-  // returned iterator is live.
-  // If !options.ignore_range_deletions, and range_del_iter is non-nullptr,
-  // then range_del_iter is set to a TruncatedRangeDelIterator for range
-  // tombstones in the SST file corresponding to the specified file number. The
-  // upper/lower bounds for the TruncatedRangeDelIterator are set to the SST
-  // file's boundary.
-  // @param options Must outlive the returned iterator.
-  // @param range_del_agg If non-nullptr, adds range deletions to the
-  //    aggregator. If an error occurs, returns it in a NewErrorInternalIterator
-  // @param for_compaction If true, a new TableReader may be allocated (but
-  //                       not cached), depending on the CF options
-  // @param skip_filters Disables loading/accessing the filter block
-  // @param level The level this table is at, -1 for "not set / don't know"
-  // @param range_del_read_seqno If non-nullptr, will be used to create
-  // *range_del_iter.
-  InternalIterator* NewIterator(
-      const ReadOptions& options, const FileOptions& toptions,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, RangeDelAggregator* range_del_agg,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor,
-      TableReader** table_reader_ptr, HistogramImpl* file_read_hist,
-      TableReaderCaller caller, Arena* arena, bool skip_filters, int level,
-      size_t max_file_size_for_l0_meta_pin,
-      const InternalKey* smallest_compaction_key,
-      const InternalKey* largest_compaction_key, bool allow_unprepared_value,
-      uint8_t protection_bytes_per_key,
-      const SequenceNumber* range_del_read_seqno = nullptr,
-      std::unique_ptr<TruncatedRangeDelIterator>* range_del_iter = nullptr);
-
-  // If a seek to internal key "k" in specified file finds an entry,
-  // call get_context->SaveValue() repeatedly until
-  // it returns false. As a side effect, it will insert the TableReader
-  // into the cache and potentially evict another entry
-  // @param get_context Context for get operation. The result of the lookup
-  //                    can be retrieved by calling get_context->State()
-  // @param file_read_hist If non-nullptr, the file reader statistics are
-  //                       recorded
-  // @param skip_filters Disables loading/accessing the filter block
-  // @param level The level this table is at, -1 for "not set / don't know"
-  Status Get(
-      const ReadOptions& options,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, const Slice& k, GetContext* get_context,
-      uint8_t block_protection_bytes_per_key,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
-      HistogramImpl* file_read_hist = nullptr, bool skip_filters = false,
-      int level = -1, size_t max_file_size_for_l0_meta_pin = 0);
-
-  // Return the range delete tombstone iterator of the file specified by
-  // `file_meta`.
-  Status GetRangeTombstoneIterator(
-      const ReadOptions& options,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, uint8_t block_protection_bytes_per_key,
-      std::unique_ptr<FragmentedRangeTombstoneIterator>* out_iter);
-
-  // Call table reader's MultiGetFilter to use the bloom filter to filter out
-  // keys. Returns Status::NotSupported() if row cache needs to be checked.
-  // If the table cache is looked up to get the table reader, the cache handle
-  // is returned in table_handle. This handle should be passed back to
-  // MultiGet() so it can be released.
-  Status MultiGetFilter(
-      const ReadOptions& options,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor,
-      HistogramImpl* file_read_hist, int level,
-      MultiGetContext::Range* mget_range, TypedHandle** table_handle,
-      uint8_t block_protection_bytes_per_key);
-
-  // If a seek to internal key "k" in specified file finds an entry,
-  // call get_context->SaveValue() repeatedly until
-  // it returns false. As a side effect, it will insert the TableReader
-  // into the cache and potentially evict another entry
-  // @param mget_range Pointer to the structure describing a batch of keys to
-  //                   be looked up in this table file. The result is stored
-  //                   in the embedded GetContext
-  // @param skip_filters Disables loading/accessing the filter block
-  // @param level The level this table is at, -1 for "not set / don't know"
-  DECLARE_SYNC_AND_ASYNC(
-      Status, MultiGet, const ReadOptions& options,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, const MultiGetContext::Range* mget_range,
-      uint8_t block_protection_bytes_per_key,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
-      HistogramImpl* file_read_hist = nullptr, bool skip_filters = false,
-      bool skip_range_deletions = false, int level = -1,
-      TypedHandle* table_handle = nullptr);
-
-  // Evict any entry for the specified file number
-  static void Evict(Cache* cache, uint64_t file_number);
-
-  // Handles releasing, erasing, etc. of what should be the last reference
-  // to an obsolete file.
-  static void ReleaseObsolete(Cache* cache, Cache::Handle* handle,
-                              uint32_t uncache_aggressiveness);
-
-  // Return handle to an existing cache entry if there is one
-  static Cache::Handle* Lookup(Cache* cache, uint64_t file_number);
-
-  // Find table reader
-  // @param skip_filters Disables loading/accessing the filter block
-  // @param level == -1 means not specified
-  Status FindTable(
-      const ReadOptions& ro, const FileOptions& toptions,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, TypedHandle**,
-      uint8_t block_protection_bytes_per_key,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
-      const bool no_io = false, HistogramImpl* file_read_hist = nullptr,
-      bool skip_filters = false, int level = -1,
-      bool prefetch_index_and_filter_in_cache = true,
-      size_t max_file_size_for_l0_meta_pin = 0,
-      Temperature file_temperature = Temperature::kUnknown);
-
-  // Get the table properties of a given table.
-  // @no_io: indicates if we should load table to the cache if it is not present
-  //         in table cache yet.
-  // @returns: `properties` will be reset on success. Please note that we will
-  //            return Status::Incomplete() if table is not present in cache and
-  //            we set `no_io` to be true.
-  Status GetTableProperties(
-      const FileOptions& toptions, const ReadOptions& read_options,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta,
-      std::shared_ptr<const TableProperties>* properties,
-      uint8_t block_protection_bytes_per_key,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
-      bool no_io = false);
-
-  Status ApproximateKeyAnchors(const ReadOptions& ro,
-                               const InternalKeyComparator& internal_comparator,
-                               const FileMetaData& file_meta,
-                               uint8_t block_protection_bytes_per_key,
-                               std::vector<TableReader::Anchor>& anchors);
-
-  // Return total memory usage of the table reader of the file.
-  // 0 if table reader of the file is not loaded.
-  size_t GetMemoryUsageByTableReader(
-      const FileOptions& toptions, const ReadOptions& read_options,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, uint8_t block_protection_bytes_per_key,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr);
-
-  // Returns approximated offset of a key in a file represented by fd.
-  uint64_t ApproximateOffsetOf(
-      const ReadOptions& read_options, const Slice& key,
-      const FileMetaData& file_meta, TableReaderCaller caller,
-      const InternalKeyComparator& internal_comparator,
-      uint8_t block_protection_bytes_per_key,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr);
-
-  // Returns approximated data size between start and end keys in a file
-  // represented by fd (the start key must not be greater than the end key).
-  uint64_t ApproximateSize(
-      const ReadOptions& read_options, const Slice& start, const Slice& end,
-      const FileMetaData& file_meta, TableReaderCaller caller,
-      const InternalKeyComparator& internal_comparator,
-      uint8_t block_protection_bytes_per_key,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr);
-
-  CacheInterface& get_cache() { return cache_; }
-
-  // Capacity of the backing Cache that indicates infinite TableCache capacity.
-  // For example when max_open_files is -1 we set the backing Cache to this.
-  static const int kInfiniteCapacity = 0x400000;
-
-  // The tables opened with this TableCache will be immortal, i.e., their
-  // lifetime is as long as that of the DB.
-  void SetTablesAreImmortal() {
-    if (cache_.get()->GetCapacity() >= kInfiniteCapacity) {
-      immortal_tables_ = true;
-    }
-  }
-
- private:
-  // Build a table reader
-  Status GetTableReader(
-      const ReadOptions& ro, const FileOptions& file_options,
-      const InternalKeyComparator& internal_comparator,
-      const FileMetaData& file_meta, bool sequential_mode,
-      uint8_t block_protection_bytes_per_key, HistogramImpl* file_read_hist,
-      std::unique_ptr<TableReader>* table_reader,
-      const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
-      bool skip_filters = false, int level = -1,
-      bool prefetch_index_and_filter_in_cache = true,
-      size_t max_file_size_for_l0_meta_pin = 0,
-      Temperature file_temperature = Temperature::kUnknown);
-
-  // Update the max_covering_tombstone_seq in the GetContext for each key based
-  // on the range deletions in the table
-  void UpdateRangeTombstoneSeqnums(const ReadOptions& options, TableReader* t,
-                                   MultiGetContext::Range& table_range);
-
-  // Create a key prefix for looking up the row cache. The prefix is of the
-  // format row_cache_id + fd_number + seq_no. Later, the user key can be
-  // appended to form the full key
-  // Return the sequence number that determines the visibility of row_cache_key
-  uint64_t CreateRowCacheKeyPrefix(const ReadOptions& options,
-                                   const FileDescriptor& fd,
-                                   const Slice& internal_key,
-                                   GetContext* get_context,
-                                   IterKey& row_cache_key);
-
-  // Helper function to lookup the row cache for a key. It appends the
-  // user key to row_cache_key at offset prefix_size
-  bool GetFromRowCache(const Slice& user_key, IterKey& row_cache_key,
-                       size_t prefix_size, GetContext* get_context,
-                       Status* read_status,
-                       SequenceNumber seq_no = kMaxSequenceNumber);
-
-  const ImmutableOptions& ioptions_;
-  const FileOptions& file_options_;
-  CacheInterface cache_;
-  std::string row_cache_id_;
-  bool immortal_tables_;
-  BlockCacheTracer* const block_cache_tracer_;
-  Striped<CacheAlignedWrapper<port::Mutex>> loader_mutex_;
-  std::shared_ptr<IOTracer> io_tracer_;
-  std::string db_session_id_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/table_cache_sync_and_async.h

@@ -1,135 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "util/coro_utils.h"
-
-#if defined(WITHOUT_COROUTINES) || \
-    (defined(USE_COROUTINES) && defined(WITH_COROUTINES))
-namespace ROCKSDB_NAMESPACE {
-
-#if defined(WITHOUT_COROUTINES)
-#endif
-
-// Batched version of TableCache::MultiGet.
-DEFINE_SYNC_AND_ASYNC(Status, TableCache::MultiGet)
-(const ReadOptions& options, const InternalKeyComparator& internal_comparator,
- const FileMetaData& file_meta, const MultiGetContext::Range* mget_range,
- uint8_t block_protection_bytes_per_key,
- const std::shared_ptr<const SliceTransform>& prefix_extractor,
- HistogramImpl* file_read_hist, bool skip_filters, bool skip_range_deletions,
- int level, TypedHandle* handle) {
-  auto& fd = file_meta.fd;
-  Status s;
-  TableReader* t = fd.table_reader;
-  MultiGetRange table_range(*mget_range, mget_range->begin(),
-                            mget_range->end());
-  if (handle != nullptr && t == nullptr) {
-    t = cache_.Value(handle);
-  }
-  autovector<std::string, MultiGetContext::MAX_BATCH_SIZE> row_cache_entries;
-  IterKey row_cache_key;
-  size_t row_cache_key_prefix_size = 0;
-  KeyContext& first_key = *table_range.begin();
-  bool lookup_row_cache =
-      ioptions_.row_cache && !first_key.get_context->NeedToReadSequence();
-
-  // Check row cache if enabled. Since row cache does not currently store
-  // sequence numbers, we cannot use it if we need to fetch the sequence.
-  if (lookup_row_cache) {
-    GetContext* first_context = first_key.get_context;
-    CreateRowCacheKeyPrefix(options, fd, first_key.ikey, first_context,
-                            row_cache_key);
-    row_cache_key_prefix_size = row_cache_key.Size();
-
-    for (auto miter = table_range.begin(); miter != table_range.end();
-         ++miter) {
-      const Slice& user_key = miter->ukey_with_ts;
-
-      GetContext* get_context = miter->get_context;
-
-      Status read_status;
-      bool ret =
-          GetFromRowCache(user_key, row_cache_key, row_cache_key_prefix_size,
-                          get_context, &read_status);
-      if (!read_status.ok()) {
-        CO_RETURN read_status;
-      }
-      if (ret) {
-        table_range.SkipKey(miter);
-      } else {
-        row_cache_entries.emplace_back();
-        get_context->SetReplayLog(&(row_cache_entries.back()));
-      }
-    }
-  }
-
-  // Check that table_range is not empty. Its possible all keys may have been
-  // found in the row cache and thus the range may now be empty
-  if (s.ok() && !table_range.empty()) {
-    if (t == nullptr) {
-      assert(handle == nullptr);
-      s = FindTable(options, file_options_, internal_comparator, file_meta,
-                    &handle, block_protection_bytes_per_key, prefix_extractor,
-                    options.read_tier == kBlockCacheTier /* no_io */,
-                    file_read_hist, skip_filters, level,
-                    true /* prefetch_index_and_filter_in_cache */,
-                    0 /*max_file_size_for_l0_meta_pin*/, file_meta.temperature);
-      TEST_SYNC_POINT_CALLBACK("TableCache::MultiGet:FindTable", &s);
-      if (s.ok()) {
-        t = cache_.Value(handle);
-        assert(t);
-      }
-    }
-    if (s.ok() && !options.ignore_range_deletions && !skip_range_deletions) {
-      UpdateRangeTombstoneSeqnums(options, t, table_range);
-    }
-    if (s.ok()) {
-      CO_AWAIT(t->MultiGet)
-      (options, &table_range, prefix_extractor.get(), skip_filters);
-    } else if (options.read_tier == kBlockCacheTier && s.IsIncomplete()) {
-      for (auto iter = table_range.begin(); iter != table_range.end(); ++iter) {
-        Status* status = iter->s;
-        if (status->IsIncomplete()) {
-          // Couldn't find Table in cache but treat as kFound if no_io set
-          iter->get_context->MarkKeyMayExist();
-          s = Status::OK();
-        }
-      }
-    }
-  }
-
-  if (lookup_row_cache) {
-    size_t row_idx = 0;
-    RowCacheInterface row_cache{ioptions_.row_cache.get()};
-
-    for (auto miter = table_range.begin(); miter != table_range.end();
-         ++miter) {
-      std::string& row_cache_entry = row_cache_entries[row_idx++];
-      const Slice& user_key = miter->ukey_with_ts;
-      GetContext* get_context = miter->get_context;
-
-      get_context->SetReplayLog(nullptr);
-      // Compute row cache key.
-      row_cache_key.TrimAppend(row_cache_key_prefix_size, user_key.data(),
-                               user_key.size());
-      // Put the replay log in row cache only if something was found.
-      if (s.ok() && !row_cache_entry.empty()) {
-        size_t charge = row_cache_entry.capacity() + sizeof(std::string);
-        auto row_ptr = new std::string(std::move(row_cache_entry));
-        // If row cache is full, it's OK.
-        row_cache.Insert(row_cache_key.GetUserKey(), row_ptr, charge)
-            .PermitUncheckedError();
-      }
-    }
-  }
-
-  if (handle != nullptr) {
-    cache_.Release(handle);
-  }
-  CO_RETURN s;
-}
-}  // namespace ROCKSDB_NAMESPACE
-#endif

package/vendor/librocksdb/vendor/rocksdb/db/table_properties_collector.cc

@@ -1,74 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "db/table_properties_collector.h"
-
-#include "db/dbformat.h"
-#include "util/coding.h"
-#include "util/string_util.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-namespace {
-
-uint64_t GetUint64Property(const UserCollectedProperties& props,
-                           const std::string& property_name,
-                           bool* property_present) {
-  auto pos = props.find(property_name);
-  if (pos == props.end()) {
-    *property_present = false;
-    return 0;
-  }
-  Slice raw = pos->second;
-  uint64_t val = 0;
-  *property_present = true;
-  return GetVarint64(&raw, &val) ? val : 0;
-}
-
-}  // anonymous namespace
-
-Status UserKeyTablePropertiesCollector::InternalAdd(const Slice& key,
-                                                    const Slice& value,
-                                                    uint64_t file_size) {
-  ParsedInternalKey ikey;
-  Status s = ParseInternalKey(key, &ikey, false /* log_err_key */);  // TODO
-  if (!s.ok()) {
-    return s;
-  }
-
-  return collector_->AddUserKey(ikey.user_key, value, GetEntryType(ikey.type),
-                                ikey.sequence, file_size);
-}
-
-void UserKeyTablePropertiesCollector::BlockAdd(
-    uint64_t block_uncomp_bytes, uint64_t block_compressed_bytes_fast,
-    uint64_t block_compressed_bytes_slow) {
-  return collector_->BlockAdd(block_uncomp_bytes, block_compressed_bytes_fast,
-                              block_compressed_bytes_slow);
-}
-
-Status UserKeyTablePropertiesCollector::Finish(
-    UserCollectedProperties* properties) {
-  return collector_->Finish(properties);
-}
-
-UserCollectedProperties UserKeyTablePropertiesCollector::GetReadableProperties()
-    const {
-  return collector_->GetReadableProperties();
-}
-
-uint64_t GetDeletedKeys(const UserCollectedProperties& props) {
-  bool property_present_ignored;
-  return GetUint64Property(props, TablePropertiesNames::kDeletedKeys,
-                           &property_present_ignored);
-}
-
-uint64_t GetMergeOperands(const UserCollectedProperties& props,
-                          bool* property_present) {
-  return GetUint64Property(props, TablePropertiesNames::kMergeOperands,
-                           property_present);
-}
-
-}  // namespace ROCKSDB_NAMESPACE