Merge pull request #292 from HarperFast/get-db-property

Get db property

Author: cb1kenobi

README.md

@@ -231,6 +231,26 @@ await promise;
 console.log(db.getOldestSnapshotTimestamp()); // returns `0`, no snapshots
 ```
 
+### `db.getDBProperty(propertyName: string): string`
+Gets a RocksDB database property as a string.
+- `propertyName: string` The name of the property to retrieve (e.g., ) `'rocksdb.levelstats'`.
+```typescript
+const db = RocksDatabase.open('/path/to/database');
+const levelStats = db.getDBProperty('rocksdb.levelstats');
+const stats = db.getDBProperty('rocksdb.stats');
+```
+
+
+### `db.getDBIntProperty(propertyName: string): number`
+Gets a RocksDB database property as an integer.
+- `propertyName: string` The name of the property to retrieve (e.g., ) `'rocksdb.num-blob-files'`.
+```typescript
+const db = RocksDatabase.open('/path/to/database');
+const blobFiles = db.getDBIntProperty('rocksdb.num-blob-files');
+const numKeys = db.getDBIntProperty('rocksdb.estimate-num-keys');
+```
+
+
 ### `db.getRange(options?: IteratorOptions): ExtendedIterable`
 
 Retrieves a range of keys and their values. Supports both synchronous and

src/binding/database.cpp

@@ -504,6 +504,75 @@ napi_value Database::GetOldestSnapshotTimestamp(napi_env env, napi_callback_info
 	return result;
 }
 
+/**
+ * Gets a RocksDB database property as a string.
+ *
+ * @example
+ * ```typescript
+ * const db = NativeDatabase.open('path/to/db');
+ * const levelStats = db.getDBProperty('rocksdb.levelstats');
+ * ```
+ */
+napi_value Database::GetDBProperty(napi_env env, napi_callback_info info) {
+	NAPI_METHOD_ARGV(1)
+	UNWRAP_DB_HANDLE_AND_OPEN()
+
+	NAPI_GET_STRING(argv[0], propertyName, "Property name is required")
+
+	std::string value;
+	bool success = (*dbHandle)->descriptor->db->GetProperty(
+		(*dbHandle)->column.get(),
+		propertyName,
+		&value
+	);
+
+	if (!success) {
+		::napi_throw_error(env, nullptr, "Failed to get database property");
+		NAPI_RETURN_UNDEFINED()
+	}
+
+	napi_value result;
+	NAPI_STATUS_THROWS(::napi_create_string_utf8(
+		env,
+		value.c_str(),
+		value.length(),
+		&result
+	))
+	return result;
+}
+
+/**
+ * Gets a RocksDB database property as an integer.
+ *
+ * @example
+ * ```typescript
+ * const db = NativeDatabase.open('path/to/db');
+ * const blobFiles = db.getDBIntProperty('rocksdb.num-blob-files');
+ * ```
+ */
+napi_value Database::GetDBIntProperty(napi_env env, napi_callback_info info) {
+	NAPI_METHOD_ARGV(1)
+	UNWRAP_DB_HANDLE_AND_OPEN()
+
+	NAPI_GET_STRING(argv[0], propertyName, "Property name is required")
+
+	uint64_t value = 0;
+	bool success = (*dbHandle)->descriptor->db->GetIntProperty(
+		(*dbHandle)->column.get(),
+		propertyName,
+		&value
+	);
+
+	if (!success) {
+		::napi_throw_error(env, nullptr, "Failed to get database integer property");
+		NAPI_RETURN_UNDEFINED()
+	}
+
+	napi_value result;
+	NAPI_STATUS_THROWS(::napi_create_int64(env, value, &result))
+	return result;
+}
+
 /**
  * Gets a value from the RocksDB database.
  *
@@ -971,6 +1040,8 @@ void Database::Init(napi_env env, napi_value exports) {
 		{ "flushSync", nullptr, FlushSync, nullptr, nullptr, nullptr, napi_default, nullptr },
 		{ "get", nullptr, Get, nullptr, nullptr, nullptr, napi_default, nullptr },
 		{ "getCount", nullptr, GetCount, nullptr, nullptr, nullptr, napi_default, nullptr },
+		{ "getDBIntProperty", nullptr, GetDBIntProperty, nullptr, nullptr, nullptr, napi_default, nullptr },
+		{ "getDBProperty", nullptr, GetDBProperty, nullptr, nullptr, nullptr, napi_default, nullptr },
 		{ "getMonotonicTimestamp", nullptr, GetMonotonicTimestamp, nullptr, nullptr, nullptr, napi_default, nullptr },
 		{ "getOldestSnapshotTimestamp", nullptr, GetOldestSnapshotTimestamp, nullptr, nullptr, nullptr, napi_default, nullptr },
 		{ "getSync", nullptr, GetSync, nullptr, nullptr, nullptr, napi_default, nullptr },

src/binding/database.h

@@ -41,6 +41,8 @@ struct Database final {
 	static napi_value FlushSync(napi_env env, napi_callback_info info);
 	static napi_value Get(napi_env env, napi_callback_info info);
 	static napi_value GetCount(napi_env env, napi_callback_info info);
+	static napi_value GetDBIntProperty(napi_env env, napi_callback_info info);
+	static napi_value GetDBProperty(napi_env env, napi_callback_info info);
 	static napi_value GetMonotonicTimestamp(napi_env env, napi_callback_info info);
 	static napi_value GetOldestSnapshotTimestamp(napi_env env, napi_callback_info info);
 	static napi_value GetSync(napi_env env, napi_callback_info info);

src/binding/db_descriptor.cpp

@@ -460,6 +460,12 @@ std::shared_ptr<DBDescriptor> DBDescriptor::open(const std::string& path, const
 	dbOptions.IncreaseParallelism(options.parallelismThreads);
 	dbOptions.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
 
+	// Define base ColumnFamilyOptions that include blob settings
+	rocksdb::ColumnFamilyOptions cfOptions;
+	cfOptions.enable_blob_files = true;
+	cfOptions.min_blob_size = 1024; // Ensure this matches your requirement
+	cfOptions.enable_blob_garbage_collection = true;
+
 	// create a shared pointer to hold the weak descriptor reference for the event listener
 	auto descriptorWeakPtr = std::make_shared<std::weak_ptr<DBDescriptor>>();
 	auto eventListener = std::make_shared<TransactionLogEventListener>(descriptorWeakPtr);
@@ -476,13 +482,13 @@ std::shared_ptr<DBDescriptor> DBDescriptor::open(const std::string& path, const
 		// database exists, use existing column families
 		for (const auto& cfName : columnFamilyNames) {
 			DEBUG_LOG("DBDescriptor::open Opening column family \"%s\"\n", cfName.c_str())
-			cfDescriptors.emplace_back(cfName, rocksdb::ColumnFamilyOptions());
+			cfDescriptors.emplace_back(cfName, cfOptions); // Use cfOptions here
 		}
 	} else {
 		// database doesn't exist or no column families found, use default
 		DEBUG_LOG("DBDescriptor::open Database doesn't exist or no column families found, using default\n")
 		cfDescriptors = {
-			rocksdb::ColumnFamilyDescriptor(rocksdb::kDefaultColumnFamilyName, rocksdb::ColumnFamilyOptions())
+			rocksdb::ColumnFamilyDescriptor(rocksdb::kDefaultColumnFamilyName, cfOptions) // Use cfOptions here
 		};
 	}
 

src/database.ts

@@ -154,6 +154,40 @@ export class RocksDatabase extends DBI<DBITransactional> {
 		return this.store.db.getOldestSnapshotTimestamp();
 	}
 
+	/**
+	 * Gets a RocksDB database property as a string.
+	 *
+	 * @param propertyName - The name of the property to retrieve (e.g., 'rocksdb.levelstats').
+	 * @returns The property value as a string.
+	 *
+	 * @example
+	 * ```typescript
+	 * const db = RocksDatabase.open('/path/to/database');
+	 * const levelStats = db.getDBProperty('rocksdb.levelstats');
+	 * const stats = db.getDBProperty('rocksdb.stats');
+	 * ```
+	 */
+	getDBProperty(propertyName: string): string {
+		return this.store.db.getDBProperty(propertyName);
+	}
+
+	/**
+	 * Gets a RocksDB database property as an integer.
+	 *
+	 * @param propertyName - The name of the property to retrieve (e.g., 'rocksdb.num-blob-files').
+	 * @returns The property value as a number.
+	 *
+	 * @example
+	 * ```typescript
+	 * const db = RocksDatabase.open('/path/to/database');
+	 * const blobFiles = db.getDBIntProperty('rocksdb.num-blob-files');
+	 * const numKeys = db.getDBIntProperty('rocksdb.estimate-num-keys');
+	 * ```
+	 */
+	getDBIntProperty(propertyName: string): number {
+		return this.store.db.getDBIntProperty(propertyName);
+	}
+
 	/**
 	 * Flushes the underlying database by performing a commit or clearing any buffered operations.
 	 *

src/index.ts

@@ -5,7 +5,7 @@ export { Store, type Context } from './store.js';
 export { DBIterator } from './dbi-iterator.js';
 export { Transaction } from './transaction.js';
 export type { Key } from './encoding.js';
-export { constants, TransactionLog, shutdown } from './load-binding.js';
+export { constants, TransactionLog, shutdown, type TransactionEntry } from './load-binding.js';
 export * from './parse-transaction-log.js';
 import './transaction-log-reader.js';
 

src/load-binding.ts

@@ -109,6 +109,8 @@ export type NativeDatabase = {
 	notify(event: string | BufferWithDataView, args?: any[]): boolean;
 	get(key: BufferWithDataView, resolve: ResolveCallback<Buffer>, reject: RejectCallback, txnId?: number): number;
 	getCount(options?: RangeOptions, txnId?: number): number;
+	getDBIntProperty(propertyName: string): number;
+	getDBProperty(propertyName: string): string;
 	getMonotonicTimestamp(): number;
 	getOldestSnapshotTimestamp(): number;
 	getSync(key: BufferWithDataView, txnId?: number): Buffer;

test/db-properties.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, it } from 'vitest';
+import { dbRunner } from './lib/util.js';
+describe('Database Properties', () => {
+	it('should get string property from database', () => dbRunner(async ({ db }) => {
+		// Put some data to ensure the database has stats
+		await db.put('key1', 'value1');
+		await db.put('key2', 'value2');
+		await db.flush();
+
+		// Get level stats property
+		const levelStats = db.getDBProperty('rocksdb.levelstats');
+		expect(levelStats).toBeDefined();
+		expect(typeof levelStats).toBe('string');
+		expect(levelStats.length).toBeGreaterThan(0);
+	}));
+
+	it('should get stats property from database', () => dbRunner(async ({ db }) => {
+		// Put some data
+		await db.put('foo', 'bar');
+		await db.flush();
+
+		// Get stats property
+		const stats = db.getDBProperty('rocksdb.stats');
+		expect(stats).toBeDefined();
+		expect(typeof stats).toBe('string');
+		expect(stats.length).toBeGreaterThan(0);
+	}));
+
+	it('should get integer property from database', () => dbRunner(async ({ db }) => {
+		// Put some data
+		await db.put('key1', 'value1');
+		await db.put('key2', 'value2');
+
+		// Get estimated number of keys
+		const numKeys = db.getDBIntProperty('rocksdb.estimate-num-keys');
+		expect(numKeys).toBeDefined();
+		expect(typeof numKeys).toBe('number');
+		expect(numKeys).toBeGreaterThan(0);
+	}));
+
+	it('should get num-files-at-level property', () => dbRunner(async ({ db }) => {
+		// Put some data and flush to create files
+		await db.put('key1', 'value1');
+		await db.put('key2', 'value2');
+		await db.flush();
+
+		// Get number of files at level 0, for some reason this is a string property
+		const numFiles = +db.getDBProperty('rocksdb.num-files-at-level0');
+		expect(numFiles).toBeDefined();
+		expect(typeof numFiles).toBe('number');
+		expect(numFiles).toBeGreaterThan(0);
+	}));
+
+	it('should test blob files with num-blob-files property', () => dbRunner(async ({ db }) => {
+		// Create large values that should trigger blob storage
+		// RocksDB typically uses blobs for values larger than a threshold (often 1KB or configurable)
+		const largeValue = 'x'.repeat(10000); // 10KB value to ensure blob creation
+
+		// Write multiple large values
+		await db.put('blob1', largeValue);
+		await db.put('blob2', largeValue);
+		await db.put('blob3', largeValue);
+		await db.flush();
+
+		// Get number of blob files
+		const numBlobFiles = db.getDBIntProperty('rocksdb.num-blob-files');
+		expect(numBlobFiles).toBeDefined();
+		expect(typeof numBlobFiles).toBe('number');
+		expect(numBlobFiles).toBeGreaterThan(0);
+
+		// Note: Whether blobs are actually created depends on RocksDB configuration
+		// The test verifies the method works, not necessarily that blobs are created
+	}));
+
+	it('should get live-blob-file-size property', () => dbRunner(async ({ db }) => {
+		// Create large values
+		const largeValue = 'x'.repeat(10000);
+		await db.put('blob1', largeValue);
+		await db.put('blob2', largeValue);
+		await db.flush();
+
+		// Get live blob file size
+		const blobSize = db.getDBIntProperty('rocksdb.live-blob-file-size');
+		expect(blobSize).toBeDefined();
+		expect(typeof blobSize).toBe('number');
+		expect(blobSize).toBeGreaterThan(0);
+	}));
+
+	it('should get total-blob-file-size property', () => dbRunner(async ({ db }) => {
+		// Create large values
+		const largeValue = 'x'.repeat(10000);
+		await db.put('blob1', largeValue);
+		await db.flush();
+
+		// Get total blob file size
+		const totalBlobSize = db.getDBIntProperty('rocksdb.total-blob-file-size');
+		expect(totalBlobSize).toBeDefined();
+		expect(typeof totalBlobSize).toBe('number');
+		expect(totalBlobSize).toBeGreaterThan(0);
+	}));
+
+	it('should get background-errors property', () => dbRunner(async ({ db }) => {
+		const bgErrors = db.getDBIntProperty('rocksdb.background-errors');
+		expect(bgErrors).toBeDefined();
+		expect(typeof bgErrors).toBe('number');
+		expect(bgErrors).toBe(0); // Should be 0 for a healthy database
+	}));
+
+	it('should get cur-size-all-mem-tables property', () => dbRunner(async ({ db }) => {
+		await db.put('key1', 'value1');
+		await db.put('key2', 'value2');
+
+		const memTableSize = db.getDBIntProperty('rocksdb.cur-size-all-mem-tables');
+		expect(memTableSize).toBeDefined();
+		expect(typeof memTableSize).toBe('number');
+		expect(memTableSize).toBeGreaterThan(0);
+	}));
+
+	it('should throw error for invalid string property', () => dbRunner(async ({ db }) => {
+		expect(() => {
+			db.getDBProperty(undefined as any);
+		}).toThrow('Property name is required');
+
+		expect(() => {
+			db.getDBProperty('invalid.property.name.that.does.not.exist');
+		}).toThrow('Failed to get database property');
+	}));
+
+	it('should throw error for invalid integer property', () => dbRunner(async ({ db }) => {
+		expect(() => {
+			db.getDBIntProperty(undefined as any);
+		}).toThrow('Property name is required');
+		
+		expect(() => {
+			db.getDBIntProperty('invalid.property.name.that.does.not.exist');
+		}).toThrow('Failed to get database integer property');
+	}));
+
+	it('should throw error when database is not open', () => dbRunner({ skipOpen: true }, async ({ db }) => {
+		expect(() => {
+			db.getDBProperty('rocksdb.stats');
+		}).toThrow('Database not open');
+
+		expect(() => {
+			db.getDBIntProperty('rocksdb.estimate-num-keys');
+		}).toThrow('Database not open');
+	}));
+});