@nxtedition/rocksdb 9.0.0 → 10.0.0

package/binding.cc

@@ -40,8 +40,6 @@ struct Database;
 struct Iterator;
 
 struct ColumnFamily {
-  napi_ref ref;
-  napi_value val;
   rocksdb::ColumnFamilyHandle* handle;
   rocksdb::ColumnFamilyDescriptor descriptor;
 };
@@ -52,9 +50,12 @@ struct Closable {
 };
 
 struct Database final {
+	Database(std::string location) : location(std::move(location)) {}
   ~Database() { assert(!db); }
 
   rocksdb::Status Close() {
+		std::lock_guard<std::mutex> lock(mutex);
+
     if (!db) {
       return rocksdb::Status::OK();
     }
@@ -64,17 +65,35 @@ struct Database final {
     }
     closables.clear();
 
-    for (auto& [id, column] : columns) {
-      db->DestroyColumnFamilyHandle(column.handle);
-    }
-    columns.clear();
-
     db->FlushWAL(true);
 
-    auto db2 = std::move(db);
-    return db2->Close();
+		for (auto& [id, column] : columns) {
+			db->DestroyColumnFamilyHandle(column.handle);
+		}
+		columns.clear();
+
+		auto db2 = std::move(db);
+		return db2->Close();
   }
 
+	void Ref() {
+		std::lock_guard<std::mutex> lock(mutex);
+
+		refs++;
+	}
+
+	void Unref() {
+		std::lock_guard<std::mutex> lock(mutex);
+
+		if (--refs == 0) {
+			Close();
+			delete this;
+		}
+	}
+
+	int refs = 0;
+	std::mutex mutex;
+	std::string location;
   std::unique_ptr<rocksdb::DB> db;
   std::set<Closable*> closables;
   std::map<int32_t, ColumnFamily> columns;
@@ -449,32 +468,74 @@ struct Iterator final : public BaseIterator {
   napi_ref ref_ = nullptr;
 };
 
-static void env_cleanup_hook(void* arg) {
-  auto database = reinterpret_cast<Database*>(arg);
-  if (database) {
-    database->Close();
-  }
-}
-
 static void FinalizeDatabase(napi_env env, void* data, void* hint) {
   if (data) {
-    auto database = reinterpret_cast<Database*>(data);
-    database->Close();
-    napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
-    for (auto& [id, column] : database->columns) {
-      napi_delete_reference(env, column.ref);
-    }
-    delete database;
+		auto database = reinterpret_cast<Database*>(data);
+
+		std::lock_guard<std::mutex> lock(database->mutex);
+
+    database->Unref();
   }
 }
 
 NAPI_METHOD(db_init) {
-  auto database = new Database();
-  napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
+  NAPI_ARGV(1);
+
+	Database* database = nullptr;
+
+  napi_valuetype type;
+  NAPI_STATUS_THROWS(napi_typeof(env, argv[0], &type));
+
+  if (type == napi_string) {
+		std::string location;
+    size_t length = 0;
+    NAPI_STATUS_THROWS(napi_get_value_string_utf8(env, argv[0], nullptr, 0, &length));
+    location.resize(length, '\0');
+    NAPI_STATUS_THROWS(napi_get_value_string_utf8(env, argv[0], &location[0], length + 1, &length));
+
+		database = new Database(location);
+  } else if (type == napi_bigint) {
+		int64_t value;
+		bool lossless;
+		NAPI_STATUS_THROWS(napi_get_value_bigint_int64(env, argv[0], &value, &lossless));
+
+		database = reinterpret_cast<Database*>(value);
+  } else {
+		NAPI_STATUS_THROWS(napi_invalid_arg);
+	}
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, database, FinalizeDatabase, nullptr, &result));
 
+	{
+		std::lock_guard<std::mutex> lock(database->mutex);
+		database->Ref();
+	}
+
+  return result;
+}
+
+NAPI_METHOD(db_get_handle) {
+  NAPI_ARGV(1);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_bigint_int64(env, reinterpret_cast<intptr_t>(database), &result));
+
+  return result;
+}
+
+NAPI_METHOD(db_get_location) {
+  NAPI_ARGV(1);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  napi_value result;
+  NAPI_STATUS_THROWS(Convert(env, &database->location, Encoding::String, result));
+
   return result;
 }
 
@@ -710,141 +771,164 @@ NAPI_METHOD(db_get_identity) {
 }
 
 NAPI_METHOD(db_open) {
-  NAPI_ARGV(4);
+  NAPI_ARGV(3);
 
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  std::string location;
-  NAPI_STATUS_THROWS(GetValue(env, argv[1], location));
-
-  rocksdb::Options dbOptions;
-
-  const auto options = argv[2];
-
-  int parallelism = std::max<int>(1, std::thread::hardware_concurrency() / 2);
-  NAPI_STATUS_THROWS(GetProperty(env, options, "parallelism", parallelism));
-  dbOptions.IncreaseParallelism(parallelism);
-
-  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;
-
-	uint32_t maxTotalWalSize = 0;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "walTotalSizeLimit", walSizeLimit));
-  dbOptions.max_total_wal_size = maxTotalWalSize / 1e6;
-
-  bool walCompression = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "walCompression", walCompression));
-  dbOptions.wal_compression =
-      walCompression ? rocksdb::CompressionType::kZSTD : rocksdb::CompressionType::kNoCompression;
-
-  dbOptions.avoid_unnecessary_blocking_io = true;
-  dbOptions.write_dbid_to_manifest = true;
-  dbOptions.use_adaptive_mutex = true;      // We don't have soo many threads in the libuv thread pool...
-  dbOptions.enable_pipelined_write = true;  // We only write in the main thread...
-  dbOptions.create_missing_column_families = true;
-  dbOptions.fail_if_options_file_error = true;
-
-  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, "unorderedWrite", dbOptions.unordered_write));
-  NAPI_STATUS_THROWS(GetProperty(env, options, "pipelinedWrite", dbOptions.enable_pipelined_write));
-
-  // 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[3];
-
-  runAsync<std::vector<rocksdb::ColumnFamilyHandle*>>(
-      "leveldown.open", env, callback,
-      [=](auto& handles) {
-        rocksdb::DB* db = nullptr;
-        const auto status = descriptors.empty() ? rocksdb::DB::Open(dbOptions, location, &db)
-                                                : rocksdb::DB::Open(dbOptions, location, descriptors, &handles, &db);
-        database->db.reset(db);
-        return status;
-      },
-      [=](auto& handles, auto env, auto& argv) {
-        argv.resize(2);
-
-        const auto size = handles.size();
-        NAPI_STATUS_RETURN(napi_create_object(env, &argv[1]));
-
-        for (size_t n = 0; n < size; ++n) {
-          ColumnFamily column;
-          column.handle = handles[n];
-          column.descriptor = descriptors[n];
-          NAPI_STATUS_RETURN(napi_create_external(env, column.handle, nullptr, nullptr, &column.val));
-          NAPI_STATUS_RETURN(napi_create_reference(env, column.val, 1, &column.ref));
-          NAPI_STATUS_RETURN(napi_set_named_property(env, argv[1], descriptors[n].name.c_str(), column.val));
-          database->columns[column.handle->GetID()] = column;
-        }
-
-        return napi_ok;
-      });
+	std::lock_guard<std::mutex> lock(database->mutex);
+
+	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);
+
+		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;
+
+		uint32_t maxTotalWalSize = 0;
+		NAPI_STATUS_THROWS(GetProperty(env, options, "walTotalSizeLimit", walSizeLimit));
+		dbOptions.max_total_wal_size = maxTotalWalSize / 1e6;
+
+		bool walCompression = false;
+		NAPI_STATUS_THROWS(GetProperty(env, options, "walCompression", walCompression));
+		dbOptions.wal_compression =
+				walCompression ? rocksdb::CompressionType::kZSTD : rocksdb::CompressionType::kNoCompression;
+
+		dbOptions.avoid_unnecessary_blocking_io = true;
+		dbOptions.write_dbid_to_manifest = true;
+		dbOptions.enable_pipelined_write = true;  // We only write in the main thread...
+		dbOptions.create_missing_column_families = true;
+		dbOptions.fail_if_options_file_error = true;
+
+		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));
+
+		// 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", env, callback,
+				[=](auto& handles) {
+					assert(!database->db);
+
+					rocksdb::DB* db = nullptr;
+
+					// TODO (fix): There is a race condition here... Check if we are already opening the database.
+
+					const auto status = descriptors.empty()
+						? rocksdb::DB::Open(dbOptions, database->location, &db)
+						: rocksdb::DB::Open(dbOptions, database->location, descriptors, &handles, &db);
+
+					{
+						std::lock_guard<std::mutex> lock(database->mutex);
+						database->db.reset(db);
+					}
+
+					return status;
+				},
+				[=](auto& handles, auto env, auto& argv) {
+					argv.resize(2);
+
+					NAPI_STATUS_RETURN(napi_create_object(env, &argv[1]));
+
+					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;
+					}
+
+					napi_value columns;
+					NAPI_STATUS_RETURN(napi_create_object(env, &columns));
+					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));
+					}
+
+					return napi_ok;
+				});
+	}
 
   return 0;
 }
@@ -859,6 +943,8 @@ NAPI_METHOD(db_close) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
+	std::lock_guard<std::mutex> lock(database->mutex);
+
   auto callback = argv[1];
 
   struct State {};
@@ -1563,36 +1649,17 @@ NAPI_METHOD(batch_iterate) {
   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)));
-
-  auto options = argv[1];
-
-  bool sync = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "sync", sync));
-
-  auto callback = argv[2];
-
-  runAsync<bool>(
-      "leveldown.flushWal", env, callback, [=](auto& state) { return database->db->FlushWAL(sync); },
-      [=](auto& state, auto env, auto& argv) { return napi_ok; });
-
-  return 0;
-}
-
 NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
   NAPI_EXPORT_FUNCTION(db_get_identity);
+  NAPI_EXPORT_FUNCTION(db_get_handle);
+  NAPI_EXPORT_FUNCTION(db_get_location);
   NAPI_EXPORT_FUNCTION(db_close);
   NAPI_EXPORT_FUNCTION(db_get_many);
   NAPI_EXPORT_FUNCTION(db_clear);
   NAPI_EXPORT_FUNCTION(db_get_property);
   NAPI_EXPORT_FUNCTION(db_get_latest_sequence);
-  NAPI_EXPORT_FUNCTION(db_flush_wal);
   NAPI_EXPORT_FUNCTION(db_get_merge_operands);
 
   NAPI_EXPORT_FUNCTION(iterator_init);

package/deps/rocksdb/rocksdb/CMakeLists.txt

@@ -254,7 +254,7 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
 endif(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64")
 
 set(PORTABLE 0 CACHE STRING "Minimum CPU arch to support, or 0 = current CPU, 1 = baseline CPU")
-if(PORTABLE STREQUAL 1)
+if(PORTABLE MATCHES "1|ON|YES|TRUE|Y")
   # Usually nothing to do; compiler default is typically the most general
   if(NOT MSVC)
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "^s390x")
@@ -264,14 +264,7 @@ if(PORTABLE STREQUAL 1)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=loongarch64")
     endif()
   endif()
-elseif(PORTABLE MATCHES [^0]+)
-  # Name of a CPU arch spec or feature set to require
-  if(MSVC)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:${PORTABLE}")
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${PORTABLE}")
-  endif()
-else()
+elseif(PORTABLE MATCHES "0|OFF|NO|FALSE|N")
   if(MSVC)
     # NOTE: No auto-detection of current CPU, but instead assume some useful
     # level of optimization is supported
@@ -285,6 +278,13 @@ else()
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
     endif()
   endif()
+else()
+  # Name of a CPU arch spec or feature set to require
+  if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:${PORTABLE}")
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${PORTABLE}")
+  endif()
 endif()
 
 include(CheckCXXSourceCompiles)
@@ -632,6 +632,7 @@ set(SOURCES
         cache/secondary_cache.cc
         cache/secondary_cache_adapter.cc
         cache/sharded_cache.cc
+        cache/tiered_secondary_cache.cc
         db/arena_wrapped_db_iter.cc
         db/blob/blob_contents.cc
         db/blob/blob_fetcher.cc
@@ -714,6 +715,7 @@ set(SOURCES
         db/wal_manager.cc
         db/wide/wide_column_serialization.cc
         db/wide/wide_columns.cc
+        db/wide/wide_columns_helper.cc
         db/write_batch.cc
         db/write_batch_base.cc
         db/write_controller.cc
@@ -1262,6 +1264,7 @@ if(WITH_TESTS)
         cache/cache_test.cc
         cache/compressed_secondary_cache_test.cc
         cache/lru_cache_test.cc
+        cache/tiered_secondary_cache_test.cc
         db/blob/blob_counting_iterator_test.cc
         db/blob/blob_file_addition_test.cc
         db/blob/blob_file_builder_test.cc
@@ -1357,6 +1360,7 @@ if(WITH_TESTS)
         db/wal_edit_test.cc
         db/wide/db_wide_basic_test.cc
         db/wide/wide_column_serialization_test.cc
+        db/wide/wide_columns_helper_test.cc
         db/write_batch_test.cc
         db/write_callback_test.cc
         db/write_controller_test.cc

package/deps/rocksdb/rocksdb/Makefile

@@ -1885,6 +1885,9 @@ compressed_secondary_cache_test: $(OBJ_DIR)/cache/compressed_secondary_cache_tes
 lru_cache_test: $(OBJ_DIR)/cache/lru_cache_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
+tiered_secondary_cache_test: $(OBJ_DIR)/cache/tiered_secondary_cache_test.o $(TEST_LIBRARY) $(LIBRARY)
+	$(AM_LINK)
+
 range_del_aggregator_test: $(OBJ_DIR)/db/range_del_aggregator_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
@@ -1984,6 +1987,9 @@ cache_reservation_manager_test: $(OBJ_DIR)/cache/cache_reservation_manager_test.
 wide_column_serialization_test: $(OBJ_DIR)/db/wide/wide_column_serialization_test.o $(TEST_LIBRARY) $(LIBRARY)
 	$(AM_LINK)
 
+wide_columns_helper_test: $(OBJ_DIR)/db/wide/wide_columns_helper_test.o $(TEST_LIBRARY) $(LIBRARY)
+	$(AM_LINK)
+
 #-------------------------------------------------
 # make install related stuff
 PREFIX ?= /usr/local
@@ -2088,8 +2094,8 @@ ROCKSDB_JAVADOCS_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-javadoc.jar
 ROCKSDB_SOURCES_JAR = rocksdbjni-$(ROCKSDB_JAVA_VERSION)-sources.jar
 SHA256_CMD = sha256sum
 
-ZLIB_VER ?= 1.2.13
-ZLIB_SHA256 ?= b3a24de97a8fdbc835b9833169501030b8977031bcb54b3b3ac13740f846ab30
+ZLIB_VER ?= 1.3
+ZLIB_SHA256 ?= ff0ba4c292013dbc27530b3a81e1f9a813cd39de01ca5e0f8bf355702efa593e
 ZLIB_DOWNLOAD_BASE ?= http://zlib.net
 BZIP2_VER ?= 1.0.8
 BZIP2_SHA256 ?= ab5a03176ee106d3f0fa90e381da478ddae405918153cca248e682cd0c4a2269
@@ -2097,11 +2103,11 @@ BZIP2_DOWNLOAD_BASE ?= http://sourceware.org/pub/bzip2
 SNAPPY_VER ?= 1.1.8
 SNAPPY_SHA256 ?= 16b677f07832a612b0836178db7f374e414f94657c138e6993cbfc5dcc58651f
 SNAPPY_DOWNLOAD_BASE ?= https://github.com/google/snappy/archive
-LZ4_VER ?= 1.9.3
-LZ4_SHA256 ?= 030644df4611007ff7dc962d981f390361e6c97a34e5cbc393ddfbe019ffe2c1
+LZ4_VER ?= 1.9.4
+LZ4_SHA256 ?= 0b0e3aa07c8c063ddf40b082bdf7e37a1562bda40a0ff5272957f3e987e0e54b
 LZ4_DOWNLOAD_BASE ?= https://github.com/lz4/lz4/archive
-ZSTD_VER ?= 1.4.9
-ZSTD_SHA256 ?= acf714d98e3db7b876e5b540cbf6dee298f60eb3c0723104f6d3f065cd60d6a8
+ZSTD_VER ?= 1.5.5
+ZSTD_SHA256 ?= 98e9c3d949d1b924e28e01eccb7deed865eefebf25c2f21c702e5cd5b63b85e1
 ZSTD_DOWNLOAD_BASE ?= https://github.com/facebook/zstd/archive
 CURL_SSL_OPTS ?= --tlsv1
 
@@ -2413,6 +2419,9 @@ jtest_run:
 jtest: rocksdbjava
 	cd java;$(MAKE) sample test
 
+jpmd: rocksdbjava rocksdbjavageneratepom
+	cd java;$(MAKE) pmd
+
 jdb_bench:
 	cd java;$(MAKE) db_bench;
 

package/deps/rocksdb/rocksdb/README.md

@@ -0,0 +1,29 @@
+## RocksDB: A Persistent Key-Value Store for Flash and RAM Storage
+
+[![CircleCI Status](https://circleci.com/gh/facebook/rocksdb.svg?style=svg)](https://circleci.com/gh/facebook/rocksdb)
+
+RocksDB is developed and maintained by Facebook Database Engineering Team.
+It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com)
+and Jeff Dean (jeff@google.com)
+
+This code is a library that forms the core building block for a fast
+key-value server, especially suited for storing data on flash drives.
+It has a Log-Structured-Merge-Database (LSM) design with flexible tradeoffs
+between Write-Amplification-Factor (WAF), Read-Amplification-Factor (RAF)
+and Space-Amplification-Factor (SAF). It has multi-threaded compactions,
+making it especially suitable for storing multiple terabytes of data in a
+single database.
+
+Start with example usage here: https://github.com/facebook/rocksdb/tree/main/examples
+
+See the [github wiki](https://github.com/facebook/rocksdb/wiki) for more explanation.
+
+The public interface is in `include/`.  Callers should not include or
+rely on the details of any other header files in this package.  Those
+internal APIs may be changed without warning.
+
+Questions and discussions are welcome on the [RocksDB Developers Public](https://www.facebook.com/groups/rocksdb.dev/) Facebook group and [email list](https://groups.google.com/g/rocksdb) on Google Groups.
+
+## License
+
+RocksDB is dual-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).  You may select, at your option, one of the above-listed licenses.