Merge pull request #25 from tidesdb/0.6.0

iss #23 #24 retire unused objecttargetfilesize cf config field and ad…

Author: guycipher

README.md

@@ -31,8 +31,3 @@ Multiple licenses apply:
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.
-
-## Support
-
-- [Discord](https://discord.gg/tWEmjR66cy)
-- [GitHub Issues](https://github.com/tidesdb/tidesdb-ts/issues)

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "tidesdb",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "description": "TypeScript bindings for TidesDB - A high-performance embedded key-value storage engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package.json

@@ -174,7 +174,6 @@ export class ColumnFamily {
           l1FileCountTrigger: cfgDecoded.l1_file_count_trigger as number,
           l0QueueStallThreshold: cfgDecoded.l0_queue_stall_threshold as number,
           useBtree: (cfgDecoded.use_btree as number) !== 0,
-          objectTargetFileSize: cfgDecoded.object_target_file_size as number,
           objectLazyCompaction: (cfgDecoded.object_lazy_compaction as number) !== 0,
           objectPrefetchCompaction: (cfgDecoded.object_prefetch_compaction as number) !== 0,
         };
@@ -295,7 +294,7 @@ export class ColumnFamily {
       use_btree: config.useBtree ? 1 : 0,
       commit_hook_fn: null,
       commit_hook_ctx: null,
-      object_target_file_size: config.objectTargetFileSize ?? 0,
+      object_target_file_size: 0,
       object_lazy_compaction: config.objectLazyCompaction ? 1 : 0,
       object_prefetch_compaction: config.objectPrefetchCompaction === false ? 0 : 1,
     };

src/column-family.ts

@@ -264,6 +264,9 @@ export const tidesdb_txn_get = lib.func(
 export const tidesdb_txn_delete = lib.func(
   "int tidesdb_txn_delete(tidesdb_txn_t *txn, tidesdb_column_family_t *cf, const uint8_t *key, size_t key_size)",
 );
+export const tidesdb_txn_single_delete = lib.func(
+  "int tidesdb_txn_single_delete(tidesdb_txn_t *txn, tidesdb_column_family_t *cf, const uint8_t *key, size_t key_size)",
+);
 export const tidesdb_txn_commit = lib.func(
   "int tidesdb_txn_commit(tidesdb_txn_t *txn)",
 );

src/ffi.ts

@@ -124,6 +124,60 @@ describe("TidesDB", () => {
       readTxn.free();
     });
 
+    test("singleDelete makes prior put unreadable", () => {
+      db.createColumnFamily("sd_cf");
+      const cf = db.getColumnFamily("sd_cf");
+
+      const txn = db.beginTransaction();
+      txn.put(cf, Buffer.from("sd_key"), Buffer.from("sd_value"), -1);
+      txn.commit();
+      txn.free();
+
+      const sdTxn = db.beginTransaction();
+      sdTxn.singleDelete(cf, Buffer.from("sd_key"));
+      sdTxn.commit();
+      sdTxn.free();
+
+      const readTxn = db.beginTransaction();
+      expect(() => readTxn.get(cf, Buffer.from("sd_key"))).toThrow();
+      readTxn.free();
+    });
+
+    test("singleDelete on non-existent key is allowed", () => {
+      db.createColumnFamily("sd_missing_cf");
+      const cf = db.getColumnFamily("sd_missing_cf");
+
+      const txn = db.beginTransaction();
+      expect(() => txn.singleDelete(cf, Buffer.from("missing"))).not.toThrow();
+      txn.commit();
+      txn.free();
+    });
+
+    test("singleDelete works alongside puts in the same transaction", () => {
+      db.createColumnFamily("sd_mixed_cf");
+      const cf = db.getColumnFamily("sd_mixed_cf");
+
+      // Seed two keys
+      const seed = db.beginTransaction();
+      seed.put(cf, Buffer.from("keep"), Buffer.from("keep_v"), -1);
+      seed.put(cf, Buffer.from("drop"), Buffer.from("drop_v"), -1);
+      seed.commit();
+      seed.free();
+
+      // Mixed batch: insert a new key and single-delete an existing one
+      const mix = db.beginTransaction();
+      mix.put(cf, Buffer.from("fresh"), Buffer.from("fresh_v"), -1);
+      mix.singleDelete(cf, Buffer.from("drop"));
+      mix.commit();
+      mix.free();
+
+      const readTxn = db.beginTransaction();
+      expect(readTxn.get(cf, Buffer.from("keep")).toString()).toBe("keep_v");
+      expect(readTxn.get(cf, Buffer.from("fresh")).toString()).toBe("fresh_v");
+      expect(() => readTxn.get(cf, Buffer.from("drop"))).toThrow();
+      readTxn.free();
+    });
+
     test("rollback", () => {
       db.createColumnFamily("test_cf");
       const cf = db.getColumnFamily("test_cf");

src/tidesdb.test.ts

@@ -107,7 +107,6 @@ export function defaultColumnFamilyConfig(): ColumnFamilyConfig {
     l1FileCountTrigger: cConfig.l1_file_count_trigger as number,
     l0QueueStallThreshold: cConfig.l0_queue_stall_threshold as number,
     useBtree: cConfig.use_btree !== 0,
-    objectTargetFileSize: cConfig.object_target_file_size as number,
     objectLazyCompaction: cConfig.object_lazy_compaction !== 0,
     objectPrefetchCompaction: cConfig.object_prefetch_compaction !== 0,
   };
@@ -281,7 +280,7 @@ export class TidesDB {
       use_btree: mergedConfig.useBtree ? 1 : 0,
       commit_hook_fn: null,
       commit_hook_ctx: null,
-      object_target_file_size: mergedConfig.objectTargetFileSize ?? 0,
+      object_target_file_size: 0,
       object_lazy_compaction: mergedConfig.objectLazyCompaction ? 1 : 0,
       object_prefetch_compaction: mergedConfig.objectPrefetchCompaction === false ? 0 : 1,
     };

src/tidesdb.ts

@@ -20,6 +20,7 @@ import {
   tidesdb_txn_put,
   tidesdb_txn_get,
   tidesdb_txn_delete,
+  tidesdb_txn_single_delete,
   tidesdb_txn_commit,
   tidesdb_txn_rollback,
   tidesdb_txn_reset,
@@ -110,6 +111,30 @@ export class Transaction {
     checkResult(result, 'failed to delete key');
   }
 
+  /**
+   * Single-delete a key from the column family.
+   *
+   * Writes a tombstone with the same read semantics as delete(), but lets compaction
+   * drop the put and the tombstone together as soon as both appear in the same merge
+   * input. The caller promises the key has been put at most once between any two
+   * single-deletes (and between the start of the key's history and its first
+   * single-delete). The engine does not verify this; violating the contract can
+   * leave older puts visible after the single-delete.
+   *
+   * Use only for keys that are inserted exactly once and then deleted exactly once
+   * (e.g. classic insert-benchmark patterns, secondary-index entries on never-updated
+   * columns, log-style tables with scheduled purges). When in doubt, prefer delete().
+   *
+   * @param cf Column family to delete from.
+   * @param key Key as Buffer.
+   */
+  singleDelete(cf: ColumnFamily, key: Buffer): void {
+    if (!this._txn) throw new Error('Transaction has been freed');
+
+    const result = tidesdb_txn_single_delete(this._txn, cf.ptr, key, key.length);
+    checkResult(result, 'failed to single-delete key');
+  }
+
   /**
    * Commit the transaction.
    */

src/transaction.ts

@@ -202,8 +202,6 @@ export interface ColumnFamilyConfig {
   l0QueueStallThreshold?: number;
   /** Use B+tree format for klog (default: false = block-based). */
   useBtree?: boolean;
-  /** Target SSTable size in object store mode (default 256MB, 0=auto). */
-  objectTargetFileSize?: number;
   /** Compact less aggressively in object store mode (default: false). */
   objectLazyCompaction?: boolean;
   /** Download all inputs before merge in object store mode (default: true). */