@nxtedition/rocksdb 10.0.13 → 10.0.15

package/deps/rocksdb/rocksdb/db/version_util.h

@@ -25,7 +25,10 @@ class OfflineManifestWriter {
                         options.table_cache_numshardbits)),
         versions_(db_path, &immutable_db_options_, sopt_, tc_.get(), &wb_, &wc_,
                   /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-                  /*db_id*/ "", /*db_session_id*/ "") {}
+                  /*db_id=*/"", /*db_session_id=*/"",
+                  options.daily_offpeak_time_utc,
+                  /*error_handler=*/nullptr,
+                  /*read_only=*/false) {}
 
   Status Recover(const std::vector<ColumnFamilyDescriptor>& column_families) {
     return versions_.Recover(column_families, /*read_only*/ false,
@@ -33,15 +36,17 @@ class OfflineManifestWriter {
                              /*no_error_if_files_missing*/ true);
   }
 
-  Status LogAndApply(const ReadOptions& read_options, ColumnFamilyData* cfd,
+  Status LogAndApply(const ReadOptions& read_options,
+                     const WriteOptions& write_options, ColumnFamilyData* cfd,
                      VersionEdit* edit,
                      FSDirectory* dir_contains_current_file) {
     // Use `mutex` to imitate a locked DB mutex when calling `LogAndApply()`.
     InstrumentedMutex mutex;
     mutex.Lock();
-    Status s = versions_.LogAndApply(
-        cfd, *cfd->GetLatestMutableCFOptions(), read_options, edit, &mutex,
-        dir_contains_current_file, false /* new_descriptor_log */);
+    Status s = versions_.LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
+                                     read_options, write_options, edit, &mutex,
+                                     dir_contains_current_file,
+                                     false /* new_descriptor_log */);
     mutex.Unlock();
     return s;
   }

package/deps/rocksdb/rocksdb/db/wal_manager.cc

@@ -153,15 +153,19 @@ void WalManager::PurgeObsoleteWALFiles() {
     return;
   }
   uint64_t const now_seconds = static_cast<uint64_t>(current_time);
-  uint64_t const time_to_check = (ttl_enabled && !size_limit_enabled)
-                                     ? db_options_.WAL_ttl_seconds / 2
-                                     : kDefaultIntervalToDeleteObsoleteWAL;
-
-  if (purge_wal_files_last_run_ + time_to_check > now_seconds) {
-    return;
-  }
-
-  purge_wal_files_last_run_ = now_seconds;
+  uint64_t const time_to_check =
+      ttl_enabled
+          ? std::min(kDefaultIntervalToDeleteObsoleteWAL,
+                     std::max(uint64_t{1}, db_options_.WAL_ttl_seconds / 2))
+          : kDefaultIntervalToDeleteObsoleteWAL;
+  uint64_t old_last_run_time = purge_wal_files_last_run_.LoadRelaxed();
+  do {
+    if (old_last_run_time + time_to_check > now_seconds) {
+      // last run is recent enough, no need to purge
+      return;
+    }
+  } while (!purge_wal_files_last_run_.CasWeakRelaxed(
+      /*expected=*/old_last_run_time, /*desired=*/now_seconds));
 
   std::string archival_dir = ArchivalDirectory(wal_dir_);
   std::vector<std::string> files;
@@ -333,8 +337,8 @@ Status WalManager::GetSortedWalsOfType(const std::string& path,
         return s;
       }
 
-      log_files.push_back(std::unique_ptr<LogFile>(
-          new LogFileImpl(number, log_type, sequence, size_bytes)));
+      log_files.emplace_back(
+          new LogFileImpl(number, log_type, sequence, size_bytes));
     }
   }
   std::sort(

package/deps/rocksdb/rocksdb/db/wal_manager.h

@@ -25,6 +25,7 @@
 #include "rocksdb/status.h"
 #include "rocksdb/transaction_log.h"
 #include "rocksdb/types.h"
+#include "util/atomic.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -118,7 +119,7 @@ class WalManager {
   port::Mutex read_first_record_cache_mutex_;
 
   // last time when PurgeObsoleteWALFiles ran.
-  uint64_t purge_wal_files_last_run_;
+  RelaxedAtomic<uint64_t> purge_wal_files_last_run_;
 
   bool seq_per_batch_;
 

package/deps/rocksdb/rocksdb/db/wal_manager_test.cc

@@ -50,11 +50,12 @@ class WalManagerTest : public testing::Test {
     db_options_.fs = env_->GetFileSystem();
     db_options_.clock = env_->GetSystemClock().get();
 
-    versions_.reset(
-        new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get(),
-                       &write_buffer_manager_, &write_controller_,
-                       /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-                       /*db_id*/ "", /*db_session_id*/ ""));
+    versions_.reset(new VersionSet(
+        dbname_, &db_options_, env_options_, table_cache_.get(),
+        &write_buffer_manager_, &write_controller_,
+        /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
+        /*db_id=*/"", /*db_session_id=*/"", /*daily_offpeak_time_utc=*/"",
+        /*error_handler=*/nullptr, /*read_only=*/false));
 
     wal_manager_.reset(
         new WalManager(db_options_, env_options_, nullptr /*IOTracer*/));
@@ -72,8 +73,8 @@ class WalManagerTest : public testing::Test {
     WriteBatch batch;
     ASSERT_OK(batch.Put(key, value));
     WriteBatchInternal::SetSequence(&batch, seq);
-    ASSERT_OK(
-        current_log_writer_->AddRecord(WriteBatchInternal::Contents(&batch)));
+    ASSERT_OK(current_log_writer_->AddRecord(
+        WriteOptions(), WriteBatchInternal::Contents(&batch)));
     versions_->SetLastAllocatedSequence(seq);
     versions_->SetLastPublishedSequence(seq);
     versions_->SetLastSequence(seq);
@@ -145,7 +146,8 @@ TEST_F(WalManagerTest, ReadFirstRecordCache) {
   WriteBatch batch;
   ASSERT_OK(batch.Put("foo", "bar"));
   WriteBatchInternal::SetSequence(&batch, 10);
-  ASSERT_OK(writer.AddRecord(WriteBatchInternal::Contents(&batch)));
+  ASSERT_OK(
+      writer.AddRecord(WriteOptions(), WriteBatchInternal::Contents(&batch)));
 
   // TODO(icanadi) move SpecialEnv outside of db_test, so we can reuse it here.
   // Waiting for lei to finish with db_test
@@ -333,4 +335,3 @@ int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-

package/deps/rocksdb/rocksdb/db/wide/db_wide_basic_test.cc

@@ -94,7 +94,7 @@ TEST_F(DBWideBasicTest, PutEntity) {
       std::array<Status, num_keys> statuses;
 
       db_->MultiGet(ReadOptions(), db_->DefaultColumnFamily(), num_keys,
-                    &keys[0], &values[0], &statuses[0]);
+                    keys.data(), values.data(), statuses.data());
 
       ASSERT_OK(statuses[0]);
       ASSERT_EQ(values[0], first_value_of_default_column);
@@ -114,7 +114,7 @@ TEST_F(DBWideBasicTest, PutEntity) {
       std::array<Status, num_keys> statuses;
 
       db_->MultiGetEntity(ReadOptions(), db_->DefaultColumnFamily(), num_keys,
-                          &keys[0], &results[0], &statuses[0]);
+                          keys.data(), results.data(), statuses.data());
 
       ASSERT_OK(statuses[0]);
       ASSERT_EQ(results[0].columns(), first_columns);
@@ -236,6 +236,144 @@ TEST_F(DBWideBasicTest, PutEntityColumnFamily) {
   ASSERT_OK(db_->Write(WriteOptions(), &batch));
 }
 
+TEST_F(DBWideBasicTest, GetEntityAsPinnableAttributeGroups) {
+  Options options = GetDefaultOptions();
+  CreateAndReopenWithCF({"hot_cf", "cold_cf"}, options);
+
+  constexpr int kDefaultCfHandleIndex = 0;
+  constexpr int kHotCfHandleIndex = 1;
+  constexpr int kColdCfHandleIndex = 2;
+
+  constexpr char first_key[] = "first";
+  WideColumns first_default_columns{
+      {"default_cf_col_1_name", "first_key_default_cf_col_1_value"},
+      {"default_cf_col_2_name", "first_key_default_cf_col_2_value"}};
+  WideColumns first_hot_columns{
+      {"hot_cf_col_1_name", "first_key_hot_cf_col_1_value"},
+      {"hot_cf_col_2_name", "first_key_hot_cf_col_2_value"}};
+  WideColumns first_cold_columns{
+      {"cold_cf_col_1_name", "first_key_cold_cf_col_1_value"}};
+
+  constexpr char second_key[] = "second";
+  WideColumns second_hot_columns{
+      {"hot_cf_col_1_name", "second_key_hot_cf_col_1_value"}};
+  WideColumns second_cold_columns{
+      {"cold_cf_col_1_name", "second_key_cold_cf_col_1_value"}};
+
+  AttributeGroups first_key_attribute_groups{
+      AttributeGroup(handles_[kDefaultCfHandleIndex], first_default_columns),
+      AttributeGroup(handles_[kHotCfHandleIndex], first_hot_columns),
+      AttributeGroup(handles_[kColdCfHandleIndex], first_cold_columns)};
+  AttributeGroups second_key_attribute_groups{
+      AttributeGroup(handles_[kHotCfHandleIndex], second_hot_columns),
+      AttributeGroup(handles_[kColdCfHandleIndex], second_cold_columns)};
+  ASSERT_OK(
+      db_->PutEntity(WriteOptions(), first_key, first_key_attribute_groups));
+  ASSERT_OK(
+      db_->PutEntity(WriteOptions(), second_key, second_key_attribute_groups));
+
+  std::vector<ColumnFamilyHandle*> all_cfs = handles_;
+  std::vector<ColumnFamilyHandle*> default_and_hot_cfs{
+      {handles_[kDefaultCfHandleIndex], handles_[kHotCfHandleIndex]}};
+  std::vector<ColumnFamilyHandle*> hot_and_cold_cfs{
+      {handles_[kHotCfHandleIndex], handles_[kColdCfHandleIndex]}};
+  std::vector<ColumnFamilyHandle*> default_null_and_hot_cfs{
+      handles_[kDefaultCfHandleIndex], nullptr, handles_[kHotCfHandleIndex],
+      nullptr};
+  auto create_result =
+      [](const std::vector<ColumnFamilyHandle*>& column_families)
+      -> PinnableAttributeGroups {
+    PinnableAttributeGroups result;
+    for (size_t i = 0; i < column_families.size(); ++i) {
+      result.emplace_back(column_families[i]);
+    }
+    return result;
+  };
+  {
+    // Case 1. Invalid Argument (passing in null CF)
+    AttributeGroups ag{
+        AttributeGroup(nullptr, first_default_columns),
+        AttributeGroup(handles_[kHotCfHandleIndex], first_hot_columns)};
+    ASSERT_NOK(db_->PutEntity(WriteOptions(), first_key, ag));
+
+    PinnableAttributeGroups result = create_result(default_null_and_hot_cfs);
+    Status s = db_->GetEntity(ReadOptions(), first_key, &result);
+    ASSERT_NOK(s);
+    ASSERT_TRUE(s.IsInvalidArgument());
+    // Valid CF, but failed with Incomplete status due to other attribute groups
+    ASSERT_TRUE(result[0].status().IsIncomplete());
+    // Null CF
+    ASSERT_TRUE(result[1].status().IsInvalidArgument());
+    // Valid CF, but failed with Incomplete status due to other attribute groups
+    ASSERT_TRUE(result[2].status().IsIncomplete());
+    // Null CF, but failed with Incomplete status because the nullcheck break
+    // out early in the loop
+    ASSERT_TRUE(result[3].status().IsIncomplete());
+  }
+  {
+    // Case 2. Get first key from default cf and hot_cf and second key from
+    // hot_cf and cold_cf
+    constexpr size_t num_column_families = 2;
+    PinnableAttributeGroups first_key_result =
+        create_result(default_and_hot_cfs);
+    PinnableAttributeGroups second_key_result = create_result(hot_and_cold_cfs);
+
+    // GetEntity for first_key
+    ASSERT_OK(db_->GetEntity(ReadOptions(), first_key, &first_key_result));
+    ASSERT_EQ(num_column_families, first_key_result.size());
+    // We expect to get values for all keys and CFs
+    for (size_t i = 0; i < num_column_families; ++i) {
+      ASSERT_OK(first_key_result[i].status());
+    }
+    // verify values for first key (default cf and hot cf)
+    ASSERT_EQ(first_default_columns, first_key_result[0].columns());
+    ASSERT_EQ(first_hot_columns, first_key_result[1].columns());
+
+    // GetEntity for second_key
+    ASSERT_OK(db_->GetEntity(ReadOptions(), second_key, &second_key_result));
+    ASSERT_EQ(num_column_families, second_key_result.size());
+    // We expect to get values for all keys and CFs
+    for (size_t i = 0; i < num_column_families; ++i) {
+      ASSERT_OK(second_key_result[i].status());
+    }
+    // verify values for second key (hot cf and cold cf)
+    ASSERT_EQ(second_hot_columns, second_key_result[0].columns());
+    ASSERT_EQ(second_cold_columns, second_key_result[1].columns());
+  }
+  {
+    // Case 3. Get first key and second key from all cfs. For the second key, we
+    // don't expect to get columns from default cf.
+    constexpr size_t num_column_families = 3;
+    PinnableAttributeGroups first_key_result = create_result(all_cfs);
+    PinnableAttributeGroups second_key_result = create_result(all_cfs);
+
+    // GetEntity for first_key
+    ASSERT_OK(db_->GetEntity(ReadOptions(), first_key, &first_key_result));
+    ASSERT_EQ(num_column_families, first_key_result.size());
+    // We expect to get values for all keys and CFs
+    for (size_t i = 0; i < num_column_families; ++i) {
+      ASSERT_OK(first_key_result[i].status());
+    }
+    // verify values for first key
+    ASSERT_EQ(first_default_columns, first_key_result[0].columns());
+    ASSERT_EQ(first_hot_columns, first_key_result[1].columns());
+    ASSERT_EQ(first_cold_columns, first_key_result[2].columns());
+
+    // GetEntity for second_key
+    ASSERT_OK(db_->GetEntity(ReadOptions(), second_key, &second_key_result));
+    ASSERT_EQ(num_column_families, second_key_result.size());
+    // key does not exist in default cf
+    ASSERT_NOK(second_key_result[0].status());
+    ASSERT_TRUE(second_key_result[0].status().IsNotFound());
+
+    // verify values for second key (hot cf and cold cf)
+    ASSERT_OK(second_key_result[1].status());
+    ASSERT_OK(second_key_result[2].status());
+    ASSERT_EQ(second_hot_columns, second_key_result[1].columns());
+    ASSERT_EQ(second_cold_columns, second_key_result[2].columns());
+  }
+}
+
 TEST_F(DBWideBasicTest, MultiCFMultiGetEntity) {
   Options options = GetDefaultOptions();
   CreateAndReopenWithCF({"corinthian"}, options);
@@ -260,8 +398,8 @@ TEST_F(DBWideBasicTest, MultiCFMultiGetEntity) {
   std::array<PinnableWideColumns, num_keys> results;
   std::array<Status, num_keys> statuses;
 
-  db_->MultiGetEntity(ReadOptions(), num_keys, &column_families[0], &keys[0],
-                      &results[0], &statuses[0]);
+  db_->MultiGetEntity(ReadOptions(), num_keys, column_families.data(),
+                      keys.data(), results.data(), statuses.data());
 
   ASSERT_OK(statuses[0]);
   ASSERT_EQ(results[0].columns(), first_columns);
@@ -274,9 +412,9 @@ TEST_F(DBWideBasicTest, MultiCFMultiGetEntityAsPinnableAttributeGroups) {
   Options options = GetDefaultOptions();
   CreateAndReopenWithCF({"hot_cf", "cold_cf"}, options);
 
-  constexpr int DEFAULT_CF_HANDLE_INDEX = 0;
-  constexpr int HOT_CF_HANDLE_INDEX = 1;
-  constexpr int COLD_CF_HANDLE_INDEX = 2;
+  constexpr int kDefaultCfHandleIndex = 0;
+  constexpr int kHotCfHandleIndex = 1;
+  constexpr int kColdCfHandleIndex = 2;
 
   constexpr char first_key[] = "first";
   WideColumns first_default_columns{
@@ -293,25 +431,28 @@ TEST_F(DBWideBasicTest, MultiCFMultiGetEntityAsPinnableAttributeGroups) {
   WideColumns second_cold_columns{
       {"cold_cf_col_1_name", "second_key_cold_cf_col_1_value"}};
 
-  // TODO - update this to use the multi-attribute-group PutEntity when ready
-  ASSERT_OK(db_->PutEntity(WriteOptions(), handles_[DEFAULT_CF_HANDLE_INDEX],
-                           first_key, first_default_columns));
-  ASSERT_OK(db_->PutEntity(WriteOptions(), handles_[HOT_CF_HANDLE_INDEX],
-                           first_key, first_hot_columns));
-  ASSERT_OK(db_->PutEntity(WriteOptions(), handles_[COLD_CF_HANDLE_INDEX],
-                           first_key, first_cold_columns));
-  ASSERT_OK(db_->PutEntity(WriteOptions(), handles_[HOT_CF_HANDLE_INDEX],
-                           second_key, second_hot_columns));
-  ASSERT_OK(db_->PutEntity(WriteOptions(), handles_[COLD_CF_HANDLE_INDEX],
-                           second_key, second_cold_columns));
+  AttributeGroups first_key_attribute_groups{
+      AttributeGroup(handles_[kDefaultCfHandleIndex], first_default_columns),
+      AttributeGroup(handles_[kHotCfHandleIndex], first_hot_columns),
+      AttributeGroup(handles_[kColdCfHandleIndex], first_cold_columns)};
+  AttributeGroups second_key_attribute_groups{
+      AttributeGroup(handles_[kHotCfHandleIndex], second_hot_columns),
+      AttributeGroup(handles_[kColdCfHandleIndex], second_cold_columns)};
+
+  ASSERT_OK(
+      db_->PutEntity(WriteOptions(), first_key, first_key_attribute_groups));
+  ASSERT_OK(
+      db_->PutEntity(WriteOptions(), second_key, second_key_attribute_groups));
 
   constexpr size_t num_keys = 2;
   std::array<Slice, num_keys> keys = {first_key, second_key};
   std::vector<ColumnFamilyHandle*> all_cfs = handles_;
   std::vector<ColumnFamilyHandle*> default_and_hot_cfs{
-      {handles_[DEFAULT_CF_HANDLE_INDEX], handles_[HOT_CF_HANDLE_INDEX]}};
+      {handles_[kDefaultCfHandleIndex], handles_[kHotCfHandleIndex]}};
   std::vector<ColumnFamilyHandle*> hot_and_cold_cfs{
-      {handles_[HOT_CF_HANDLE_INDEX], handles_[COLD_CF_HANDLE_INDEX]}};
+      {handles_[kHotCfHandleIndex], handles_[kColdCfHandleIndex]}};
+  std::vector<ColumnFamilyHandle*> null_and_hot_cfs{
+      nullptr, handles_[kHotCfHandleIndex], nullptr};
   auto create_result =
       [](const std::vector<ColumnFamilyHandle*>& column_families)
       -> PinnableAttributeGroups {
@@ -322,7 +463,7 @@ TEST_F(DBWideBasicTest, MultiCFMultiGetEntityAsPinnableAttributeGroups) {
     return result;
   };
   {
-    // Check for invalid argument
+    // Check for invalid read option argument
     ReadOptions read_options;
     read_options.io_activity = Env::IOActivity::kGetEntity;
     std::vector<PinnableAttributeGroups> results;
@@ -336,6 +477,31 @@ TEST_F(DBWideBasicTest, MultiCFMultiGetEntityAsPinnableAttributeGroups) {
         ASSERT_TRUE(results[i][j].status().IsInvalidArgument());
       }
     }
+    // Check for invalid column family in Attribute Group result
+    results.clear();
+    results.emplace_back(create_result(null_and_hot_cfs));
+    results.emplace_back(create_result(all_cfs));
+    db_->MultiGetEntity(ReadOptions(), num_keys, keys.data(), results.data());
+
+    // First one failed due to null CFs in the AttributeGroup
+    // Null CF
+    ASSERT_NOK(results[0][0].status());
+    ASSERT_TRUE(results[0][0].status().IsInvalidArgument());
+    // Valid CF, but failed with incomplete status because of other attribute
+    // groups
+    ASSERT_NOK(results[0][1].status());
+    ASSERT_TRUE(results[0][1].status().IsIncomplete());
+    // Null CF
+    ASSERT_NOK(results[0][2].status());
+    ASSERT_TRUE(results[0][2].status().IsInvalidArgument());
+
+    // Second one failed with Incomplete because first one failed
+    ASSERT_NOK(results[1][0].status());
+    ASSERT_TRUE(results[1][0].status().IsIncomplete());
+    ASSERT_NOK(results[1][1].status());
+    ASSERT_TRUE(results[1][1].status().IsIncomplete());
+    ASSERT_NOK(results[1][2].status());
+    ASSERT_TRUE(results[1][2].status().IsIncomplete());
   }
   {
     // Case 1. Get first key from default cf and hot_cf and second key from
@@ -476,7 +642,7 @@ TEST_F(DBWideBasicTest, MergePlainKeyValue) {
       std::array<Status, num_keys> statuses;
 
       db_->MultiGetEntity(ReadOptions(), db_->DefaultColumnFamily(), num_keys,
-                          &keys[0], &results[0], &statuses[0]);
+                          keys.data(), results.data(), statuses.data());
 
       ASSERT_OK(statuses[0]);
       ASSERT_EQ(results[0].columns(), expected_first_columns);
@@ -656,7 +822,7 @@ TEST_F(DBWideBasicTest, MergeEntity) {
       std::array<Status, num_keys> statuses;
 
       db_->MultiGet(ReadOptions(), db_->DefaultColumnFamily(), num_keys,
-                    &keys[0], &values[0], &statuses[0]);
+                    keys.data(), values.data(), statuses.data());
 
       ASSERT_EQ(values[0], first_expected_default);
       ASSERT_OK(statuses[0]);
@@ -673,7 +839,7 @@ TEST_F(DBWideBasicTest, MergeEntity) {
       std::array<Status, num_keys> statuses;
 
       db_->MultiGetEntity(ReadOptions(), db_->DefaultColumnFamily(), num_keys,
-                          &keys[0], &results[0], &statuses[0]);
+                          keys.data(), results.data(), statuses.data());
 
       ASSERT_OK(statuses[0]);
       ASSERT_EQ(results[0].columns(), first_expected_columns);
@@ -734,7 +900,7 @@ TEST_F(DBWideBasicTest, MergeEntity) {
       int number_of_operands = 0;
 
       ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(),
-                                      first_key, &merge_operands[0],
+                                      first_key, merge_operands.data(),
                                       &get_merge_opts, &number_of_operands));
 
       ASSERT_EQ(number_of_operands, num_merge_operands);
@@ -747,7 +913,7 @@ TEST_F(DBWideBasicTest, MergeEntity) {
       int number_of_operands = 0;
 
       ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(),
-                                      second_key, &merge_operands[0],
+                                      second_key, merge_operands.data(),
                                       &get_merge_opts, &number_of_operands));
 
       ASSERT_EQ(number_of_operands, num_merge_operands);
@@ -767,7 +933,7 @@ TEST_F(DBWideBasicTest, MergeEntity) {
       int number_of_operands = 0;
 
       ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(),
-                                      first_key, &merge_operands[0],
+                                      first_key, merge_operands.data(),
                                       &get_merge_opts, &number_of_operands));
 
       ASSERT_EQ(number_of_operands, num_merge_operands);
@@ -779,7 +945,7 @@ TEST_F(DBWideBasicTest, MergeEntity) {
       int number_of_operands = 0;
 
       ASSERT_OK(db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(),
-                                      second_key, &merge_operands[0],
+                                      second_key, merge_operands.data(),
                                       &get_merge_opts, &number_of_operands));
 
       ASSERT_EQ(number_of_operands, num_merge_operands);
@@ -1557,6 +1723,215 @@ TEST_F(DBWideBasicTest, PutEntitySerializationError) {
   ASSERT_OK(db_->Write(WriteOptions(), &batch));
 }
 
+TEST_F(DBWideBasicTest, PinnableWideColumnsMove) {
+  Options options = GetDefaultOptions();
+
+  constexpr char key1[] = "foo";
+  constexpr char value[] = "bar";
+  ASSERT_OK(db_->Put(WriteOptions(), db_->DefaultColumnFamily(), key1, value));
+
+  constexpr char key2[] = "baz";
+  const WideColumns columns{{"quux", "corge"}};
+  ASSERT_OK(db_->PutEntity(WriteOptions(), db_->DefaultColumnFamily(), key2,
+                           columns));
+
+  ASSERT_OK(db_->Flush(FlushOptions()));
+
+  const auto test_move = [&](bool fill_cache) {
+    ReadOptions read_options;
+    read_options.fill_cache = fill_cache;
+
+    {
+      const WideColumns expected_columns{{kDefaultWideColumnName, value}};
+
+      {
+        PinnableWideColumns result;
+        ASSERT_OK(db_->GetEntity(read_options, db_->DefaultColumnFamily(), key1,
+                                 &result));
+        ASSERT_EQ(result.columns(), expected_columns);
+
+        PinnableWideColumns move_target(std::move(result));
+        ASSERT_EQ(move_target.columns(), expected_columns);
+      }
+
+      {
+        PinnableWideColumns result;
+        ASSERT_OK(db_->GetEntity(read_options, db_->DefaultColumnFamily(), key1,
+                                 &result));
+        ASSERT_EQ(result.columns(), expected_columns);
+
+        PinnableWideColumns move_target;
+        move_target = std::move(result);
+        ASSERT_EQ(move_target.columns(), expected_columns);
+      }
+    }
+
+    {
+      PinnableWideColumns result;
+      ASSERT_OK(db_->GetEntity(read_options, db_->DefaultColumnFamily(), key2,
+                               &result));
+      ASSERT_EQ(result.columns(), columns);
+
+      PinnableWideColumns move_target(std::move(result));
+      ASSERT_EQ(move_target.columns(), columns);
+    }
+
+    {
+      PinnableWideColumns result;
+      ASSERT_OK(db_->GetEntity(read_options, db_->DefaultColumnFamily(), key2,
+                               &result));
+      ASSERT_EQ(result.columns(), columns);
+
+      PinnableWideColumns move_target;
+      move_target = std::move(result);
+      ASSERT_EQ(move_target.columns(), columns);
+    }
+  };
+
+  // Test with and without fill_cache to cover both the case when pointers are
+  // invalidated during PinnableSlice's move and when they are not.
+  test_move(/* fill_cache*/ false);
+  test_move(/* fill_cache*/ true);
+}
+
+TEST_F(DBWideBasicTest, SanityChecks) {
+  constexpr char foo[] = "foo";
+  constexpr char bar[] = "bar";
+  constexpr size_t num_keys = 2;
+
+  {
+    constexpr ColumnFamilyHandle* column_family = nullptr;
+    PinnableWideColumns columns;
+    ASSERT_TRUE(db_->GetEntity(ReadOptions(), column_family, foo, &columns)
+                    .IsInvalidArgument());
+  }
+
+  {
+    constexpr PinnableWideColumns* columns = nullptr;
+    ASSERT_TRUE(
+        db_->GetEntity(ReadOptions(), db_->DefaultColumnFamily(), foo, columns)
+            .IsInvalidArgument());
+  }
+
+  {
+    ReadOptions read_options;
+    read_options.io_activity = Env::IOActivity::kGet;
+
+    PinnableWideColumns columns;
+    ASSERT_TRUE(
+        db_->GetEntity(read_options, db_->DefaultColumnFamily(), foo, &columns)
+            .IsInvalidArgument());
+  }
+
+  {
+    constexpr ColumnFamilyHandle* column_family = nullptr;
+    std::array<Slice, num_keys> keys{{foo, bar}};
+    std::array<PinnableWideColumns, num_keys> results;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGetEntity(ReadOptions(), column_family, num_keys, keys.data(),
+                        results.data(), statuses.data());
+
+    ASSERT_TRUE(statuses[0].IsInvalidArgument());
+    ASSERT_TRUE(statuses[1].IsInvalidArgument());
+  }
+
+  {
+    constexpr Slice* keys = nullptr;
+    std::array<PinnableWideColumns, num_keys> results;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGetEntity(ReadOptions(), db_->DefaultColumnFamily(), num_keys,
+                        keys, results.data(), statuses.data());
+
+    ASSERT_TRUE(statuses[0].IsInvalidArgument());
+    ASSERT_TRUE(statuses[1].IsInvalidArgument());
+  }
+
+  {
+    std::array<Slice, num_keys> keys{{foo, bar}};
+    constexpr PinnableWideColumns* results = nullptr;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGetEntity(ReadOptions(), db_->DefaultColumnFamily(), num_keys,
+                        keys.data(), results, statuses.data());
+
+    ASSERT_TRUE(statuses[0].IsInvalidArgument());
+    ASSERT_TRUE(statuses[1].IsInvalidArgument());
+  }
+
+  {
+    ReadOptions read_options;
+    read_options.io_activity = Env::IOActivity::kMultiGet;
+
+    std::array<Slice, num_keys> keys{{foo, bar}};
+    std::array<PinnableWideColumns, num_keys> results;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGetEntity(read_options, db_->DefaultColumnFamily(), num_keys,
+                        keys.data(), results.data(), statuses.data());
+    ASSERT_TRUE(statuses[0].IsInvalidArgument());
+    ASSERT_TRUE(statuses[1].IsInvalidArgument());
+  }
+
+  {
+    constexpr ColumnFamilyHandle** column_families = nullptr;
+    std::array<Slice, num_keys> keys{{foo, bar}};
+    std::array<PinnableWideColumns, num_keys> results;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGetEntity(ReadOptions(), num_keys, column_families, keys.data(),
+                        results.data(), statuses.data());
+
+    ASSERT_TRUE(statuses[0].IsInvalidArgument());
+    ASSERT_TRUE(statuses[1].IsInvalidArgument());
+  }
+
+  {
+    std::array<ColumnFamilyHandle*, num_keys> column_families{
+        {db_->DefaultColumnFamily(), db_->DefaultColumnFamily()}};
+    constexpr Slice* keys = nullptr;
+    std::array<PinnableWideColumns, num_keys> results;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGetEntity(ReadOptions(), num_keys, column_families.data(), keys,
+                        results.data(), statuses.data());
+
+    ASSERT_TRUE(statuses[0].IsInvalidArgument());
+    ASSERT_TRUE(statuses[1].IsInvalidArgument());
+  }
+
+  {
+    std::array<ColumnFamilyHandle*, num_keys> column_families{
+        {db_->DefaultColumnFamily(), db_->DefaultColumnFamily()}};
+    std::array<Slice, num_keys> keys{{foo, bar}};
+    constexpr PinnableWideColumns* results = nullptr;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGetEntity(ReadOptions(), num_keys, column_families.data(),
+                        keys.data(), results, statuses.data());
+
+    ASSERT_TRUE(statuses[0].IsInvalidArgument());
+    ASSERT_TRUE(statuses[1].IsInvalidArgument());
+  }
+
+  {
+    ReadOptions read_options;
+    read_options.io_activity = Env::IOActivity::kMultiGet;
+
+    std::array<ColumnFamilyHandle*, num_keys> column_families{
+        {db_->DefaultColumnFamily(), db_->DefaultColumnFamily()}};
+    std::array<Slice, num_keys> keys{{foo, bar}};
+    std::array<PinnableWideColumns, num_keys> results;
+    std::array<Status, num_keys> statuses;
+
+    db_->MultiGetEntity(read_options, num_keys, column_families.data(),
+                        keys.data(), results.data(), statuses.data());
+    ASSERT_TRUE(statuses[0].IsInvalidArgument());
+    ASSERT_TRUE(statuses[1].IsInvalidArgument());
+  }
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {