wip? this is old, don't remember what it was

Author: dnut

build.zig

@@ -12,14 +12,14 @@ pub fn build(b: *Build) void {
     const bindings_mod = b.addModule("bindings", .{
         .target = target,
         .optimize = optimize,
-        .root_source_file = b.path("src/lib.zig"),
+        .root_source_file = b.path("src/root.zig"),
     });
     bindings_mod.addImport("rocksdb", rocksdb_mod);
 
     const tests = b.addTest(.{
         .target = target,
         .optimize = optimize,
-        .root_source_file = b.path("src/lib.zig"),
+        .root_source_file = b.path("src/root.zig"),
     });
     const test_step = b.step("test", "Run bindings tests");
     tests.root_module.addImport("rocksdb", rocksdb_mod);

src/batch.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 const rdb = @import("rocksdb");
-const lib = @import("lib.zig");
+const lib = @import("root.zig");
 
 const Allocator = std.mem.Allocator;
 

src/database.zig

@@ -1,10 +1,12 @@
 const std = @import("std");
 const rdb = @import("rocksdb");
-const lib = @import("lib.zig");
+const lib = @import("root.zig");
+const private = @import("private.zig");
 
 const Allocator = std.mem.Allocator;
 const RwLock = std.Thread.RwLock;
 
+const CallHandler = private.errors.CallHandler;
 const Data = lib.Data;
 const ErrorHandler = lib.ErrorHandler;
 const Iterator = lib.Iterator;
@@ -429,30 +431,6 @@ pub const LiveFile = struct {
     }
 };
 
-const CallHandler = struct {
-    /// The error string to pass into rocksdb.
-    err_str_in: ?[*:0]u8 = null,
-    /// The user's error string.
-    handler: ErrorHandler,
-
-    fn init(handler: ErrorHandler) CallHandler {
-        return .{ .handler = handler };
-    }
-
-    fn handle(
-        self: *CallHandler,
-        ret: anytype,
-        comptime err: anytype,
-    ) @TypeOf(err)!@TypeOf(ret) {
-        if (self.err_str_in) |s| {
-            self.handler.handle(err, s);
-            return err;
-        } else {
-            return ret;
-        }
-    }
-};
-
 const CfNameToHandleMap = struct {
     allocator: Allocator,
     map: std.StringHashMapUnmanaged(ColumnFamilyHandle),

src/errors.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 const rdb = @import("rocksdb");
-const lib = @import("lib.zig");
+const lib = @import("root.zig");
 
 const Data = lib.Data;
 
@@ -43,3 +43,27 @@ pub const ErrorHandler = union(enum) {
         }
     }
 };
+
+pub const CallHandler = struct {
+    /// The error string to pass into rocksdb.
+    err_str_in: ?[*:0]u8 = null,
+    /// The user's error string.
+    handler: ErrorHandler,
+
+    pub fn init(handler: ErrorHandler) CallHandler {
+        return .{ .handler = handler };
+    }
+
+    pub fn handle(
+        self: *CallHandler,
+        ret: anytype,
+        comptime err: anytype,
+    ) @TypeOf(err)!@TypeOf(ret) {
+        if (self.err_str_in) |s| {
+            self.handler.handle(err, s);
+            return err;
+        } else {
+            return ret;
+        }
+    }
+};

src/iterator.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 const rdb = @import("rocksdb");
-const lib = @import("lib.zig");
+const lib = @import("root.zig");
 
 const Allocator = std.mem.Allocator;
 

src/private.zig

@@ -0,0 +1,17 @@
+//! This exposes all of the files within the library to be accessible within the
+//! library itself. This file should *not* be exposed publicly.
+
+pub const batch = @import("batch.zig");
+pub const errors = @import("errors.zig");
+pub const data = @import("data.zig");
+pub const database = @import("database.zig");
+pub const iterator = @import("iterator.zig");
+pub const transaction = @import("transaction.zig");
+
+/// The public facing API of the library.
+pub const root = @import("root.zig");
+
+test {
+    const std = @import("std");
+    std.testing.refAllDecls(@This());
+}

src/lib.zig src/root.zigsrc/lib.zig renamed to src/root.zig

@@ -18,13 +18,11 @@ pub const ErrorHandler = errors.ErrorHandler;
 
 ////////////
 // private
-pub const batch = @import("batch.zig");
-const errors = @import("errors.zig");
-pub const data = @import("data.zig");
-pub const database = @import("database.zig");
-pub const iterator = @import("iterator.zig");
+const private = @import("private.zig");
 
-test {
-    const std = @import("std");
-    std.testing.refAllDecls(@This());
-}
+const batch = private.batch;
+const errors = private.errors;
+const data = private.data;
+const database = private.database;
+const iterator = private.iterator;
+const transaction = private.transaction;

src/transaction.zig

@@ -0,0 +1,72 @@
+const std = @import("std");
+const rdb = @import("rocksdb");
+const lib = @import("private.zig");
+
+const Allocator = std.mem.Allocator;
+
+const CallHandler = lib.errors.CallHandler;
+const ColumnFamilyHandle = lib.root.ColumnFamilyHandle;
+const Data = lib.root.Data;
+const ErrorHandler = lib.root.ErrorHandler;
+
+pub const Transaction = struct {
+    inner: *rdb.rocksdb_transaction_t,
+
+    const Self = @This();
+
+    pub fn deinit(self: Transaction) void {
+        rdb.rocksdb_transaction_destroy(self.inner);
+    }
+
+    pub fn commit(
+        self: Transaction,
+        error_handler: ErrorHandler,
+    ) error{RocksDBTransactionCommit}!void {
+        var ch = CallHandler.init(error_handler);
+        try ch.handle(rdb.rocksdb_transaction_commit(self.inner), error.RocksDBTransactionCommit);
+    }
+
+    pub fn put(
+        self: *const Self,
+        column_family: ColumnFamilyHandle,
+        key: []const u8,
+        value: []const u8,
+        error_handler: ErrorHandler,
+    ) error{RocksDBTransactionPut}!void {
+        var ch = CallHandler.init(error_handler);
+        try ch.handle(rdb.rocksdb_transaction_put_cf(
+            self.inner,
+            column_family,
+            key.ptr,
+            key.len,
+            value.ptr,
+            value.len,
+            @ptrCast(&ch.err_str_in),
+        ), error.RocksDBTransactionPut);
+    }
+
+    pub fn get(
+        self: *const Self,
+        column_family: ColumnFamilyHandle,
+        key: []const u8,
+        error_handler: ErrorHandler,
+    ) error{RocksDBTransactionGet}!Data {
+        var valueLength: usize = 0;
+        var ch = CallHandler.init(error_handler);
+        const value = try ch.handle(rdb.rocksdb_transaction_get_cf(
+            self.inner,
+            column_family,
+            key.ptr,
+            key.len,
+            &valueLength,
+            @ptrCast(&ch.err_str_in),
+        ), error.RocksDBTransactionGet);
+        if (value == 0) {
+            return null;
+        }
+        return .{
+            .free = rdb.rocksdb_free,
+            .data = value[0..valueLength],
+        };
+    }
+};