@nxtedition/rocksdb 15.4.1 → 16.0.0

package/deps/rocksdb/rocksdb/table/unique_id.cc

@@ -14,7 +14,7 @@ namespace ROCKSDB_NAMESPACE {
 
 std::string EncodeSessionId(uint64_t upper, uint64_t lower) {
   std::string db_session_id(20U, '\0');
-  char *buf = db_session_id.data();
+  char* buf = db_session_id.data();
   // Preserving `lower` is slightly tricky. 36^12 is slightly more than
   // 62 bits, so we use 12 chars plus the bottom two bits of one more.
   // (A tiny fraction of 20 digit strings go unused.)
@@ -26,8 +26,8 @@ std::string EncodeSessionId(uint64_t upper, uint64_t lower) {
   return db_session_id;
 }
 
-Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
-                       uint64_t *lower) {
+Status DecodeSessionId(const std::string& db_session_id, uint64_t* upper,
+                       uint64_t* lower) {
   const size_t len = db_session_id.size();
   if (len == 0) {
     return Status::NotSupported("Missing db_session_id");
@@ -41,7 +41,7 @@ Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
     return Status::NotSupported("Too long db_session_id");
   }
   uint64_t a = 0, b = 0;
-  const char *buf = &db_session_id.front();
+  const char* buf = &db_session_id.front();
   bool success = ParseBaseChars<36>(&buf, len - 12U, &a);
   if (!success) {
     return Status::NotSupported("Bad digit in db_session_id");
@@ -56,8 +56,8 @@ Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
   return Status::OK();
 }
 
-Status GetSstInternalUniqueId(const std::string &db_id,
-                              const std::string &db_session_id,
+Status GetSstInternalUniqueId(const std::string& db_id,
+                              const std::string& db_session_id,
                               uint64_t file_number, UniqueIdPtr out,
                               bool force) {
   if (!force) {
@@ -160,11 +160,11 @@ std::string EncodeUniqueIdBytes(UniqueIdPtr in) {
   return ret;
 }
 
-Status DecodeUniqueIdBytes(const std::string &unique_id, UniqueIdPtr out) {
+Status DecodeUniqueIdBytes(const std::string& unique_id, UniqueIdPtr out) {
   if (unique_id.size() != (out.extended ? 24 : 16)) {
     return Status::NotSupported("Not a valid unique_id");
   }
-  const char *buf = &unique_id.front();
+  const char* buf = &unique_id.front();
   out.ptr[0] = DecodeFixed64(&buf[0]);
   out.ptr[1] = DecodeFixed64(&buf[8]);
   if (out.extended) {
@@ -174,8 +174,8 @@ Status DecodeUniqueIdBytes(const std::string &unique_id, UniqueIdPtr out) {
 }
 
 template <typename ID>
-Status GetUniqueIdFromTablePropertiesHelper(const TableProperties &props,
-                                            std::string *out_id) {
+Status GetUniqueIdFromTablePropertiesHelper(const TableProperties& props,
+                                            std::string* out_id) {
   ID tmp{};
   Status s = GetSstInternalUniqueId(props.db_id, props.db_session_id,
                                     props.orig_file_number, &tmp);
@@ -188,23 +188,27 @@ Status GetUniqueIdFromTablePropertiesHelper(const TableProperties &props,
   return s;
 }
 
-Status GetExtendedUniqueIdFromTableProperties(const TableProperties &props,
-                                              std::string *out_id) {
+Status GetExtendedUniqueIdFromTableProperties(const TableProperties& props,
+                                              std::string* out_id) {
   return GetUniqueIdFromTablePropertiesHelper<UniqueId64x3>(props, out_id);
 }
 
-Status GetUniqueIdFromTableProperties(const TableProperties &props,
-                                      std::string *out_id) {
+Status GetUniqueIdFromTableProperties(const TableProperties& props,
+                                      std::string* out_id) {
   return GetUniqueIdFromTablePropertiesHelper<UniqueId64x2>(props, out_id);
 }
 
-std::string UniqueIdToHumanString(const std::string &id) {
-  // Not so efficient, but that's OK
-  std::string str = Slice(id).ToString(/*hex*/ true);
-  for (size_t i = 16; i < str.size(); i += 17) {
-    str.insert(i, "-");
+std::string UniqueIdToHumanString(const std::string& id) {
+  std::string hex = Slice(id).ToString(/*hex*/ true);
+  std::string result;
+  result.reserve(hex.size() + hex.size() / 16);
+  for (size_t i = 0; i < hex.size(); i++) {
+    if (i > 0 && i % 16 == 0) {
+      result.push_back('-');
+    }
+    result.push_back(hex[i]);
   }
-  return str;
+  return result;
 }
 
 std::string InternalUniqueIdToHumanString(UniqueIdPtr in) {

package/deps/rocksdb/rocksdb/table/unique_id_impl.h

@@ -26,14 +26,14 @@ constexpr UniqueId64x3 kNullUniqueId64x3 = {};
 
 // Dynamic pointer wrapper for one of the two above
 struct UniqueIdPtr {
-  uint64_t *ptr = nullptr;
+  uint64_t* ptr = nullptr;
   bool extended = false;
 
-  /*implicit*/ UniqueIdPtr(UniqueId64x2 *id) {
+  /*implicit*/ UniqueIdPtr(UniqueId64x2* id) {
     ptr = (*id).data();
     extended = false;
   }
-  /*implicit*/ UniqueIdPtr(UniqueId64x3 *id) {
+  /*implicit*/ UniqueIdPtr(UniqueId64x3* id) {
     ptr = (*id).data();
     extended = true;
   }
@@ -45,8 +45,8 @@ struct UniqueIdPtr {
 // unique id, so can be manipulated in more ways but very carefully.
 // These must be long term stable to ensure GetUniqueIdFromTableProperties
 // is long term stable.
-Status GetSstInternalUniqueId(const std::string &db_id,
-                              const std::string &db_session_id,
+Status GetSstInternalUniqueId(const std::string& db_id,
+                              const std::string& db_session_id,
                               uint64_t file_number, UniqueIdPtr out,
                               bool force = false);
 
@@ -66,7 +66,7 @@ void ExternalUniqueIdToInternal(UniqueIdPtr in_out);
 std::string EncodeUniqueIdBytes(UniqueIdPtr in);
 
 // Reverse of EncodeUniqueIdBytes.
-Status DecodeUniqueIdBytes(const std::string &unique_id, UniqueIdPtr out);
+Status DecodeUniqueIdBytes(const std::string& unique_id, UniqueIdPtr out);
 
 // For presenting internal IDs for debugging purposes. Visually distinct from
 // UniqueIdToHumanString for external IDs.
@@ -87,7 +87,7 @@ std::string EncodeSessionId(uint64_t upper, uint64_t lower);
 // Reverse of EncodeSessionId. Returns NotSupported on error rather than
 // Corruption because non-standard session IDs should be allowed with degraded
 // functionality.
-Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
-                       uint64_t *lower);
+Status DecodeSessionId(const std::string& db_session_id, uint64_t* upper,
+                       uint64_t* lower);
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/test_util/sync_point.h

@@ -6,10 +6,9 @@
 
 #include <assert.h>
 
+#include <atomic>
 #include <functional>
-#include <mutex>
 #include <string>
-#include <thread>
 #include <vector>
 
 #include "rocksdb/rocksdb_namespace.h"
@@ -190,6 +189,8 @@ namespace ROCKSDB_NAMESPACE {
 // Intentionally not based on std::exception to reduce places where this
 // would be caught
 struct TestableAssertionFailure {};
+// Tracks whether to throw on testable_assert failure instead of aborting.
+// This is an atomic counter for re-entrancy / thread-safety.
 extern std::atomic<int> g_throw_on_testable_assertion_failure;
 }  // namespace ROCKSDB_NAMESPACE
 #define testable_assert(cond)                                          \
@@ -202,7 +203,7 @@ extern std::atomic<int> g_throw_on_testable_assertion_failure;
     } else {                                                           \
       assert(cond);                                                    \
     }                                                                  \
-  } while (0)
+  } while (0)  // require ; in caller
 #define ASSERT_TESTABLE_FAILURE(expr)                                   \
   do {                                                                  \
     ROCKSDB_NAMESPACE::g_throw_on_testable_assertion_failure.fetch_add( \
@@ -210,5 +211,5 @@ extern std::atomic<int> g_throw_on_testable_assertion_failure;
     ASSERT_THROW(expr, ROCKSDB_NAMESPACE::TestableAssertionFailure);    \
     ROCKSDB_NAMESPACE::g_throw_on_testable_assertion_failure.fetch_sub( \
         1, std::memory_order_relaxed);                                  \
-  } while (0)
+  } while (0)  // require ; in caller
 #endif

package/deps/rocksdb/rocksdb/test_util/testutil.cc

@@ -29,6 +29,7 @@
 #include "test_util/mock_time_env.h"
 #include "test_util/sync_point.h"
 #include "util/random.h"
+#include "util/string_util.h"
 
 #ifndef ROCKSDB_UNITTESTS_WITH_CUSTOM_OBJECTS_FROM_STATIC_LIBS
 void RegisterCustomObjects(int /*argc*/, char** /*argv*/) {}
@@ -44,7 +45,7 @@ const std::set<uint32_t> kFooterFormatVersionsToTest{
     6U,
     // In case any interesting future changes
     kDefaultFormatVersion,
-    kLatestFormatVersion,
+    kLatestBbtFormatVersion,
 };
 const ReadOptionsNoIo kReadOptionsNoIo;
 

package/deps/rocksdb/rocksdb/test_util/testutil.h

@@ -796,9 +796,9 @@ struct CompressorCustomAlg : public CompressorWrapper {
   }
 
   std::unique_ptr<Compressor> MaybeCloneSpecialized(
-      CacheEntryRole block_type, DictSampleArgs&& dict_samples) const override {
+      CacheEntryRole block_type, DictConfigArgs&& dict_config) const override {
     auto clone =
-        wrapped_->CloneMaybeSpecialized(block_type, std::move(dict_samples));
+        wrapped_->CloneMaybeSpecialized(block_type, std::move(dict_config));
     return std::make_unique<CompressorCustomAlg>(std::move(clone));
   }
 

package/deps/rocksdb/rocksdb/tools/block_cache_analyzer/block_cache_trace_analyzer_test.cc

@@ -26,6 +26,7 @@ int main() {
 #include "test_util/testutil.h"
 #include "tools/block_cache_analyzer/block_cache_trace_analyzer.h"
 #include "trace_replay/block_cache_tracer.h"
+#include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -88,7 +89,7 @@ class BlockCacheTracerTest : public testing::Test {
       case 4:
         return TableReaderCaller::kUserIterator;
     }
-    // This cannot happend.
+    // This cannot happen.
     assert(false);
     return TableReaderCaller::kMaxBlockCacheLookupCaller;
   }