rocksdb-native 2.2.0 → 2.3.0

package/vendor/librocksdb/vendor/rocksdb/utilities/option_change_migration/option_change_migration.cc

@@ -160,14 +160,7 @@ Status OptionChangeMigration(std::string dbname, const Options& old_opts,
     return MigrateToLevelBase(dbname, old_opts, new_opts);
   } else if (new_opts.compaction_style ==
              CompactionStyle::kCompactionStyleFIFO) {
-    uint64_t l0_file_size = 0;
-    if (new_opts.compaction_options_fifo.max_table_files_size > 0) {
-      // Create at least 8 files when max_table_files_size hits, so that the DB
-      // doesn't just disappear. This in fact violates the FIFO condition, but
-      // otherwise, the migrated DB is unlikley to be usable.
-      l0_file_size = new_opts.compaction_options_fifo.max_table_files_size / 8;
-    }
-    return CompactToLevel(old_opts, dbname, 0, l0_file_size, true);
+    return CompactToLevel(old_opts, dbname, 0, 0 /* l0_file_size */, true);
   } else {
     return Status::NotSupported(
         "Do not how to migrate to this compaction style");

package/vendor/librocksdb/vendor/rocksdb/utilities/table_properties_collectors/compact_for_tiering_collector.cc

@@ -0,0 +1,144 @@
+//  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 "utilities/table_properties_collectors/compact_for_tiering_collector.h"
+
+#include <sstream>
+
+#include "db/seqno_to_time_mapping.h"
+#include "rocksdb/status.h"
+#include "rocksdb/types.h"
+#include "rocksdb/utilities/customizable_util.h"
+#include "rocksdb/utilities/object_registry.h"
+#include "rocksdb/utilities/options_type.h"
+#include "rocksdb/utilities/table_properties_collectors.h"
+#include "util/string_util.h"
+
+namespace ROCKSDB_NAMESPACE {
+const std::string
+    CompactForTieringCollector::kNumEligibleLastLevelEntriesPropertyName =
+        "rocksdb.eligible.last.level.entries";
+
+CompactForTieringCollector::CompactForTieringCollector(
+    SequenceNumber last_level_inclusive_max_seqno_threshold,
+    double compaction_trigger_ratio)
+    : last_level_inclusive_max_seqno_threshold_(
+          last_level_inclusive_max_seqno_threshold),
+      compaction_trigger_ratio_(compaction_trigger_ratio) {
+  assert(last_level_inclusive_max_seqno_threshold_ != kMaxSequenceNumber);
+}
+
+Status CompactForTieringCollector::AddUserKey(const Slice& /*key*/,
+                                              const Slice& value,
+                                              EntryType type,
+                                              SequenceNumber seq,
+                                              uint64_t /*file_size*/) {
+  SequenceNumber seq_for_check = seq;
+  if (type == kEntryTimedPut) {
+    seq_for_check = ParsePackedValueForSeqno(value);
+  }
+  if (seq_for_check < last_level_inclusive_max_seqno_threshold_) {
+    last_level_eligible_entries_counter_++;
+  }
+  total_entries_counter_ += 1;
+  return Status::OK();
+}
+
+Status CompactForTieringCollector::Finish(UserCollectedProperties* properties) {
+  assert(!finish_called_);
+  assert(compaction_trigger_ratio_ > 0);
+  if (last_level_eligible_entries_counter_ >=
+      compaction_trigger_ratio_ * total_entries_counter_) {
+    assert(compaction_trigger_ratio_ <= 1);
+    need_compaction_ = true;
+  }
+  if (last_level_eligible_entries_counter_ > 0) {
+    *properties = UserCollectedProperties{
+        {kNumEligibleLastLevelEntriesPropertyName,
+         std::to_string(last_level_eligible_entries_counter_)},
+    };
+  }
+  finish_called_ = true;
+  return Status::OK();
+}
+
+UserCollectedProperties CompactForTieringCollector::GetReadableProperties()
+    const {
+  return UserCollectedProperties{
+      {kNumEligibleLastLevelEntriesPropertyName,
+       std::to_string(last_level_eligible_entries_counter_)},
+  };
+}
+
+bool CompactForTieringCollector::NeedCompact() const {
+  return need_compaction_;
+}
+
+void CompactForTieringCollector::Reset() {
+  last_level_eligible_entries_counter_ = 0;
+  total_entries_counter_ = 0;
+  finish_called_ = false;
+  need_compaction_ = false;
+}
+
+TablePropertiesCollector*
+CompactForTieringCollectorFactory::CreateTablePropertiesCollector(
+    TablePropertiesCollectorFactory::Context context) {
+  double compaction_trigger_ratio = GetCompactionTriggerRatio();
+  if (compaction_trigger_ratio <= 0 ||
+      context.level_at_creation == context.num_levels - 1 ||
+      context.last_level_inclusive_max_seqno_threshold == kMaxSequenceNumber) {
+    return nullptr;
+  }
+  return new CompactForTieringCollector(
+      context.last_level_inclusive_max_seqno_threshold,
+      compaction_trigger_ratio);
+}
+
+static std::unordered_map<std::string, OptionTypeInfo>
+    on_compact_for_tiering_type_info = {
+        {"compaction_trigger_ratio",
+         {0, OptionType::kUnknown, OptionVerificationType::kNormal,
+          OptionTypeFlags::kCompareNever | OptionTypeFlags::kMutable,
+          [](const ConfigOptions&, const std::string&, const std::string& value,
+             void* addr) {
+            auto* factory =
+                static_cast<CompactForTieringCollectorFactory*>(addr);
+            factory->SetCompactionTriggerRatio(ParseDouble(value));
+            return Status::OK();
+          },
+          [](const ConfigOptions&, const std::string&, const void* addr,
+             std::string* value) {
+            const auto* factory =
+                static_cast<const CompactForTieringCollectorFactory*>(addr);
+            *value = std::to_string(factory->GetCompactionTriggerRatio());
+            return Status::OK();
+          },
+          nullptr}},
+
+};
+
+CompactForTieringCollectorFactory::CompactForTieringCollectorFactory(
+    double compaction_trigger_ratio)
+    : compaction_trigger_ratio_(compaction_trigger_ratio) {
+  RegisterOptions("", this, &on_compact_for_tiering_type_info);
+}
+
+std::string CompactForTieringCollectorFactory::ToString() const {
+  std::ostringstream cfg;
+  cfg << Name()
+      << ", compaction trigger ratio:" << compaction_trigger_ratio_.load()
+      << std::endl;
+  return cfg.str();
+}
+
+std::shared_ptr<CompactForTieringCollectorFactory>
+NewCompactForTieringCollectorFactory(double compaction_trigger_ratio) {
+  return std::make_shared<CompactForTieringCollectorFactory>(
+      compaction_trigger_ratio);
+}
+
+}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/utilities/table_properties_collectors/compact_for_tiering_collector.h

@@ -0,0 +1,45 @@
+//  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).
+
+#pragma once
+
+#include "rocksdb/utilities/table_properties_collectors.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// A user property collector that marks a SST file as need-compaction when for
+// the tiering use case. See documentation for
+// `CompactForTieringCollectorFactory`.
+class CompactForTieringCollector : public TablePropertiesCollector {
+ public:
+  static const std::string kNumEligibleLastLevelEntriesPropertyName;
+
+  CompactForTieringCollector(
+      SequenceNumber last_level_inclusive_max_seqno_threshold_,
+      double compaction_trigger_ratio);
+
+  Status AddUserKey(const Slice& key, const Slice& value, EntryType type,
+                    SequenceNumber seq, uint64_t file_size) override;
+
+  Status Finish(UserCollectedProperties* properties) override;
+
+  UserCollectedProperties GetReadableProperties() const override;
+
+  const char* Name() const override { return "CompactForTieringCollector"; }
+
+  bool NeedCompact() const override;
+
+ private:
+  void Reset();
+
+  SequenceNumber last_level_inclusive_max_seqno_threshold_;
+  double compaction_trigger_ratio_;
+  size_t last_level_eligible_entries_counter_ = 0;
+  size_t total_entries_counter_ = 0;
+  bool finish_called_ = false;
+  bool need_compaction_ = false;
+};
+}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/utilities/table_properties_collectors/compact_on_deletion_collector.cc

@@ -188,6 +188,7 @@ NewCompactOnDeletionCollectorFactory(size_t sliding_window_size,
       new CompactOnDeletionCollectorFactory(sliding_window_size,
                                             deletion_trigger, deletion_ratio));
 }
+
 namespace {
 static int RegisterTablePropertiesCollectorFactories(
     ObjectLibrary& library, const std::string& /*arg*/) {
@@ -202,6 +203,17 @@ static int RegisterTablePropertiesCollectorFactories(
         guard->reset(new CompactOnDeletionCollectorFactory(0, 0, 0));
         return guard->get();
       });
+  library.AddFactory<TablePropertiesCollectorFactory>(
+      CompactForTieringCollectorFactory::kClassName(),
+      [](const std::string& /*uri*/,
+         std::unique_ptr<TablePropertiesCollectorFactory>* guard,
+         std::string* /* errmsg */) {
+        // By default, create a `CompactForTieringCollectorFactory` that is
+        // disabled. Users will need to call corresponding setters to enable
+        // the factory.
+        guard->reset(new CompactForTieringCollectorFactory(0));
+        return guard->get();
+      });
   return 1;
 }
 }  // namespace

package/vendor/librocksdb/vendor/rocksdb/utilities/transactions/lock/range/range_tree/lib/portability/toku_time.h

@@ -165,7 +165,7 @@ static inline tokutime_t toku_time_now(void) {
 
 static inline uint64_t toku_current_time_microsec(void) {
   struct timeval t;
-  gettimeofday(&t, NULL);
+  gettimeofday(&t, nullptr);
   return t.tv_sec * (1UL * 1000 * 1000) + t.tv_usec;
 }
 

package/vendor/librocksdb/vendor/rocksdb/utilities/transactions/lock/range/range_tree/lib/util/growable_array.h

@@ -78,7 +78,7 @@ class GrowableArray {
   void init(void)
   // Effect: Initialize the array to contain no elements.
   {
-    m_array = NULL;
+    m_array = nullptr;
     m_size = 0;
     m_size_limit = 0;
   }
@@ -87,7 +87,7 @@ class GrowableArray {
   // Effect: Deinitialize the array (freeing any memory it uses, for example).
   {
     toku_free(m_array);
-    m_array = NULL;
+    m_array = nullptr;
     m_size = 0;
     m_size_limit = 0;
   }
@@ -113,7 +113,7 @@ class GrowableArray {
   // constant.
   {
     if (m_size >= m_size_limit) {
-      if (m_array == NULL) {
+      if (m_array == nullptr) {
         m_size_limit = 1;
       } else {
         m_size_limit *= 2;

package/vendor/librocksdb/vendor/rocksdb/utilities/transactions/pessimistic_transaction.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).
 
-
 #include "utilities/transactions/pessimistic_transaction.h"
 
 #include <map>
@@ -190,12 +189,9 @@ inline Status WriteCommittedTxn::GetForUpdateImpl(
     }
   }
 
-  if (!do_validate && kMaxTxnTimestamp != read_timestamp_) {
-    return Status::InvalidArgument(
-        "If do_validate is false then GetForUpdate with read_timestamp is not "
-        "defined.");
-  } else if (do_validate && kMaxTxnTimestamp == read_timestamp_) {
-    return Status::InvalidArgument("read_timestamp must be set for validation");
+  Status s = SanityCheckReadTimestamp(do_validate);
+  if (!s.ok()) {
+    return s;
   }
 
   if (!read_options.timestamp) {
@@ -218,6 +214,94 @@ inline Status WriteCommittedTxn::GetForUpdateImpl(
                                            value, exclusive, do_validate);
 }
 
+Status WriteCommittedTxn::GetEntityForUpdate(const ReadOptions& read_options,
+                                             ColumnFamilyHandle* column_family,
+                                             const Slice& key,
+                                             PinnableWideColumns* columns,
+                                             bool exclusive, bool do_validate) {
+  if (!column_family) {
+    return Status::InvalidArgument(
+        "Cannot call GetEntityForUpdate without a column family handle");
+  }
+
+  const Comparator* const ucmp = column_family->GetComparator();
+  assert(ucmp);
+  const size_t ts_sz = ucmp->timestamp_size();
+
+  if (ts_sz == 0) {
+    return TransactionBaseImpl::GetEntityForUpdate(
+        read_options, column_family, key, columns, exclusive, do_validate);
+  }
+
+  assert(ts_sz > 0);
+  Status s = SanityCheckReadTimestamp(do_validate);
+  if (!s.ok()) {
+    return s;
+  }
+
+  std::string ts_buf;
+  PutFixed64(&ts_buf, read_timestamp_);
+  Slice ts(ts_buf);
+
+  if (!read_options.timestamp) {
+    ReadOptions read_options_copy = read_options;
+    read_options_copy.timestamp = &ts;
+
+    return TransactionBaseImpl::GetEntityForUpdate(
+        read_options_copy, column_family, key, columns, exclusive, do_validate);
+  }
+
+  assert(read_options.timestamp);
+  if (*read_options.timestamp != ts) {
+    return Status::InvalidArgument("Must read from the same read timestamp");
+  }
+
+  return TransactionBaseImpl::GetEntityForUpdate(
+      read_options, column_family, key, columns, exclusive, do_validate);
+}
+
+Status WriteCommittedTxn::SanityCheckReadTimestamp(bool do_validate) {
+  bool enable_udt_validation =
+      txn_db_impl_->GetTxnDBOptions().enable_udt_validation;
+  if (!enable_udt_validation) {
+    if (kMaxTxnTimestamp != read_timestamp_) {
+      return Status::InvalidArgument(
+          "read_timestamp is set but timestamp validation is disabled for the "
+          "DB");
+    }
+  } else {
+    if (!do_validate) {
+      if (kMaxTxnTimestamp != read_timestamp_) {
+        return Status::InvalidArgument(
+            "If do_validate is false then GetForUpdate with read_timestamp is "
+            "not "
+            "defined.");
+      }
+    } else {
+      if (kMaxTxnTimestamp == read_timestamp_) {
+        return Status::InvalidArgument(
+            "read_timestamp must be set for validation");
+      }
+    }
+  }
+  return Status::OK();
+}
+
+Status WriteCommittedTxn::PutEntityImpl(ColumnFamilyHandle* column_family,
+                                        const Slice& key,
+                                        const WideColumns& columns,
+                                        bool do_validate, bool assume_tracked) {
+  return Operate(column_family, key, do_validate, assume_tracked,
+                 [column_family, &key, &columns, this]() {
+                   Status s = GetBatchForWrite()->PutEntity(column_family, key,
+                                                            columns);
+                   if (s.ok()) {
+                     ++num_put_entities_;
+                   }
+                   return s;
+                 });
+}
+
 Status WriteCommittedTxn::Put(ColumnFamilyHandle* column_family,
                               const Slice& key, const Slice& value,
                               const bool assume_tracked) {
@@ -428,7 +512,8 @@ Status WriteCommittedTxn::SetReadTimestampForValidation(TxnTimestamp ts) {
 }
 
 Status WriteCommittedTxn::SetCommitTimestamp(TxnTimestamp ts) {
-  if (read_timestamp_ < kMaxTxnTimestamp && ts <= read_timestamp_) {
+  if (txn_db_impl_->GetTxnDBOptions().enable_udt_validation &&
+      read_timestamp_ < kMaxTxnTimestamp && ts <= read_timestamp_) {
     return Status::InvalidArgument(
         "Cannot commit at timestamp smaller than or equal to read timestamp");
   }
@@ -570,9 +655,9 @@ Status WriteCommittedTxn::PrepareInternal() {
   SequenceNumber* const KIgnoreSeqUsed = nullptr;
   const size_t kNoBatchCount = 0;
   s = db_impl_->WriteImpl(write_options, GetWriteBatch()->GetWriteBatch(),
-                          kNoWriteCallback, &log_number_, kRefNoLog,
-                          kDisableMemtable, KIgnoreSeqUsed, kNoBatchCount,
-                          &mark_log_callback);
+                          kNoWriteCallback, /*user_write_cb=*/nullptr,
+                          &log_number_, kRefNoLog, kDisableMemtable,
+                          KIgnoreSeqUsed, kNoBatchCount, &mark_log_callback);
   return s;
 }
 
@@ -705,11 +790,11 @@ Status WriteCommittedTxn::CommitWithoutPrepareInternal() {
       post_mem_cb = &snapshot_creation_cb;
     }
   }
-  auto s = db_impl_->WriteImpl(write_options_, wb,
-                               /*callback*/ nullptr, /*log_used*/ nullptr,
-                               /*log_ref*/ 0, /*disable_memtable*/ false,
-                               &seq_used, /*batch_cnt=*/0,
-                               /*pre_release_callback=*/nullptr, post_mem_cb);
+  auto s = db_impl_->WriteImpl(
+      write_options_, wb,
+      /*callback*/ nullptr, /*user_write_cb=*/nullptr, /*log_used*/ nullptr,
+      /*log_ref*/ 0, /*disable_memtable*/ false, &seq_used, /*batch_cnt=*/0,
+      /*pre_release_callback=*/nullptr, post_mem_cb);
   assert(!s.ok() || seq_used != kMaxSequenceNumber);
   if (s.ok()) {
     SetId(seq_used);
@@ -720,6 +805,7 @@ Status WriteCommittedTxn::CommitWithoutPrepareInternal() {
 Status WriteCommittedTxn::CommitBatchInternal(WriteBatch* batch, size_t) {
   uint64_t seq_used = kMaxSequenceNumber;
   auto s = db_impl_->WriteImpl(write_options_, batch, /*callback*/ nullptr,
+                               /*user_write_cb=*/nullptr,
                                /*log_used*/ nullptr, /*log_ref*/ 0,
                                /*disable_memtable*/ false, &seq_used);
   assert(!s.ok() || seq_used != kMaxSequenceNumber);
@@ -793,6 +879,7 @@ Status WriteCommittedTxn::CommitInternal() {
     }
   }
   s = db_impl_->WriteImpl(write_options_, working_batch, /*callback*/ nullptr,
+                          /*user_write_cb=*/nullptr,
                           /*log_used*/ nullptr, /*log_ref*/ log_number_,
                           /*disable_memtable*/ false, &seq_used,
                           /*batch_cnt=*/0, /*pre_release_callback=*/nullptr,
@@ -896,6 +983,11 @@ Status PessimisticTransaction::LockBatch(WriteBatch* batch,
       RecordKey(column_family_id, key);
       return Status::OK();
     }
+    Status PutEntityCF(uint32_t column_family_id, const Slice& key,
+                       const Slice& /* unused */) override {
+      RecordKey(column_family_id, key);
+      return Status::OK();
+    }
     Status MergeCF(uint32_t column_family_id, const Slice& key,
                    const Slice& /* unused */) override {
       RecordKey(column_family_id, key);
@@ -1132,7 +1224,10 @@ Status PessimisticTransaction::ValidateSnapshot(
 
   return TransactionUtil::CheckKeyForConflicts(
       db_impl_, cfh, key.ToString(), snap_seq, ts_sz == 0 ? nullptr : &ts_buf,
-      false /* cache_only */);
+      false /* cache_only */,
+      /* snap_checker */ nullptr,
+      /* min_uncommitted */ kMaxSequenceNumber,
+      txn_db_impl_->GetTxnDBOptions().enable_udt_validation);
 }
 
 bool PessimisticTransaction::TryStealingLocks() {
@@ -1152,14 +1247,15 @@ Status PessimisticTransaction::SetName(const TransactionName& name) {
   if (txn_state_ == STARTED) {
     if (name_.length()) {
       s = Status::InvalidArgument("Transaction has already been named.");
-    } else if (txn_db_impl_->GetTransactionByName(name) != nullptr) {
-      s = Status::InvalidArgument("Transaction name must be unique.");
     } else if (name.length() < 1 || name.length() > 512) {
       s = Status::InvalidArgument(
           "Transaction name length must be between 1 and 512 chars.");
     } else {
       name_ = name;
-      txn_db_impl_->RegisterTransaction(this);
+      s = txn_db_impl_->RegisterTransaction(this);
+      if (!s.ok()) {
+        name_.clear();
+      }
     }
   } else {
     s = Status::InvalidArgument("Transaction is beyond state for naming.");

package/vendor/librocksdb/vendor/rocksdb/utilities/transactions/pessimistic_transaction.h

@@ -5,7 +5,6 @@
 
 #pragma once
 
-
 #include <algorithm>
 #include <atomic>
 #include <mutex>
@@ -235,6 +234,11 @@ class WriteCommittedTxn : public PessimisticTransaction {
                       PinnableSlice* pinnable_val, bool exclusive,
                       const bool do_validate) override;
 
+  Status GetEntityForUpdate(const ReadOptions& read_options,
+                            ColumnFamilyHandle* column_family, const Slice& key,
+                            PinnableWideColumns* columns, bool exclusive,
+                            bool do_validate) override;
+
   using TransactionBaseImpl::Put;
   // `key` does NOT include timestamp even when it's enabled.
   Status Put(ColumnFamilyHandle* column_family, const Slice& key,
@@ -249,6 +253,25 @@ class WriteCommittedTxn : public PessimisticTransaction {
   Status PutUntracked(ColumnFamilyHandle* column_family, const SliceParts& key,
                       const SliceParts& value) override;
 
+  // `key` does NOT include timestamp even when it's enabled.
+  Status PutEntity(ColumnFamilyHandle* column_family, const Slice& key,
+                   const WideColumns& columns,
+                   bool assume_tracked = false) override {
+    const bool do_validate = !assume_tracked;
+
+    return PutEntityImpl(column_family, key, columns, do_validate,
+                         assume_tracked);
+  }
+
+  Status PutEntityUntracked(ColumnFamilyHandle* column_family, const Slice& key,
+                            const WideColumns& columns) override {
+    constexpr bool do_validate = false;
+    constexpr bool assume_tracked = false;
+
+    return PutEntityImpl(column_family, key, columns, do_validate,
+                         assume_tracked);
+  }
+
   using TransactionBaseImpl::Delete;
   // `key` does NOT include timestamp even when it's enabled.
   Status Delete(ColumnFamilyHandle* column_family, const Slice& key,
@@ -288,6 +311,10 @@ class WriteCommittedTxn : public PessimisticTransaction {
                           TValue* value, bool exclusive,
                           const bool do_validate);
 
+  Status PutEntityImpl(ColumnFamilyHandle* column_family, const Slice& key,
+                       const WideColumns& columns, bool do_validate,
+                       bool assume_tracked);
+
   template <typename TKey, typename TOperation>
   Status Operate(ColumnFamilyHandle* column_family, const TKey& key,
                  const bool do_validate, const bool assume_tracked,
@@ -303,6 +330,11 @@ class WriteCommittedTxn : public PessimisticTransaction {
 
   Status RollbackInternal() override;
 
+  // Checks if the combination of `do_validate`, the read timestamp set in
+  // `read_timestamp_` and the `enable_udt_validation` flag in
+  // TransactionDBOptions make sense together.
+  Status SanityCheckReadTimestamp(bool do_validate);
+
   // Column families that enable timestamps and whose data are written when
   // indexing_enabled_ is false. If a key is written when indexing_enabled_ is
   // true, then the corresponding column family is not added to cfs_with_ts