@nxtedition/rocksdb 15.4.1 → 15.5.0

package/deps/rocksdb/rocksdb/table/meta_blocks.cc

@@ -29,8 +29,6 @@ namespace ROCKSDB_NAMESPACE {
 const std::string kPropertiesBlockName = "rocksdb.properties";
 // NB: only used with format_version >= 6
 const std::string kIndexBlockName = "rocksdb.index";
-// Old property block name for backward compatibility
-const std::string kPropertiesBlockOldName = "rocksdb.stats";
 const std::string kCompressionDictBlockName = "rocksdb.compression_dict";
 const std::string kRangeDelBlockName = "rocksdb.range_del";
 
@@ -170,6 +168,18 @@ void PropertyBlockBuilder::AddTableProperty(const TableProperties& props) {
   if (props.key_smallest_seqno != UINT64_MAX) {
     Add(TablePropertiesNames::kKeySmallestSeqno, props.key_smallest_seqno);
   }
+  if (props.data_block_restart_interval > 0) {
+    Add(TablePropertiesNames::kDataBlockRestartInterval,
+        props.data_block_restart_interval);
+  }
+  if (props.index_block_restart_interval > 0) {
+    Add(TablePropertiesNames::kIndexBlockRestartInterval,
+        props.index_block_restart_interval);
+  }
+  if (props.separate_key_value_in_data_block > 0) {
+    Add(TablePropertiesNames::kSeparateKeyValueInDataBlock,
+        props.separate_key_value_in_data_block);
+  }
 }
 
 Slice PropertyBlockBuilder::Finish() {
@@ -316,6 +326,12 @@ Status ParsePropertiesBlock(
        &new_table_properties->key_largest_seqno},
       {TablePropertiesNames::kKeySmallestSeqno,
        &new_table_properties->key_smallest_seqno},
+      {TablePropertiesNames::kDataBlockRestartInterval,
+       &new_table_properties->data_block_restart_interval},
+      {TablePropertiesNames::kIndexBlockRestartInterval,
+       &new_table_properties->index_block_restart_interval},
+      {TablePropertiesNames::kSeparateKeyValueInDataBlock,
+       &new_table_properties->separate_key_value_in_data_block},
   };
 
   Status s;
@@ -476,7 +492,8 @@ Status ReadTablePropertiesHelper(
     // (See write_global_seqno comment above)
     if (s.ok() && footer.GetBlockTrailerSize() > 0) {
       s = VerifyBlockChecksum(footer, properties_block.data(), block_size,
-                              file->file_name(), handle.offset());
+                              file->file_name(), handle.offset(),
+                              BlockType::kProperties);
       if (s.IsCorruption()) {
         if (new_table_properties->external_sst_file_global_seqno_offset != 0) {
           std::string tmp_buf(properties_block.data(), len);
@@ -485,7 +502,8 @@ Status ReadTablePropertiesHelper(
               handle.offset();
           EncodeFixed64(&tmp_buf[static_cast<size_t>(global_seqno_offset)], 0);
           s = VerifyBlockChecksum(footer, tmp_buf.data(), block_size,
-                                  file->file_name(), handle.offset());
+                                  file->file_name(), handle.offset(),
+                                  BlockType::kProperties);
         }
       }
     }
@@ -543,14 +561,6 @@ Status FindOptionalMetaBlock(InternalIterator* meta_index_iter,
     if (meta_index_iter->Valid() && meta_index_iter->key() == meta_block_name) {
       Slice v = meta_index_iter->value();
       return block_handle->DecodeFrom(&v);
-    } else if (meta_block_name == kPropertiesBlockName) {
-      // Have to try old name for compatibility
-      meta_index_iter->Seek(kPropertiesBlockOldName);
-      if (meta_index_iter->status().ok() && meta_index_iter->Valid() &&
-          meta_index_iter->key() == kPropertiesBlockOldName) {
-        Slice v = meta_index_iter->value();
-        return block_handle->DecodeFrom(&v);
-      }
     }
   }
   // else

package/deps/rocksdb/rocksdb/table/meta_blocks.h

@@ -34,7 +34,6 @@ struct TableProperties;
 // Meta block names for metaindex
 extern const std::string kPropertiesBlockName;
 extern const std::string kIndexBlockName;
-extern const std::string kPropertiesBlockOldName;
 extern const std::string kCompressionDictBlockName;
 extern const std::string kRangeDelBlockName;
 

package/deps/rocksdb/rocksdb/table/sst_file_dumper.cc

@@ -23,6 +23,7 @@
 #include "port/port.h"
 #include "rocksdb/db.h"
 #include "rocksdb/env.h"
+#include "rocksdb/file_checksum.h"
 #include "rocksdb/iterator.h"
 #include "rocksdb/slice_transform.h"
 #include "rocksdb/status.h"
@@ -85,6 +86,7 @@ Status SstFileDumper::GetTableReader(const std::string& file_path) {
   uint64_t file_size = 0;
   FileOptions fopts = soptions_;
   fopts.temperature = file_temp_;
+  fopts.file_checksum_func_name = kNoFileChecksumFuncName;
   Status s = fs->NewRandomAccessFile(file_path, fopts, &file, nullptr);
   if (s.ok()) {
     // check empty file
@@ -129,18 +131,18 @@ Status SstFileDumper::GetTableReader(const std::string& file_path) {
       if (magic_number == kCuckooTableMagicNumber) {
         fopts = soptions_;
         fopts.temperature = file_temp_;
+        fopts.file_checksum_func_name = kNoFileChecksumFuncName;
       }
 
       fs->NewRandomAccessFile(file_path, fopts, &file, nullptr);
       file_.reset(new RandomAccessFileReader(std::move(file), file_path));
     }
 
-    // For old sst format, ReadTableProperties might fail but file can be read
-    if (ReadTableProperties(magic_number, file_.get(), file_size,
+    s = ReadTableProperties(magic_number, file_.get(), file_size,
                             (magic_number == kBlockBasedTableMagicNumber)
                                 ? &prefetch_buffer
-                                : nullptr)
-            .ok()) {
+                                : nullptr);
+    if (s.ok()) {
       s = SetTableOptionsByMagicNumber(magic_number);
       if (s.ok()) {
         if (table_properties_ && !table_properties_->comparator_name.empty()) {
@@ -155,8 +157,6 @@ Status SstFileDumper::GetTableReader(const std::string& file_path) {
           }
         }
       }
-    } else {
-      s = SetOldTableOptions();
     }
     options_.comparator = internal_comparator_.user_comparator();
 
@@ -458,8 +458,7 @@ Status SstFileDumper::ReadTableProperties(uint64_t table_magic_number,
 Status SstFileDumper::SetTableOptionsByMagicNumber(
     uint64_t table_magic_number) {
   assert(table_properties_);
-  if (table_magic_number == kBlockBasedTableMagicNumber ||
-      table_magic_number == kLegacyBlockBasedTableMagicNumber) {
+  if (table_magic_number == kBlockBasedTableMagicNumber) {
     // Preserve BlockBasedTableOptions on options_ when possible
     if (!options_.table_factory->IsInstanceOf(
             TableFactory::kBlockBasedTableName())) {
@@ -524,19 +523,6 @@ Status SstFileDumper::SetTableOptionsByMagicNumber(
   return Status::OK();
 }
 
-Status SstFileDumper::SetOldTableOptions() {
-  assert(table_properties_ == nullptr);
-  if (!options_.table_factory->IsInstanceOf(
-          TableFactory::kBlockBasedTableName())) {
-    options_.table_factory = std::make_shared<BlockBasedTableFactory>();
-  }
-  if (!silent_) {
-    fprintf(stdout, "Sst file format: block-based(old version)\n");
-  }
-
-  return Status::OK();
-}
-
 Status SstFileDumper::ReadSequential(bool print_kv, uint64_t read_num_limit,
                                      bool has_from, const std::string& from_key,
                                      bool has_to, const std::string& to_key,

package/deps/rocksdb/rocksdb/table/sst_file_dumper.h

@@ -65,7 +65,6 @@ class SstFileDumper {
                                       std::chrono::microseconds* read_time);
 
   Status SetTableOptionsByMagicNumber(uint64_t table_magic_number);
-  Status SetOldTableOptions();
 
   // Helper function to call the factory with settings specific to the
   // factory implementation

package/deps/rocksdb/rocksdb/table/sst_file_reader.cc

@@ -11,6 +11,7 @@
 #include "file/random_access_file_reader.h"
 #include "options/cf_options.h"
 #include "rocksdb/env.h"
+#include "rocksdb/file_checksum.h"
 #include "rocksdb/file_system.h"
 #include "table/get_context.h"
 #include "table/table_builder.h"
@@ -51,6 +52,7 @@ Status SstFileReader::Open(const std::string& file_path) {
   std::unique_ptr<FSRandomAccessFile> file;
   std::unique_ptr<RandomAccessFileReader> file_reader;
   FileOptions fopts(r->soptions);
+  fopts.file_checksum_func_name = kNoFileChecksumFuncName;
   const auto& fs = r->options.env->GetFileSystem();
 
   s = fs->GetFileSize(file_path, fopts.io_options, &file_size, nullptr);
@@ -81,16 +83,20 @@ Status SstFileReader::Open(const std::string& file_path) {
   return s;
 }
 
-std::vector<Status> SstFileReader::MultiGet(const ReadOptions& roptions,
-                                            const std::vector<Slice>& keys,
-                                            std::vector<std::string>* values) {
+std::vector<Status> SstFileReader::MultiGet(
+    const ReadOptions& roptions, const std::vector<Slice>& keys,
+    std::vector<PinnableSlice>* values) {
   const auto num_keys = keys.size();
   std::vector<Status> statuses(num_keys, Status::OK());
-  std::vector<PinnableSlice> pin_values(num_keys);
+  values->resize(num_keys);
+  for (size_t i = 0; i < num_keys; ++i) {
+    (*values)[i].Reset();
+  }
 
   auto r = rep_.get();
   const Comparator* user_comparator =
       r->ioptions.internal_comparator.user_comparator();
+  Statistics* statistics = r->ioptions.stats;
 
   autovector<KeyContext, MultiGetContext::MAX_BATCH_SIZE> key_context;
   autovector<KeyContext*, MultiGetContext::MAX_BATCH_SIZE> sorted_keys;
@@ -98,16 +104,16 @@ std::vector<Status> SstFileReader::MultiGet(const ReadOptions& roptions,
   autovector<MergeContext, MultiGetContext::MAX_BATCH_SIZE> merge_ctx;
   sorted_keys.resize(num_keys);
   for (size_t i = 0; i < num_keys; ++i) {
-    PinnableSlice* val = &pin_values[i];
-    val->Reset();
+    PinnableSlice* val = &(*values)[i];
     merge_ctx.emplace_back();
     key_context.emplace_back(nullptr, keys[i], val, nullptr,
                              nullptr /* timestamp */, &statuses[i]);
-    get_ctx.emplace_back(user_comparator, r->ioptions.merge_operator.get(),
-                         nullptr, nullptr, GetContext::kNotFound,
-                         *key_context[i].key, val, nullptr, nullptr, nullptr,
-                         &merge_ctx[i], true,
-                         &key_context[i].max_covering_tombstone_seq, nullptr);
+    get_ctx.emplace_back(
+        user_comparator, r->ioptions.merge_operator.get(), nullptr /* logger */,
+        statistics, GetContext::kNotFound, *key_context[i].key, val,
+        nullptr /* columns */, nullptr /* timestamp */,
+        nullptr /* value_found */, &merge_ctx[i], true,
+        &key_context[i].max_covering_tombstone_seq, r->ioptions.clock);
     key_context[i].get_context = &get_ctx[i];
   }
   for (size_t i = 0; i < num_keys; ++i) {
@@ -135,12 +141,12 @@ std::vector<Status> SstFileReader::MultiGet(const ReadOptions& roptions,
                             r->moptions.prefix_extractor.get(),
                             false /* skip filters */);
 
-  values->resize(num_keys);
   for (size_t i = 0; i < num_keys; ++i) {
+    get_ctx[i].ReportCounters();
+
     if (statuses[i].ok()) {
       switch (get_ctx[i].State()) {
         case GetContext::kFound:
-          (*values)[i].assign(pin_values[i].data(), pin_values[i].size());
           break;
         case GetContext::kNotFound:
         case GetContext::kDeleted:
@@ -160,6 +166,75 @@ std::vector<Status> SstFileReader::MultiGet(const ReadOptions& roptions,
   return statuses;
 }
 
+std::vector<Status> SstFileReader::MultiGet(const ReadOptions& roptions,
+                                            const std::vector<Slice>& keys,
+                                            std::vector<std::string>* values) {
+  std::vector<PinnableSlice> pin_values;
+  std::vector<Status> statuses = MultiGet(roptions, keys, &pin_values);
+  values->resize(keys.size());
+  for (size_t i = 0; i < keys.size(); ++i) {
+    if (statuses[i].ok()) {
+      (*values)[i].assign(pin_values[i].data(), pin_values[i].size());
+    }
+  }
+  return statuses;
+}
+
+Status SstFileReader::Get(const ReadOptions& roptions, const Slice& key,
+                          PinnableSlice* value) {
+  auto r = rep_.get();
+  value->Reset();
+
+  const Comparator* user_comparator =
+      r->ioptions.internal_comparator.user_comparator();
+  Statistics* statistics = r->ioptions.stats;
+
+  Status status;
+  MergeContext merge_context;
+  SequenceNumber max_covering_tombstone_seq = 0;
+  GetContext get_ctx(user_comparator, r->ioptions.merge_operator.get(),
+                     nullptr /* logger */, statistics, GetContext::kNotFound,
+                     key, value, nullptr /* columns */, nullptr /* timestamp */,
+                     nullptr /* value_found */, &merge_context, true,
+                     &max_covering_tombstone_seq, r->ioptions.clock);
+
+  status = r->table_reader->Get(
+      roptions, InternalKey(key, kMaxSequenceNumber, kTypeValue).Encode(),
+      &get_ctx, r->moptions.prefix_extractor.get(), false /* skip_filters */);
+
+  get_ctx.ReportCounters();
+
+  if (status.ok()) {
+    switch (get_ctx.State()) {
+      case GetContext::kFound:
+        break;
+      case GetContext::kNotFound:
+      case GetContext::kDeleted:
+        status = Status::NotFound();
+        break;
+      case GetContext::kMerge:
+        status = Status::MergeInProgress();
+        break;
+      case GetContext::kCorrupt:
+      case GetContext::kUnexpectedBlobIndex:
+      case GetContext::kMergeOperatorFailed:
+        status = Status::Corruption();
+        break;
+    }
+  }
+  return status;
+}
+
+Status SstFileReader::Get(const ReadOptions& roptions, const Slice& key,
+                          std::string* value) {
+  PinnableSlice pin_value;
+  Status s = Get(roptions, key, &pin_value);
+  if (s.ok()) {
+    value->assign(pin_value.data(), pin_value.size());
+  }
+  return s;
+}
+
 Iterator* SstFileReader::NewIterator(const ReadOptions& roptions) {
   assert(roptions.io_activity == Env::IOActivity::kUnknown);
   auto r = rep_.get();

package/deps/rocksdb/rocksdb/table/sst_file_reader_test.cc

@@ -164,7 +164,7 @@ TEST_F(SstFileReaderTest, ReadFileWithGlobalSeqno) {
   Options options;
   options.create_if_missing = true;
   std::string db_name = test::PerThreadDBPath("test_db");
-  DB* db;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DB::Open(options, db_name, &db));
   // Bump sequence number.
   ASSERT_OK(db->Put(WriteOptions(), keys[0], "foo"));
@@ -186,7 +186,7 @@ TEST_F(SstFileReaderTest, ReadFileWithGlobalSeqno) {
     }
   }
   ASSERT_FALSE(ingested_file.empty());
-  delete db;
+  db.reset();
 
   // Verify the file can be open and read by SstFileReader.
   CheckFile(db_name + ingested_file, keys, true /* check_global_seqno */);
@@ -768,39 +768,36 @@ TEST_F(SstFileReaderTableIteratorTest, UserDefinedTimestampsEnabled) {
   Close();
 }
 
-class SstFileReaderTableMultiGetTest : public DBTestBase {
+class SstFileReaderTableGetTest : public DBTestBase,
+                                  public testing::WithParamInterface<bool> {
  public:
-  SstFileReaderTableMultiGetTest()
-      : DBTestBase("sst_file_reader_table_multi_get_test",
+  SstFileReaderTableGetTest()
+      : DBTestBase("sst_file_reader_table_get_test",
                    /*env_do_fsync=*/false) {}
 
-  void VerifyTableEntry(Iterator* iter, const std::string& user_key,
-                        ValueType value_type,
-                        std::optional<std::string> expected_value,
-                        bool backward_iteration = false) {
-    ASSERT_TRUE(iter->Valid());
-    ASSERT_TRUE(iter->status().ok());
-    ParsedInternalKey pikey;
-    ASSERT_OK(ParseInternalKey(iter->key(), &pikey, /*log_err_key=*/false));
-    ASSERT_EQ(pikey.user_key, user_key);
-    ASSERT_EQ(pikey.type, value_type);
-    if (expected_value.has_value()) {
-      ASSERT_EQ(iter->value(), expected_value.value());
-    }
-    if (!backward_iteration) {
-      iter->Next();
+  bool UseMultiGet() const { return GetParam(); }
+
+  std::vector<Status> DoGet(SstFileReader& reader,
+                            const std::vector<Slice>& keys,
+                            std::vector<std::string>* values) {
+    if (UseMultiGet()) {
+      return reader.MultiGet(ReadOptions(), keys, values);
     } else {
-      iter->Prev();
+      values->resize(keys.size());
+      std::vector<Status> statuses(keys.size());
+      for (size_t i = 0; i < keys.size(); ++i) {
+        statuses[i] = reader.Get(ReadOptions(), keys[i], &(*values)[i]);
+      }
+      return statuses;
     }
   }
 };
 
-TEST_F(SstFileReaderTableMultiGetTest, Basic) {
+TEST_P(SstFileReaderTableGetTest, Basic) {
   Options options = CurrentOptions();
-  const Comparator* ucmp = BytewiseComparator();
-  options.comparator = ucmp;
   options.disable_auto_compactions = true;
   options.merge_operator = MergeOperators::CreateStringAppendOperator();
+  options.statistics = CreateDBStatistics();
   BlockBasedTableOptions bbto;
   bbto.filter_policy.reset(NewBloomFilterPolicy(10, false));
   options.table_factory.reset(NewBlockBasedTableFactory(bbto));
@@ -822,7 +819,7 @@ TEST_F(SstFileReaderTableMultiGetTest, Basic) {
 
   std::vector<LiveFileMetaData> files;
   dbfull()->GetLiveFilesMetaData(&files);
-  ASSERT_TRUE(files.size() == 1);
+  ASSERT_EQ(files.size(), 1);
   ASSERT_TRUE(files[0].level == 0);
   std::string file_name = files[0].directory + "/" + files[0].relative_filename;
 
@@ -830,25 +827,36 @@ TEST_F(SstFileReaderTableMultiGetTest, Basic) {
   ASSERT_OK(reader.Open(file_name));
   ASSERT_OK(reader.VerifyChecksum());
 
-  std::vector<Slice> keys;
+  ASSERT_OK(options.statistics->Reset());
+
+  std::vector<Slice> keys = {"fo1", "foo", "baz",
+                             "bar", "aaa", "zzz_not_in_sst"};
   std::vector<std::string> values;
+  auto statuses = DoGet(reader, keys, &values);
 
-  keys.emplace_back("fo1");
-  keys.emplace_back("foo");
-  keys.emplace_back("baz");
-  keys.emplace_back("bar");
-  keys.emplace_back("aaa");
-  auto statuses = reader.MultiGet(ReadOptions(), keys, &values);
-  ASSERT_TRUE(statuses[0].IsNotFound())
-      << "Failed: status=" << statuses[0].ToString() << " val=" << values[0];
-  ASSERT_TRUE(statuses[1].IsNotFound())
-      << "Failed: status=" << statuses[0].ToString() << " val=" << values[1];
-  ASSERT_TRUE(statuses[2].ok());
-  ASSERT_TRUE(statuses[3].ok());
-  ASSERT_EQ("val3", values[2]);
-  ASSERT_EQ("val2", values[3]);
-  ASSERT_TRUE(statuses[4].ok());
-  ASSERT_EQ("val4,val5", values[4]);
+  // Non-existent key returns NotFound
+  ASSERT_TRUE(statuses[0].IsNotFound());
+
+  // Deleted key returns NotFound
+  ASSERT_TRUE(statuses[1].IsNotFound());
+
+  // Found keys
+  ASSERT_OK(statuses[2]);
+  ASSERT_EQ(values[2], "val3");
+
+  ASSERT_OK(statuses[3]);
+  ASSERT_EQ(values[3], "val2");
+
+  // Merged key
+  ASSERT_OK(statuses[4]);
+  ASSERT_EQ(values[4], "val4,val5");
+
+  // Bloom filter filtered key
+  ASSERT_TRUE(statuses[5].IsNotFound());
+
+  uint64_t cache_hits = options.statistics->getTickerCount(BLOCK_CACHE_HIT);
+  uint64_t cache_misses = options.statistics->getTickerCount(BLOCK_CACHE_MISS);
+  ASSERT_GT(cache_hits + cache_misses, 0);
 
   dbfull()->ReleaseSnapshot(snapshot1);
   dbfull()->ReleaseSnapshot(snapshot2);
@@ -856,6 +864,9 @@ TEST_F(SstFileReaderTableMultiGetTest, Basic) {
   Close();
 }
 
+INSTANTIATE_TEST_CASE_P(SingleAndMulti, SstFileReaderTableGetTest,
+                        testing::Bool());
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/table/sst_file_writer.cc

@@ -30,7 +30,7 @@ const size_t kFadviseTrigger = 1024 * 1024;  // 1MB
 struct SstFileWriter::Rep {
   Rep(const EnvOptions& _env_options, const Options& options,
       Env::IOPriority _io_priority, const Comparator* _user_comparator,
-      ColumnFamilyHandle* _cfh, bool _invalidate_page_cache, bool _skip_filters,
+      ColumnFamilyHandle* _cfh, bool _invalidate_page_cache,
       std::string _db_session_id)
       : env_options(_env_options),
         ioptions(options),
@@ -39,7 +39,6 @@ struct SstFileWriter::Rep {
         internal_comparator(_user_comparator),
         cfh(_cfh),
         invalidate_page_cache(_invalidate_page_cache),
-        skip_filters(_skip_filters),
         db_session_id(_db_session_id),
         ts_sz(_user_comparator->timestamp_size()),
         strip_timestamp(ts_sz > 0 &&
@@ -67,7 +66,6 @@ struct SstFileWriter::Rep {
   // The size of the file during the last time we called Fadvise to remove
   // cached pages from page cache.
   uint64_t last_fadvise_size = 0;
-  bool skip_filters;
   std::string db_session_id;
   uint64_t next_file_number = 1;
   size_t ts_sz;
@@ -305,9 +303,9 @@ SstFileWriter::SstFileWriter(const EnvOptions& env_options,
                              const Comparator* user_comparator,
                              ColumnFamilyHandle* column_family,
                              bool invalidate_page_cache,
-                             Env::IOPriority io_priority, bool skip_filters)
+                             Env::IOPriority io_priority)
     : rep_(new Rep(env_options, options, io_priority, user_comparator,
-                   column_family, invalidate_page_cache, skip_filters,
+                   column_family, invalidate_page_cache,
                    DBImpl::GenerateDbSessionId(options.env))) {
   // SstFileWriter is used to create sst files that can be added to database
   // later. Therefore, no real db_id and db_session_id are associated with it.
@@ -403,9 +401,6 @@ Status SstFileWriter::Open(const std::string& file_path, Temperature temp) {
   // assign fake file numbers to each file (into table properties) and keep
   // the same session id for the life of the SstFileWriter.
   r->next_file_number++;
-  // XXX: when we can remove skip_filters from the SstFileWriter public API
-  // we can remove it from TableBuilderOptions.
-  table_builder_options.skip_filters = r->skip_filters;
   FileTypeSet tmp_set = r->ioptions.checksum_handoff_file_types;
   r->file_writer.reset(new WritableFileWriter(
       std::move(sst_file), file_path, r->env_options, r->ioptions.clock,
@@ -424,10 +419,6 @@ Status SstFileWriter::Open(const std::string& file_path, Temperature temp) {
   return s;
 }
 
-Status SstFileWriter::Add(const Slice& user_key, const Slice& value) {
-  return rep_->Add(user_key, value, ValueType::kTypeValue);
-}
-
 Status SstFileWriter::Put(const Slice& user_key, const Slice& value) {
   return rep_->Add(user_key, value, ValueType::kTypeValue);
 }

package/deps/rocksdb/rocksdb/table/table_builder.h

@@ -164,10 +164,6 @@ struct TableBuilderOptions : public TablePropertiesCollectorFactory::Context {
   const TableFileCreationReason reason;
   // END for FilterBuildingContext
 
-  // XXX: only used by BlockBasedTableBuilder for SstFileWriter. If you
-  // want to skip filters, that should be (for example) null filter_policy
-  // in the table options of the ioptions.table_factory
-  bool skip_filters = false;
   const uint64_t cur_file_num;
 };
 

package/deps/rocksdb/rocksdb/table/table_properties.cc

@@ -328,6 +328,12 @@ const std::string TablePropertiesNames::kKeyLargestSeqno =
     "rocksdb.key.largest.seqno";
 const std::string TablePropertiesNames::kKeySmallestSeqno =
     "rocksdb.key.smallest.seqno";
+const std::string TablePropertiesNames::kDataBlockRestartInterval =
+    "rocksdb.data.block.restart.interval";
+const std::string TablePropertiesNames::kIndexBlockRestartInterval =
+    "rocksdb.index.block.restart.interval";
+const std::string TablePropertiesNames::kSeparateKeyValueInDataBlock =
+    "rocksdb.separate.key.value.in.data.block";
 
 static std::unordered_map<std::string, OptionTypeInfo>
     table_properties_type_info = {
@@ -450,6 +456,18 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct TableProperties, key_smallest_seqno),
           OptionType::kUInt64T, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
+        {"data_block_restart_interval",
+         {offsetof(struct TableProperties, data_block_restart_interval),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
+        {"index_block_restart_interval",
+         {offsetof(struct TableProperties, index_block_restart_interval),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
+        {"separate_key_value_in_data_block",
+         {offsetof(struct TableProperties, separate_key_value_in_data_block),
+          OptionType::kUInt64T, OptionVerificationType::kNormal,
+          OptionTypeFlags::kNone}},
         {"db_id",
          {offsetof(struct TableProperties, db_id), OptionType::kEncodedString}},
         {"db_session_id",

package/deps/rocksdb/rocksdb/table/table_reader_bench.cc

@@ -84,7 +84,7 @@ void TableReaderBenchmark(Options& opts, EnvOptions& env_options,
   Env* env = Env::Default();
   auto* clock = env->GetSystemClock().get();
   TableBuilder* tb = nullptr;
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   Status s;
   const ImmutableOptions ioptions(opts);
   const ColumnFamilyOptions cfo(opts);
@@ -257,8 +257,7 @@ void TableReaderBenchmark(Options& opts, EnvOptions& env_options,
   if (!through_db) {
     env->DeleteFile(file_name);
   } else {
-    delete db;
-    db = nullptr;
+    db.reset();
     DestroyDB(dbname, opts);
   }
 }