@nxtedition/rocksdb 14.0.0 → 15.1.0

package/binding.cc

@@ -1178,6 +1178,12 @@ NAPI_METHOD(db_open) {
 
     NAPI_STATUS_THROWS(GetProperty(env, options, "compactionReadaheadSize", dbOptions.compaction_readahead_size));
 
+    NAPI_STATUS_THROWS(GetProperty(env, options, "useAdaptiveMutex", dbOptions.use_adaptive_mutex));
+
+    NAPI_STATUS_THROWS(GetProperty(env, options, "writeBufferSize", dbOptions.db_write_buffer_size));
+
+    NAPI_STATUS_THROWS(GetProperty(env, options, "manualWALFlush", dbOptions.manual_wal_flush));
+
     // TODO (feat): dbOptions.listeners
 
     std::string infoLogLevel;
@@ -1600,6 +1606,28 @@ NAPI_METHOD(db_get_latest_sequence) {
   return result;
 }
 
+NAPI_METHOD(db_flush_wal) {
+  NAPI_ARGV(3);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  bool sync;
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], sync));
+
+  auto callback = argv[2];
+
+  struct State {};
+  runAsync<State>(
+      "leveldown.flush_wal", env, callback,
+      [=](auto& state) {
+        return database->db->FlushWAL(sync);
+      },
+      [](auto& state, auto env, auto& argv) { return napi_ok; });
+
+  return 0;
+}
+
 NAPI_METHOD(iterator_init) {
   NAPI_ARGV(2);
 
@@ -2034,193 +2062,30 @@ NAPI_METHOD(updates_close) {
   }
 }
 
-NAPI_METHOD(db_open_for_read_only) {
-  NAPI_ARGV(3);
+NAPI_METHOD(db_compact_range_sync) {
+  NAPI_ARGV(2);
 
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  if (database->db) {
-    napi_value columns;
-    NAPI_STATUS_THROWS(napi_create_object(env, &columns));
-    for (auto& [id, column] : database->columns) {
-      napi_value val;
-      NAPI_STATUS_THROWS(napi_create_external(env, column.handle, nullptr, nullptr, &val));
-      NAPI_STATUS_THROWS(napi_set_named_property(env, columns, column.descriptor.name.c_str(), val));
-    }
-    return columns;
-  } else {
-    rocksdb::Options dbOptions;
-
-    const auto options = argv[1];
-
-    int parallelism = std::max<int>(1, std::thread::hardware_concurrency() / 2);
-    NAPI_STATUS_THROWS(GetProperty(env, options, "parallelism", parallelism));
-    dbOptions.IncreaseParallelism(parallelism);
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "walDir", dbOptions.wal_dir));
-
-    uint32_t walTTL = 0;
-    NAPI_STATUS_THROWS(GetProperty(env, options, "walTTL", walTTL));
-    dbOptions.WAL_ttl_seconds = walTTL / 1e3;
-
-    uint32_t walSizeLimit = 0;
-    NAPI_STATUS_THROWS(GetProperty(env, options, "walSizeLimit", walSizeLimit));
-    dbOptions.WAL_size_limit_MB = walSizeLimit / 1e6;
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "maxTotalWalSize", dbOptions.max_total_wal_size));
-
-    bool walCompression = true;
-    NAPI_STATUS_THROWS(GetProperty(env, options, "walCompression", walCompression));
-    dbOptions.wal_compression =
-        walCompression ? rocksdb::CompressionType::kZSTD : rocksdb::CompressionType::kNoCompression;
-
-    dbOptions.avoid_unnecessary_blocking_io = true;
-    NAPI_STATUS_THROWS(GetProperty(env, options, "avoidUnnecessaryBlockingIO", dbOptions.avoid_unnecessary_blocking_io));
-
-    dbOptions.create_missing_column_families = true;
-    NAPI_STATUS_THROWS(GetProperty(env, options, "createMissingColumnFamilies", dbOptions.create_missing_column_families));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "writeDbIdToManifest", dbOptions.write_dbid_to_manifest));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "adviseRandomOnOpen", dbOptions.advise_random_on_open));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "bytesPerSync", dbOptions.bytes_per_sync));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "walBytesPerSync", dbOptions.wal_bytes_per_sync));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "strictBytesPerSync", dbOptions.strict_bytes_per_sync));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "delayedWriteRate", dbOptions.delayed_write_rate));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "createIfMissing", dbOptions.create_if_missing));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "errorIfExists", dbOptions.error_if_exists));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "pipelinedWrite", dbOptions.enable_pipelined_write));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "dailyOffpeakTime", dbOptions.daily_offpeak_time_utc));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "unorderedWrite", dbOptions.unordered_write));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "allowMmapReads", dbOptions.allow_mmap_reads));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "allowMmapWrites", dbOptions.allow_mmap_writes));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "memTableHugePageSize", dbOptions.memtable_huge_page_size));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "useDirectIOReads", dbOptions.use_direct_reads));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "useDirectIOForFlushAndCompaction", dbOptions.use_direct_io_for_flush_and_compaction));
-
-    NAPI_STATUS_THROWS(GetProperty(env, options, "compactionReadaheadSize", dbOptions.compaction_readahead_size));
-
-    // TODO (feat): dbOptions.listeners
-
-    std::string infoLogLevel;
-    NAPI_STATUS_THROWS(GetProperty(env, options, "infoLogLevel", infoLogLevel));
-    if (infoLogLevel.size() > 0) {
-      rocksdb::InfoLogLevel lvl = {};
-
-      if (infoLogLevel == "debug")
-        lvl = rocksdb::InfoLogLevel::DEBUG_LEVEL;
-      else if (infoLogLevel == "info")
-        lvl = rocksdb::InfoLogLevel::INFO_LEVEL;
-      else if (infoLogLevel == "warn")
-        lvl = rocksdb::InfoLogLevel::WARN_LEVEL;
-      else if (infoLogLevel == "error")
-        lvl = rocksdb::InfoLogLevel::ERROR_LEVEL;
-      else if (infoLogLevel == "fatal")
-        lvl = rocksdb::InfoLogLevel::FATAL_LEVEL;
-      else if (infoLogLevel == "header")
-        lvl = rocksdb::InfoLogLevel::HEADER_LEVEL;
-      else
-        napi_throw_error(env, nullptr, "invalid log level");
-
-      dbOptions.info_log_level = lvl;
-    } else {
-      // In some places RocksDB checks this option to see if it should prepare
-      // debug information (ahead of logging), so set it to the highest level.
-      dbOptions.info_log_level = rocksdb::InfoLogLevel::HEADER_LEVEL;
-      dbOptions.info_log.reset(new NullLogger());
-    }
-
-    NAPI_STATUS_THROWS(InitOptions(env, dbOptions, options));
-
-    std::vector<rocksdb::ColumnFamilyDescriptor> descriptors;
-
-    bool hasColumns;
-    NAPI_STATUS_THROWS(napi_has_named_property(env, options, "columns", &hasColumns));
-
-    if (hasColumns) {
-      napi_value columns;
-      NAPI_STATUS_THROWS(napi_get_named_property(env, options, "columns", &columns));
-
-      napi_value keys;
-      NAPI_STATUS_THROWS(napi_get_property_names(env, columns, &keys));
-
-      uint32_t len;
-      NAPI_STATUS_THROWS(napi_get_array_length(env, keys, &len));
-
-      descriptors.resize(len);
-      for (uint32_t n = 0; n < len; ++n) {
-        napi_value key;
-        NAPI_STATUS_THROWS(napi_get_element(env, keys, n, &key));
-
-        napi_value column;
-        NAPI_STATUS_THROWS(napi_get_property(env, columns, key, &column));
-
-        NAPI_STATUS_THROWS(InitOptions(env, descriptors[n].options, column));
-
-        NAPI_STATUS_THROWS(GetValue(env, key, descriptors[n].name));
-      }
-    }
-
-    auto callback = argv[2];
-
-    runAsync<std::vector<rocksdb::ColumnFamilyHandle*>>(
-        "leveldown.open_for_read_only", env, callback,
-        [=](auto& handles) {
-          assert(!database->db);
-
-          rocksdb::DB* db = nullptr;
-
-          const auto status = descriptors.empty()
-                                  ? rocksdb::DB::OpenForReadOnly(dbOptions, database->location, &db)
-                                  : rocksdb::DB::OpenForReadOnly(dbOptions, database->location, descriptors, &handles, &db);
-
-          database->db.reset(db);
-
-          return status;
-        },
-        [=](auto& handles, auto env, auto& argv) {
-          argv.resize(2);
+  std::optional<std::string> start;
+  std::optional<std::string> end;
 
-          NAPI_STATUS_RETURN(napi_create_object(env, &argv[1]));
+  NAPI_STATUS_THROWS(GetProperty(env, argv[1], "start", start));
+  NAPI_STATUS_THROWS(GetProperty(env, argv[1], "end", end));
 
-          for (size_t n = 0; n < handles.size(); ++n) {
-            ColumnFamily column;
-            column.handle = handles[n];
-            column.descriptor = descriptors[n];
-            database->columns[column.handle->GetID()] = column;
-          }
+  rocksdb::CompactRangeOptions options;
 
-          napi_value columns = argv[1];
-          for (auto& [id, column] : database->columns) {
-            napi_value val;
-            NAPI_STATUS_RETURN(napi_create_external(env, column.handle, nullptr, nullptr, &val));
-            NAPI_STATUS_RETURN(napi_set_named_property(env, columns, column.descriptor.name.c_str(), val));
-          }
+  auto begin = start ? std::make_unique<rocksdb::Slice>(*start) : nullptr;
+  auto finish = end ? std::make_unique<rocksdb::Slice>(*end) : nullptr;
 
-          return napi_ok;
-        });
-  }
+  ROCKS_STATUS_THROWS_NAPI(database->db->CompactRange(options, begin.get(), finish.get()));
 
   return 0;
 }
 
 NAPI_METHOD(db_compact_range) {
-  NAPI_ARGV(2);
+  NAPI_ARGV(3);
 
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
@@ -2231,12 +2096,19 @@ NAPI_METHOD(db_compact_range) {
   NAPI_STATUS_THROWS(GetProperty(env, argv[1], "start", start));
   NAPI_STATUS_THROWS(GetProperty(env, argv[1], "end", end));
 
-  rocksdb::CompactRangeOptions options;
+  auto callback = argv[2];
 
-  auto begin = start ? std::make_unique<rocksdb::Slice>(*start) : nullptr;
-  auto finish = end ? std::make_unique<rocksdb::Slice>(*end) : nullptr;
+  runAsync<std::nullptr_t>(
+      "leveldown.compact_range", env, callback,
+      [=](auto& state) {
+        rocksdb::CompactRangeOptions options;
 
-  ROCKS_STATUS_THROWS_NAPI(database->db->CompactRange(options, begin.get(), finish.get()));
+        auto begin = start ? std::make_unique<rocksdb::Slice>(*start) : nullptr;
+        auto finish = end ? std::make_unique<rocksdb::Slice>(*end) : nullptr;
+
+        return database->db->CompactRange(options, begin.get(), finish.get());
+      },
+      [](auto& state, auto env, auto& argv) { return napi_ok; });
 
   return 0;
 }
@@ -2254,8 +2126,9 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_get_property);
   NAPI_EXPORT_FUNCTION(db_get_latest_sequence);
   NAPI_EXPORT_FUNCTION(db_query);
-  NAPI_EXPORT_FUNCTION(db_open_for_read_only);
+  NAPI_EXPORT_FUNCTION(db_compact_range_sync);
   NAPI_EXPORT_FUNCTION(db_compact_range);
+  NAPI_EXPORT_FUNCTION(db_flush_wal);
 
   NAPI_EXPORT_FUNCTION(iterator_init);
   NAPI_EXPORT_FUNCTION(iterator_seek);

package/deps/rocksdb/rocksdb/BUCK

@@ -425,6 +425,7 @@ rocks_cpp_library_wrapper(name="rocksdb_stress_lib", srcs=[
         "db_stress_tool/batched_ops_stress.cc",
         "db_stress_tool/cf_consistency_stress.cc",
         "db_stress_tool/db_stress_common.cc",
+        "db_stress_tool/db_stress_compaction_service.cc",
         "db_stress_tool/db_stress_compression_manager.cc",
         "db_stress_tool/db_stress_driver.cc",
         "db_stress_tool/db_stress_filters.cc",
@@ -5193,6 +5194,12 @@ cpp_unittest_wrapper(name="import_column_family_test",
             extra_compiler_flags=[])
 
 
+cpp_unittest_wrapper(name="index_builder_test",
+            srcs=["table/block_based/index_builder_test.cc"],
+            deps=[":rocksdb_test_lib"],
+            extra_compiler_flags=[])
+
+
 cpp_unittest_wrapper(name="inlineskiplist_test",
             srcs=["memtable/inlineskiplist_test.cc"],
             deps=[":rocksdb_test_lib"],

package/deps/rocksdb/rocksdb/CMakeLists.txt

@@ -203,9 +203,16 @@ if(WIN32 AND MSVC)
   endif()
 endif()
 
+option(WIN_CI "Accelerate build speed and reduce build artifect size for github CI with MSVC" OFF)
+
 if(MSVC)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi /nologo /EHsc /GS /Gd /GR /GF /fp:precise /Zc:wchar_t /Zc:forScope /errorReport:queue")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W4 /wd4127 /wd4996 /wd4100 /wd4324")
+  if(WIN_CI)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /nologo /EHsc /Gd /GR /GF /fp:precise /Zc:wchar_t /Zc:forScope /errorReport:queue")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /W4 /wd4127 /wd4996 /wd4100 /wd4324 /wd4702")
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi /nologo /EHsc /GS /Gd /GR /GF /fp:precise /Zc:wchar_t /Zc:forScope /errorReport:queue")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FC /d2Zi+ /W4 /wd4127 /wd4996 /wd4100 /wd4324")
+  endif()
 else()
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wextra -Wall -pthread")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsign-compare -Wshadow -Wno-unused-parameter -Wno-unused-variable -Woverloaded-virtual -Wnon-virtual-dtor -Wno-missing-field-initializers -Wno-strict-aliasing -Wno-invalid-offsetof")
@@ -313,7 +320,7 @@ if(NOT MSVC)
 endif()
 
 # Check if -latomic is required or not
-if (NOT MSVC)
+if (NOT MSVC AND NOT APPLE)
   CHECK_CXX_SOURCE_COMPILES("
 #include <atomic>
 std::atomic<uint64_t> x(0);
@@ -450,24 +457,33 @@ else()
   endif()
 endif()
 
-# Used to run CI build and tests so we can run faster
+# Used to run optimized debug build and tests so we can run faster
 option(OPTDBG "Build optimized debug build with MSVC" OFF)
 option(WITH_RUNTIME_DEBUG "build with debug version of runtime library" ON)
 if(MSVC)
-  if(OPTDBG)
+  if (WIN_CI)
     message(STATUS "Debug optimization is enabled")
     set(CMAKE_CXX_FLAGS_DEBUG "/Oxt")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG:FASTLINK")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG:FASTLINK")
   else()
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /RTC1")
-
-    # Minimal Build is deprecated after MSVC 2015
-    if( MSVC_VERSION GREATER 1900 )
-      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Gm-")
+    if(OPTDBG)
+      message(STATUS "Debug optimization is enabled")
+      set(CMAKE_CXX_FLAGS_DEBUG "/Oxt")
     else()
-      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Gm")
-    endif()
+      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /RTC1")
 
+      # Minimal Build is deprecated after MSVC 2015
+      if( MSVC_VERSION GREATER 1900 )
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Gm-")
+      else()
+        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Gm")
+      endif()
+    endif()
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG")
   endif()
+
   if(WITH_RUNTIME_DEBUG)
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /${RUNTIME_LIBRARY}d")
   else()
@@ -475,8 +491,6 @@ if(MSVC)
   endif()
   set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Oxt /Zp8 /Gm- /Gy /${RUNTIME_LIBRARY}")
 
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG")
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
@@ -1438,6 +1452,7 @@ if(WITH_TESTS)
         table/block_based/block_based_table_reader_test.cc
         table/block_based/block_test.cc
         table/block_based/data_block_hash_index_test.cc
+        table/block_based/index_builder_test.cc
         table/block_based/full_filter_block_test.cc
         table/block_based/partitioned_filter_block_test.cc
         table/cleanable_test.cc

package/deps/rocksdb/rocksdb/Directory.Build.props

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+    <PropertyGroup>
+        <CLToolExe>ccache_msvc_compiler.bat</CLToolExe>
+        <CLToolPath>$(MSBuildThisFileDirectory)</CLToolPath>
+        <UseMultiToolTask>true</UseMultiToolTask>
+        <EnforceProcessCountAcrossBuilds>true</EnforceProcessCountAcrossBuilds>
+    </PropertyGroup>
+</Project>

package/deps/rocksdb/rocksdb/Makefile

@@ -1739,6 +1739,9 @@ block_test: $(OBJ_DIR)/table/block_based/block_test.o $(TEST_LIBRARY) $(LIBRARY)
 data_block_hash_index_test: $(OBJ_DIR)/table/block_based/data_block_hash_index_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
+index_builder_test: $(OBJ_DIR)/table/block_based/index_builder_test.o $(TEST_LIBRARY) $(LIBRARY)
+	$(AM_LINK)
+
 inlineskiplist_test: $(OBJ_DIR)/memtable/inlineskiplist_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
@@ -2492,6 +2495,8 @@ commit_prereq:
 	false # J=$(J) build_tools/precommit_checker.py unit clang_unit release clang_release tsan asan ubsan lite unit_non_shm
 	# $(MAKE) clean && $(MAKE) jclean && $(MAKE) rocksdbjava;
 
+FOLLY_COMMIT_HASH = e95383b7c8b5b1e46cf47acf2f317d54f93c8268
+
 # For public CI runs, checkout folly in a way that can build with RocksDB.
 # This is mostly intended as a test-only simulation of Meta-internal folly
 # integration.
@@ -2503,7 +2508,7 @@ checkout_folly:
 	fi
 	@# Pin to a particular version for public CI, so that PR authors don't
 	@# need to worry about folly breaking our integration. Update periodically
-	cd third-party/folly && git reset --hard e95383b7c8b5b1e46cf47acf2f317d54f93c8268
+	cd third-party/folly && git reset --hard $(FOLLY_COMMIT_HASH)
 	@# Apparently missing include
 	perl -pi -e 's/(#include <atomic>)/$$1\n#include <cstring>/' third-party/folly/folly/lang/Exception.h
 	@# Warning-as-error on memcpy

package/deps/rocksdb/rocksdb/cache/secondary_cache_adapter.cc

@@ -33,7 +33,7 @@ const char* kTieredCacheName = "TieredCache";
 // proportionally across the primary/secondary caches.
 //
 // The primary block cache is initially sized to the sum of the primary cache
-// budget + teh secondary cache budget, as follows -
+// budget + the secondary cache budget, as follows -
 //   |---------    Primary Cache Configured Capacity  -----------|
 //   |---Secondary Cache Budget----|----Primary Cache Budget-----|
 //
@@ -51,7 +51,7 @@ const char* kTieredCacheName = "TieredCache";
 // placeholder is counted against the primary cache. To compensate and count
 // a portion of it against the secondary cache, the secondary cache Deflate()
 // method is called to shrink it. Since the Deflate() causes the secondary
-// actual usage to shrink, it is refelcted here by releasing an equal amount
+// actual usage to shrink, it is reflected here by releasing an equal amount
 // from the pri_cache_res_ reservation. The Deflate() in the secondary cache
 // can be, but is not required to be, implemented using its own cache
 // reservation manager.
@@ -72,7 +72,7 @@ const char* kTieredCacheName = "TieredCache";
 // reservation is increased by an equal amount.
 //
 // Another way of implementing this would have been to simply split the user
-// reservation into primary and seconary components. However, this would
+// reservation into primary and secondary components. However, this would
 // require allocating a structure to track the associated secondary cache
 // reservation, which adds some complexity and overhead.
 //
@@ -621,7 +621,7 @@ Status CacheWithSecondaryAdapter::UpdateCacheReservationRatio(
   } else {
     // We're shrinking the ratio. Try to avoid unnecessary evictions -
     // 1. Lower the secondary cache capacity
-    // 2. Decrease pri_cache_res_ reservation to relect lower secondary
+    // 2. Decrease pri_cache_res_ reservation to reflect lower secondary
     //    cache utilization (decrease in capacity - decrease in share of cache
     //    reservations)
     // 3. Inflate the secondary cache to give it back the reduction in its

package/deps/rocksdb/rocksdb/ccache_msvc_compiler.bat

@@ -0,0 +1 @@
+ccache.exe cl.exe %*

package/deps/rocksdb/rocksdb/db/compaction/compaction.cc

@@ -281,8 +281,9 @@ Compaction::Compaction(
     std::vector<CompactionInputFiles> _inputs, int _output_level,
     uint64_t _target_file_size, uint64_t _max_compaction_bytes,
     uint32_t _output_path_id, CompressionType _compression,
-    CompressionOptions _compression_opts, Temperature _output_temperature,
-    uint32_t _max_subcompactions, std::vector<FileMetaData*> _grandparents,
+    CompressionOptions _compression_opts,
+    Temperature _output_temperature_override, uint32_t _max_subcompactions,
+    std::vector<FileMetaData*> _grandparents,
     std::optional<SequenceNumber> _earliest_snapshot,
     const SnapshotChecker* _snapshot_checker,
     CompactionReason _compaction_reason, const std::string& _trim_ts,
@@ -303,7 +304,7 @@ Compaction::Compaction(
       output_path_id_(_output_path_id),
       output_compression_(_compression),
       output_compression_opts_(_compression_opts),
-      output_temperature_(_output_temperature),
+      output_temperature_override_(_output_temperature_override),
       deletion_compaction_(_compaction_reason == CompactionReason::kFIFOTtl ||
                            _compaction_reason ==
                                CompactionReason::kFIFOMaxSize),
@@ -1128,4 +1129,17 @@ void Compaction::FilterInputsForCompactionIterator() {
   }
 }
 
+Temperature Compaction::GetOutputTemperature(bool is_proximal_level) const {
+  if (output_temperature_override_ != Temperature::kUnknown) {
+    return output_temperature_override_;
+  }
+
+  if (is_last_level() && !is_proximal_level &&
+      mutable_cf_options_.last_level_temperature != Temperature::kUnknown) {
+    return mutable_cf_options_.last_level_temperature;
+  }
+
+  return mutable_cf_options_.default_write_temperature;
+}
+
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db/compaction/compaction.h

@@ -90,7 +90,8 @@ class Compaction {
              uint64_t target_file_size, uint64_t max_compaction_bytes,
              uint32_t output_path_id, CompressionType compression,
              CompressionOptions compression_opts,
-             Temperature output_temperature, uint32_t max_subcompactions,
+             Temperature output_temperature_override,
+             uint32_t max_subcompactions,
              std::vector<FileMetaData*> grandparents,
              std::optional<SequenceNumber> earliest_snapshot,
              const SnapshotChecker* snapshot_checker,
@@ -409,7 +410,11 @@ class Compaction {
 
   uint64_t max_compaction_bytes() const { return max_compaction_bytes_; }
 
-  Temperature output_temperature() const { return output_temperature_; }
+  // Order of precedence for temperature:
+  // 1. Override temp if not kUnknown
+  // 2. Temperature of the last level files if applicable
+  // 3. Default write temperature
+  Temperature GetOutputTemperature(bool is_proximal_level = false) const;
 
   uint32_t max_subcompactions() const { return max_subcompactions_; }
 
@@ -541,7 +546,7 @@ class Compaction {
   const uint32_t output_path_id_;
   CompressionType output_compression_;
   CompressionOptions output_compression_opts_;
-  Temperature output_temperature_;
+  Temperature output_temperature_override_;
   // If true, then the compaction can be done by simply deleting input files.
   const bool deletion_compaction_;
   // should it split the output file using the compact cursor?

package/deps/rocksdb/rocksdb/db/compaction/compaction_iterator.h

@@ -270,6 +270,16 @@ class CompactionIterator {
   // true, unless `must_count_input_entries=true` was specified during iterator
   // creation (which ensures the count is always accurate).
   uint64_t NumInputEntryScanned() const { return input_.NumItered(); }
+
+  // Returns true if the current valid key was already scanned/counted during
+  // a lookahead operation in a previous iteration.
+  //
+  // REQUIRED: Valid() must be true
+  bool IsCurrentKeyAlreadyScanned() const {
+    assert(Valid());
+    return at_next_ || merge_out_iter_.Valid();
+  }
+
   Status InputStatus() const { return input_.status(); }
 
   bool IsDeleteRangeSentinelKey() const { return is_range_del_; }