Note: not every field round-trips. The persisted fields are the ones the engine + * stores in a column family's {@code config.ini} (write buffer size, level ratios, + * compression, bloom/index settings, sync mode, skip list parameters, isolation level, + * compaction triggers, tombstone density, B+tree and object-store flags, and the + * comparator name). Runtime-only fields such as commit hooks are not persisted.
+ * + * @param iniFile path to the INI file to write + * @param sectionName section name to write the configuration under + * @throws TidesDBException if the file cannot be written + */ + public void saveToIni(String iniFile, String sectionName) throws TidesDBException { + if (iniFile == null || iniFile.isEmpty()) { + throw new IllegalArgumentException("INI file path cannot be null or empty"); + } + if (sectionName == null || sectionName.isEmpty()) { + throw new IllegalArgumentException("Section name cannot be null or empty"); + } + nativeSaveToIni(iniFile, sectionName, + writeBufferSize, levelSizeRatio, minLevels, dividingLevelOffset, klogValueThreshold, + compressionAlgorithm.getValue(), enableBloomFilter, bloomFPR, enableBlockIndexes, + indexSampleRatio, blockIndexPrefixLen, syncMode.getValue(), syncIntervalUs, + comparatorName, skipListMaxLevel, skipListProbability, + defaultIsolationLevel.getValue(), minDiskSpace, l1FileCountTrigger, + l0QueueStallThreshold, tombstoneDensityTrigger, tombstoneDensityMinEntries, + useBtree, objectLazyCompaction, objectPrefetchCompaction); + } + + /** + * Loads a column family configuration from an INI file section previously written by + * {@link #saveToIni(String, String)} (or produced by the engine for an existing column + * family). Fields absent from the section fall back to the engine defaults. + * + * @param iniFile path to the INI file to read + * @param sectionName section name to read the configuration from + * @return the loaded configuration + * @throws TidesDBException if the file cannot be read or the section is missing + */ + public static ColumnFamilyConfig loadFromIni(String iniFile, String sectionName) throws TidesDBException { + if (iniFile == null || iniFile.isEmpty()) { + throw new IllegalArgumentException("INI file path cannot be null or empty"); + } + if (sectionName == null || sectionName.isEmpty()) { + throw new IllegalArgumentException("Section name cannot be null or empty"); + } + return nativeLoadFromIni(iniFile, sectionName); + } + private static native double nativeDefaultTombstoneDensityTrigger(); private static native long nativeDefaultTombstoneDensityMinEntries(); + private static native void nativeSaveToIni(String iniFile, String sectionName, + long writeBufferSize, long levelSizeRatio, int minLevels, int dividingLevelOffset, + long klogValueThreshold, int compressionAlgorithm, boolean enableBloomFilter, + double bloomFPR, boolean enableBlockIndexes, int indexSampleRatio, int blockIndexPrefixLen, + int syncMode, long syncIntervalUs, String comparatorName, int skipListMaxLevel, + float skipListProbability, int defaultIsolationLevel, long minDiskSpace, + int l1FileCountTrigger, int l0QueueStallThreshold, double tombstoneDensityTrigger, + long tombstoneDensityMinEntries, boolean useBtree, boolean objectLazyCompaction, + boolean objectPrefetchCompaction) throws TidesDBException; + private static native ColumnFamilyConfig nativeLoadFromIni(String iniFile, String sectionName) throws TidesDBException; /** * Builder for ColumnFamilyConfig. diff --git a/src/main/java/com/tidesdb/Config.java b/src/main/java/com/tidesdb/Config.java index a6169e0..b72dbd2 100644 --- a/src/main/java/com/tidesdb/Config.java +++ b/src/main/java/com/tidesdb/Config.java @@ -45,6 +45,7 @@ public class Config { private String objectStoreFsPath; private ObjectStoreConfig objectStoreConfig; private int maxConcurrentFlushes; + private boolean finishCompactionsOnClose; private Config(Builder builder) { this.dbPath = builder.dbPath; @@ -65,6 +66,7 @@ private Config(Builder builder) { this.objectStoreFsPath = builder.objectStoreFsPath; this.objectStoreConfig = builder.objectStoreConfig; this.maxConcurrentFlushes = builder.maxConcurrentFlushes; + this.finishCompactionsOnClose = builder.finishCompactionsOnClose; } /** @@ -172,6 +174,16 @@ public int getMaxConcurrentFlushes() { return maxConcurrentFlushes; } + /** + * Returns the close behavior for in-flight compactions. + * + * @return true if {@code close()} waits for in-flight compactions to finish; + * false (default) cancels them at their next checkpoint for a fast shutdown + */ + public boolean isFinishCompactionsOnClose() { + return finishCompactionsOnClose; + } + /** * Builder for Config. */ @@ -194,6 +206,7 @@ public static class Builder { private String objectStoreFsPath = null; private ObjectStoreConfig objectStoreConfig = null; private int maxConcurrentFlushes = 0; + private boolean finishCompactionsOnClose = false; public Builder dbPath(String dbPath) { this.dbPath = dbPath; @@ -285,6 +298,20 @@ public Builder maxConcurrentFlushes(int maxConcurrentFlushes) { return this; } + /** + * Sets the close behavior for in-flight compactions. + * + * @param finishCompactionsOnClose false (default) cancels in-flight compactions at their + * next checkpoint for a fast shutdown (no data is lost; recovery handles a mid-merge + * state). true lets in-flight compactions run to completion before {@code close()} + * returns. + * @return this builder + */ + public Builder finishCompactionsOnClose(boolean finishCompactionsOnClose) { + this.finishCompactionsOnClose = finishCompactionsOnClose; + return this; + } + public Config build() { validate(); return new Config(this); diff --git a/src/main/java/com/tidesdb/DbStats.java b/src/main/java/com/tidesdb/DbStats.java index c5ae3b9..83d8718 100644 --- a/src/main/java/com/tidesdb/DbStats.java +++ b/src/main/java/com/tidesdb/DbStats.java @@ -54,6 +54,14 @@ public class DbStats { private final long totalUploads; private final long totalUploadFailures; private final boolean replicaMode; + private final long uwalBytesWritten; + private final long walBytesWritten; + private final long flushBytesWritten; + private final long compactionBytesWritten; + private final long compactionBytesRead; + private final long userBytesWritten; + private final long flushCount; + private final long compactionCount; public DbStats(int numColumnFamilies, long totalMemory, long availableMemory, long resolvedMemoryLimit, int memoryPressureLevel, int flushPendingCount, @@ -66,7 +74,10 @@ public DbStats(int numColumnFamilies, long totalMemory, long availableMemory, boolean objectStoreEnabled, String objectStoreConnector, long localCacheBytesUsed, long localCacheBytesMax, int localCacheNumFiles, long lastUploadedGeneration, long uploadQueueDepth, - long totalUploads, long totalUploadFailures, boolean replicaMode) { + long totalUploads, long totalUploadFailures, boolean replicaMode, + long uwalBytesWritten, long walBytesWritten, long flushBytesWritten, + long compactionBytesWritten, long compactionBytesRead, long userBytesWritten, + long flushCount, long compactionCount) { this.numColumnFamilies = numColumnFamilies; this.totalMemory = totalMemory; this.availableMemory = availableMemory; @@ -98,6 +109,14 @@ public DbStats(int numColumnFamilies, long totalMemory, long availableMemory, this.totalUploads = totalUploads; this.totalUploadFailures = totalUploadFailures; this.replicaMode = replicaMode; + this.uwalBytesWritten = uwalBytesWritten; + this.walBytesWritten = walBytesWritten; + this.flushBytesWritten = flushBytesWritten; + this.compactionBytesWritten = compactionBytesWritten; + this.compactionBytesRead = compactionBytesRead; + this.userBytesWritten = userBytesWritten; + this.flushCount = flushCount; + this.compactionCount = compactionCount; } public int getNumColumnFamilies() { @@ -224,6 +243,84 @@ public boolean isReplicaMode() { return replicaMode; } + /** + * Gets the framed bytes appended to the shared unified WAL (lifetime since open). + * Returns 0 when unified memtable mode is off. + * + * @return unified WAL bytes written + */ + public long getUwalBytesWritten() { + return uwalBytesWritten; + } + + /** + * Gets the per-column-family WAL bytes summed across all column families + * (lifetime since open). + * + * @return WAL bytes written across all CFs + */ + public long getWalBytesWritten() { + return walBytesWritten; + } + + /** + * Gets the flush output bytes summed across all column families (lifetime since open). + * + * @return flush output bytes written across all CFs + */ + public long getFlushBytesWritten() { + return flushBytesWritten; + } + + /** + * Gets the compaction output bytes summed across all column families (lifetime since open). + * + * @return compaction output bytes written across all CFs + */ + public long getCompactionBytesWritten() { + return compactionBytesWritten; + } + + /** + * Gets the compaction input bytes summed across all column families (lifetime since open). + * + * @return compaction input bytes read across all CFs + */ + public long getCompactionBytesRead() { + return compactionBytesRead; + } + + /** + * Gets the logical committed bytes summed across all column families (lifetime since open). + * This is the database-wide write-amplification denominator: + * {@code (uwal + wal + flush + compaction) / userBytesWritten}. + * + * @return user bytes written across all CFs + */ + public long getUserBytesWritten() { + return userBytesWritten; + } + + /** + * Gets the number of flushed SSTables summed across all column families + * (lifetime since open). + * + * @return flush count across all CFs + */ + public long getFlushCount() { + return flushCount; + } + + /** + * Gets the number of compaction output SSTables summed across all column families + * (lifetime since open). + * + * @return compaction count across all CFs + */ + public long getCompactionCount() { + return compactionCount; + } + @Override public String toString() { return "DbStats{" + @@ -258,6 +355,14 @@ public String toString() { ", totalUploads=" + totalUploads + ", totalUploadFailures=" + totalUploadFailures + ", replicaMode=" + replicaMode + + ", uwalBytesWritten=" + uwalBytesWritten + + ", walBytesWritten=" + walBytesWritten + + ", flushBytesWritten=" + flushBytesWritten + + ", compactionBytesWritten=" + compactionBytesWritten + + ", compactionBytesRead=" + compactionBytesRead + + ", userBytesWritten=" + userBytesWritten + + ", flushCount=" + flushCount + + ", compactionCount=" + compactionCount + '}'; } } diff --git a/src/main/java/com/tidesdb/Stats.java b/src/main/java/com/tidesdb/Stats.java index 37b6f5b..44aa721 100644 --- a/src/main/java/com/tidesdb/Stats.java +++ b/src/main/java/com/tidesdb/Stats.java @@ -44,6 +44,13 @@ public class Stats { private final long[] levelTombstoneCounts; private final double maxSstDensity; private final int maxSstDensityLevel; + private final long walBytesWritten; + private final long flushBytesWritten; + private final long compactionBytesWritten; + private final long compactionBytesRead; + private final long userBytesWritten; + private final long flushCount; + private final long compactionCount; public Stats(int numLevels, long memtableSize, long[] levelSizes, int[] levelNumSSTables, ColumnFamilyConfig config, long totalKeys, long totalDataSize, @@ -51,7 +58,10 @@ public Stats(int numLevels, long memtableSize, long[] levelSizes, int[] levelNum double readAmp, double hitRate, boolean useBtree, long btreeTotalNodes, int btreeMaxHeight, double btreeAvgHeight, long totalTombstones, double tombstoneRatio, long[] levelTombstoneCounts, - double maxSstDensity, int maxSstDensityLevel) { + double maxSstDensity, int maxSstDensityLevel, + long walBytesWritten, long flushBytesWritten, long compactionBytesWritten, + long compactionBytesRead, long userBytesWritten, long flushCount, + long compactionCount) { this.numLevels = numLevels; this.memtableSize = memtableSize; this.levelSizes = levelSizes; @@ -73,6 +83,13 @@ public Stats(int numLevels, long memtableSize, long[] levelSizes, int[] levelNum this.levelTombstoneCounts = levelTombstoneCounts; this.maxSstDensity = maxSstDensity; this.maxSstDensityLevel = maxSstDensityLevel; + this.walBytesWritten = walBytesWritten; + this.flushBytesWritten = flushBytesWritten; + this.compactionBytesWritten = compactionBytesWritten; + this.compactionBytesRead = compactionBytesRead; + this.userBytesWritten = userBytesWritten; + this.flushCount = flushCount; + this.compactionCount = compactionCount; } /** @@ -271,6 +288,76 @@ public int getMaxSstDensityLevel() { return maxSstDensityLevel; } + /** + * Gets the framed bytes appended to this column family's WAL (lifetime since open). + * Always 0 in unified memtable mode, where the shared WAL volume is reported db-wide + * via {@link DbStats#getUwalBytesWritten()}. + * + * @return WAL bytes written + */ + public long getWalBytesWritten() { + return walBytesWritten; + } + + /** + * Gets the on-disk bytes this column family's flushes wrote to L0 SSTables + * (lifetime since open). + * + * @return flush output bytes written + */ + public long getFlushBytesWritten() { + return flushBytesWritten; + } + + /** + * Gets the on-disk bytes this column family's compactions wrote (lifetime since open). + * + * @return compaction output bytes written + */ + public long getCompactionBytesWritten() { + return compactionBytesWritten; + } + + /** + * Gets the on-disk bytes this column family's compactions read as input + * (lifetime since open). + * + * @return compaction input bytes read + */ + public long getCompactionBytesRead() { + return compactionBytesRead; + } + + /** + * Gets the logical key+value bytes committed to this column family (lifetime since open). + * This is the write-amplification denominator: divide the WAL, flush, and compaction + * write totals by this value to compute write amplification. + * + * @return user bytes written + */ + public long getUserBytesWritten() { + return userBytesWritten; + } + + /** + * Gets the number of flushed SSTables produced by this column family (lifetime since open). + * + * @return flush count + */ + public long getFlushCount() { + return flushCount; + } + + /** + * Gets the number of compaction output SSTables produced by this column family + * (lifetime since open). + * + * @return compaction count + */ + public long getCompactionCount() { + return compactionCount; + } + @Override public String toString() { StringBuilder sb = new StringBuilder(); @@ -292,6 +379,13 @@ public String toString() { sb.append(", tombstoneRatio=").append(tombstoneRatio); sb.append(", maxSstDensity=").append(maxSstDensity); sb.append(", maxSstDensityLevel=").append(maxSstDensityLevel); + sb.append(", walBytesWritten=").append(walBytesWritten); + sb.append(", flushBytesWritten=").append(flushBytesWritten); + sb.append(", compactionBytesWritten=").append(compactionBytesWritten); + sb.append(", compactionBytesRead=").append(compactionBytesRead); + sb.append(", userBytesWritten=").append(userBytesWritten); + sb.append(", flushCount=").append(flushCount); + sb.append(", compactionCount=").append(compactionCount); if (levelSizes != null) { sb.append(", levelSizes=["); for (int i = 0; i < levelSizes.length; i++) { diff --git a/src/main/java/com/tidesdb/TidesDB.java b/src/main/java/com/tidesdb/TidesDB.java index 635d0b1..0000601 100644 --- a/src/main/java/com/tidesdb/TidesDB.java +++ b/src/main/java/com/tidesdb/TidesDB.java @@ -87,7 +87,8 @@ public static TidesDB open(Config config) throws TidesDBException { osc != null ? osc.isReplicaMode() : false, osc != null ? osc.getReplicaSyncIntervalUs() : 5000000, osc != null ? osc.isReplicaReplayWal() : true, - config.getMaxConcurrentFlushes() + config.getMaxConcurrentFlushes(), + config.isFinishCompactionsOnClose() ); return new TidesDB(handle); @@ -361,7 +362,40 @@ public DbStats getDbStats() throws TidesDBException { checkNotClosed(); return nativeGetDbStats(nativeHandle); } - + + /** + * Cancels background compaction database-wide. In-flight merges bail safely at their + * next checkpoint (their uncommitted output is discarded, inputs are left intact, so no + * data is lost) and any queued compaction is skipped. Flushes are unaffected, so + * durability is preserved. Blocks (bounded) until compaction is idle. + * + *The cancellation is sticky for the session and is reset on the next open. It is + * intended to be called immediately before {@link #close()} for a fast shutdown.
+ * + * @throws TidesDBException if the operation fails + */ + public void cancelBackgroundWork() throws TidesDBException { + checkNotClosed(); + nativeCancelBackgroundWork(nativeHandle); + } + + /** + * Raises this process's open-file ceiling toward {@code desired} descriptors so a database + * can keep more SSTables open. The engine sizes {@code maxOpenSSTables} to fit this at open + * time, so call it before {@link #open(Config)}. This is an explicit, opt-in + * operator action; TidesDB never raises the limit itself. + * + *On POSIX systems (Linux, macOS, the BSDs, illumos) this raises the {@code RLIMIT_NOFILE} + * soft limit toward the hard limit; on Windows it raises the CRT stdio cap (max 8192). A + * failed or partial raise is non-fatal.
+ * + * @param desired target descriptor count; values ≤ 0 just report the current ceiling + * @return the open-file ceiling in effect after the attempt + */ + public static long raiseOpenFileLimit(long desired) { + return nativeRaiseOpenFileLimit(desired); + } + private void checkNotClosed() { if (closed) { throw new IllegalStateException("TidesDB instance is closed"); @@ -391,7 +425,8 @@ private static native long nativeOpen(String dbPath, int numFlushThreads, int nu boolean oscWalSyncOnCommit, boolean oscReplicaMode, long oscReplicaSyncIntervalUs, boolean oscReplicaReplayWal, - int maxConcurrentFlushes) throws TidesDBException; + int maxConcurrentFlushes, + boolean finishCompactionsOnClose) throws TidesDBException; private static native void nativeClose(long handle); @@ -436,4 +471,8 @@ private static native void nativeCreateColumnFamily(long handle, String name, private static native void nativeDeleteColumnFamily(long handle, long cfHandle) throws TidesDBException; private static native void nativePromoteToPrimary(long handle) throws TidesDBException; + + private static native void nativeCancelBackgroundWork(long handle) throws TidesDBException; + + private static native long nativeRaiseOpenFileLimit(long desired); } diff --git a/src/main/java/com/tidesdb/TidesDBIterator.java b/src/main/java/com/tidesdb/TidesDBIterator.java index b75fdf5..66900c6 100644 --- a/src/main/java/com/tidesdb/TidesDBIterator.java +++ b/src/main/java/com/tidesdb/TidesDBIterator.java @@ -72,7 +72,7 @@ public void seek(byte[] key) throws TidesDBException { } /** - * Positions the iterator at the last key <= target key. + * Positions the iterator at the last key {@code <=} target key. * * @param key the target key * @throws TidesDBException if the seek fails diff --git a/src/test/java/com/tidesdb/TidesDBTest.java b/src/test/java/com/tidesdb/TidesDBTest.java index 24378b8..77b991e 100644 --- a/src/test/java/com/tidesdb/TidesDBTest.java +++ b/src/test/java/com/tidesdb/TidesDBTest.java @@ -1734,10 +1734,12 @@ void testMaxConcurrentFlushes() throws TidesDBException { cf.flushMemtable(); } - // defaultConfig() should source maxConcurrentFlushes from the C library + // defaultConfig() should source maxConcurrentFlushes from the C library. The engine's + // default is 0, which is the "auto" sentinel meaning "pin to the resolved + // num_flush_threads" -- so the only invariant we can assert is that it is non-negative. Config defaults = Config.defaultConfig(); - assertTrue(defaults.getMaxConcurrentFlushes() > 0, - "default maxConcurrentFlushes should be non-zero (sourced from tidesdb_default_config())"); + assertTrue(defaults.getMaxConcurrentFlushes() >= 0, + "default maxConcurrentFlushes should be sourced from tidesdb_default_config()"); } @Test @@ -1767,4 +1769,190 @@ void testTransactionSingleDeleteNullArgs() throws TidesDBException { } } } + + @Test + @Order(48) + void testRaiseOpenFileLimit() { + // Reporting-only call (desired <= 0) returns the current ceiling without changing it. + long current = TidesDB.raiseOpenFileLimit(0); + assertTrue(current > 0, "current open-file ceiling should be positive"); + + // A raise attempt is non-fatal and returns the ceiling in effect afterwards (>= current). + long after = TidesDB.raiseOpenFileLimit(current); + assertTrue(after >= current, "ceiling after a raise attempt should not be lower"); + } + + @Test + @Order(49) + void testCancelBackgroundWork() throws TidesDBException { + Config config = Config.builder(tempDir.resolve("testdb_cancel_bg").toString()) + .numFlushThreads(2) + .numCompactionThreads(2) + .logLevel(LogLevel.INFO) + .blockCacheSize(64 * 1024 * 1024) + .maxOpenSSTables(256) + .build(); + + try (TidesDB db = TidesDB.open(config)) { + db.createColumnFamily("cancel_cf", ColumnFamilyConfig.defaultConfig()); + ColumnFamily cf = db.getColumnFamily("cancel_cf"); + + try (Transaction txn = db.beginTransaction()) { + txn.put(cf, "k".getBytes(StandardCharsets.UTF_8), + "v".getBytes(StandardCharsets.UTF_8)); + txn.commit(); + } + + // Sticky db-wide cancel of background compaction; flushes are unaffected. + assertDoesNotThrow(db::cancelBackgroundWork); + } + } + + @Test + @Order(50) + void testFinishCompactionsOnClose() throws TidesDBException { + Config config = Config.builder(tempDir.resolve("testdb_finish_compactions").toString()) + .numFlushThreads(2) + .numCompactionThreads(2) + .logLevel(LogLevel.INFO) + .blockCacheSize(64 * 1024 * 1024) + .maxOpenSSTables(256) + .finishCompactionsOnClose(true) + .build(); + + assertTrue(config.isFinishCompactionsOnClose()); + + try (TidesDB db = TidesDB.open(config)) { + db.createColumnFamily("finish_cf", ColumnFamilyConfig.defaultConfig()); + ColumnFamily cf = db.getColumnFamily("finish_cf"); + try (Transaction txn = db.beginTransaction()) { + txn.put(cf, "k".getBytes(StandardCharsets.UTF_8), + "v".getBytes(StandardCharsets.UTF_8)); + txn.commit(); + } + cf.flushMemtable(); + } + // close() returning without error is the observable contract for this flag. + } + + @Test + @Order(51) + void testCfConfigIniRoundTrip() throws TidesDBException { + String iniFile = tempDir.resolve("cf_config.ini").toString(); + String section = "round_trip_cf"; + + ColumnFamilyConfig original = ColumnFamilyConfig.builder() + .writeBufferSize(96 * 1024 * 1024) + .levelSizeRatio(8) + .minLevels(4) + .klogValueThreshold(1024) + .compressionAlgorithm(CompressionAlgorithm.ZSTD_COMPRESSION) + .enableBloomFilter(true) + .bloomFPR(0.02) + .enableBlockIndexes(true) + .indexSampleRatio(2) + .blockIndexPrefixLen(8) + .syncMode(SyncMode.SYNC_INTERVAL) + .syncIntervalUs(250000) + .defaultIsolationLevel(IsolationLevel.SNAPSHOT) + .l1FileCountTrigger(6) + .l0QueueStallThreshold(15) + .tombstoneDensityTrigger(0.4) + .tombstoneDensityMinEntries(2048) + .minDiskSpace(50 * 1024 * 1024) + .useBtree(true) + .objectLazyCompaction(true) + .objectPrefetchCompaction(false) + .build(); + + original.saveToIni(iniFile, section); + + ColumnFamilyConfig loaded = ColumnFamilyConfig.loadFromIni(iniFile, section); + + assertEquals(original.getWriteBufferSize(), loaded.getWriteBufferSize()); + assertEquals(original.getLevelSizeRatio(), loaded.getLevelSizeRatio()); + assertEquals(original.getMinLevels(), loaded.getMinLevels()); + assertEquals(original.getKlogValueThreshold(), loaded.getKlogValueThreshold()); + assertEquals(original.getCompressionAlgorithm(), loaded.getCompressionAlgorithm()); + assertEquals(original.isEnableBloomFilter(), loaded.isEnableBloomFilter()); + assertEquals(original.getBloomFPR(), loaded.getBloomFPR(), 1e-9); + assertEquals(original.isEnableBlockIndexes(), loaded.isEnableBlockIndexes()); + assertEquals(original.getIndexSampleRatio(), loaded.getIndexSampleRatio()); + assertEquals(original.getBlockIndexPrefixLen(), loaded.getBlockIndexPrefixLen()); + assertEquals(original.getSyncMode(), loaded.getSyncMode()); + assertEquals(original.getSyncIntervalUs(), loaded.getSyncIntervalUs()); + assertEquals(original.getDefaultIsolationLevel(), loaded.getDefaultIsolationLevel()); + assertEquals(original.getL1FileCountTrigger(), loaded.getL1FileCountTrigger()); + assertEquals(original.getL0QueueStallThreshold(), loaded.getL0QueueStallThreshold()); + assertEquals(original.getTombstoneDensityTrigger(), loaded.getTombstoneDensityTrigger(), 1e-9); + assertEquals(original.getTombstoneDensityMinEntries(), loaded.getTombstoneDensityMinEntries()); + assertEquals(original.getMinDiskSpace(), loaded.getMinDiskSpace()); + assertEquals(original.isUseBtree(), loaded.isUseBtree()); + assertEquals(original.isObjectLazyCompaction(), loaded.isObjectLazyCompaction()); + assertEquals(original.isObjectPrefetchCompaction(), loaded.isObjectPrefetchCompaction()); + } + + @Test + @Order(52) + void testCfConfigIniInvalidArgs() { + assertThrows(IllegalArgumentException.class, + () -> ColumnFamilyConfig.defaultConfig().saveToIni(null, "s")); + assertThrows(IllegalArgumentException.class, + () -> ColumnFamilyConfig.defaultConfig().saveToIni("f.ini", "")); + assertThrows(IllegalArgumentException.class, + () -> ColumnFamilyConfig.loadFromIni("", "s")); + assertThrows(IllegalArgumentException.class, + () -> ColumnFamilyConfig.loadFromIni("f.ini", null)); + // Reading a non-existent INI file surfaces as a TidesDBException, not a crash. + assertThrows(TidesDBException.class, + () -> ColumnFamilyConfig.loadFromIni( + tempDir.resolve("does_not_exist.ini").toString(), "nope")); + } + + @Test + @Order(53) + void testWriteAmplificationCounters() throws TidesDBException { + Config config = Config.builder(tempDir.resolve("testdb_write_amp").toString()) + .numFlushThreads(2) + .numCompactionThreads(2) + .logLevel(LogLevel.INFO) + .blockCacheSize(64 * 1024 * 1024) + .maxOpenSSTables(256) + .build(); + + try (TidesDB db = TidesDB.open(config)) { + db.createColumnFamily("wa_cf", ColumnFamilyConfig.defaultConfig()); + ColumnFamily cf = db.getColumnFamily("wa_cf"); + + for (int i = 0; i < 200; i++) { + try (Transaction txn = db.beginTransaction()) { + txn.put(cf, ("key" + i).getBytes(StandardCharsets.UTF_8), + ("value" + i).getBytes(StandardCharsets.UTF_8)); + txn.commit(); + } + } + cf.flushMemtable(); + cf.purge(); + + Stats stats = cf.getStats(); + // Counters are non-negative and user bytes reflect the committed payload. + assertTrue(stats.getUserBytesWritten() > 0, "user bytes should be recorded"); + assertTrue(stats.getWalBytesWritten() >= 0); + assertTrue(stats.getFlushBytesWritten() >= 0); + assertTrue(stats.getCompactionBytesWritten() >= 0); + assertTrue(stats.getCompactionBytesRead() >= 0); + assertTrue(stats.getFlushCount() >= 0); + assertTrue(stats.getCompactionCount() >= 0); + + DbStats dbStats = db.getDbStats(); + assertTrue(dbStats.getUserBytesWritten() > 0, "db-wide user bytes should be recorded"); + assertTrue(dbStats.getUwalBytesWritten() >= 0); + assertTrue(dbStats.getWalBytesWritten() >= 0); + assertTrue(dbStats.getFlushBytesWritten() >= 0); + assertTrue(dbStats.getCompactionBytesWritten() >= 0); + assertTrue(dbStats.getCompactionBytesRead() >= 0); + assertTrue(dbStats.getFlushCount() >= 0); + assertTrue(dbStats.getCompactionCount() >= 0); + } + } }