gitweb.ps.run Git - ziglmdb/blob - src/main.zig

   1 const std = @import("std");
   2 const lmdb = @cImport(@cInclude("lmdb.h"));
   3
   4 const print = std.debug.print;
   5
   6 fn get(txn: ?*lmdb.MDB_txn, dbi: lmdb.MDB_dbi, k: anytype, comptime T: type) ?T {
   7     var key = lmdb.MDB_val{
   8         .mv_size = @sizeOf(@TypeOf(k)),
   9         .mv_data = @constCast(@ptrCast(&k)),
  10     };
  11     var val: lmdb.MDB_val = undefined;
  12     return switch (lmdb.mdb_get(txn, dbi, &key, &val)) {
  13         0 => @as(*T, @ptrFromInt(@intFromPtr(val.mv_data))).*,
  14         else => |err| {
  15             _ = err;
  16             // print("get err: {}\n", .{err});
  17             return null;
  18         },
  19     };
  20 }
  21
  22 fn put(txn: ?*lmdb.MDB_txn, dbi: lmdb.MDB_dbi, k: anytype, v: anytype) void {
  23     var key = lmdb.MDB_val{
  24         .mv_size = @sizeOf(@TypeOf(k)),
  25         .mv_data = @constCast(@ptrCast(&k)),
  26     };
  27     var val = lmdb.MDB_val{
  28         .mv_size = @sizeOf(@TypeOf(v)),
  29         .mv_data = @constCast(@ptrCast(&v)),
  30     };
  31     switch (lmdb.mdb_put(txn, dbi, &key, &val, 0)) {
  32         0 => {},
  33         else => |err| {
  34             print("put err: {}\n", .{err});
  35         },
  36     }
  37 }
  38
  39 pub fn main() void {
  40     var env: ?*lmdb.MDB_env = undefined;
  41     _ = lmdb.mdb_env_create(&env);
  42     _ = lmdb.mdb_env_set_maxdbs(env, 10);
  43     _ = lmdb.mdb_env_set_mapsize(env, 1024 * 1024 * 120);
  44     _ = lmdb.mdb_env_open(env, "./db1", lmdb.MDB_NOSYNC | lmdb.MDB_WRITEMAP, 0o664);
  45     defer lmdb.mdb_env_close(env);
  46
  47     for (0..1000000) |i| {
  48         var txn: ?*lmdb.MDB_txn = undefined;
  49         switch (lmdb.mdb_txn_begin(env, null, 0, &txn)) {
  50             0 => {},
  51             else => |err| {
  52                 print("txn err: {}\n", .{err});
  53             },
  54         }
  55
  56         var db: lmdb.MDB_dbi = undefined;
  57         _ = lmdb.mdb_dbi_open(txn, "subdb2", lmdb.MDB_CREATE | lmdb.MDB_INTEGERKEY, &db);
  58         if (i == 0) {
  59             var db_stat: lmdb.MDB_stat = undefined;
  60             _ = lmdb.mdb_stat(txn, db, &db_stat);
  61             // print("{}\n", .{db_stat});
  62         }
  63         defer lmdb.mdb_dbi_close(env, db);
  64
  65         const Val = struct {
  66             a: u64,
  67             b: i64,
  68             c: [16]u8,
  69         };
  70
  71         var new_val = Val{
  72             .a = 123,
  73             .b = -123,
  74             .c = undefined,
  75         };
  76         std.mem.copyForwards(u8, &new_val.c, "a c efghabcdefgh");
  77
  78         const key: u64 = i + 1000;
  79         if (get(txn, db, key, Val)) |val| {
  80             if (i % 100000 == 0) {
  81                 print("{}: {}\n", .{ i, val });
  82             }
  83             new_val = val;
  84             new_val.a += 1;
  85             new_val.b -= 1;
  86             std.mem.copyForwards(u8, &new_val.c, "a c efghabcdefgh");
  87         } else {
  88             if (i % 100000 == 0) {
  89                 print("not found\n", .{});
  90             }
  91         }
  92
  93         put(txn, db, key, new_val);
  94
  95         switch (lmdb.mdb_txn_commit(txn)) {
  96             0 => {},
  97             lmdb.MDB_MAP_FULL => {
  98                 print("resize\n", .{});
  99                 _ = lmdb.mdb_env_set_mapsize(env, 0);
 100             },
 101             else => |err| {
 102                 print("commit err: {}\n", .{err});
 103             },
 104         }
 105     }
 106
 107     switch (lmdb.mdb_env_sync(env, 1)) {
 108         0 => {},
 109         else => |err| {
 110             print("sync err: {}\n", .{err});
 111         },
 112     }
 113
 114     // var env_info: lmdb.MDB_envinfo = undefined;
 115     // _ = lmdb.mdb_env_info(env, &env_info);
 116
 117     // var env_stat: lmdb.MDB_stat = undefined;
 118     // _ = lmdb.mdb_env_stat(env, &env_stat);
 119
 120     // print("{}\n", .{env_info});
 121     // print("{}\n", .{env_stat});
 122
 123     print("done!\n", .{});
 124 }
 125
 126 test "hash" {
 127     const pw = "affeaffe";
 128
 129     var hash_buffer: [128]u8 = undefined;
 130
 131     var buffer: [1024 * 1024]u8 = undefined;
 132     var alloc = std.heap.FixedBufferAllocator.init(&buffer);
 133
 134     const result = try std.crypto.pwhash.argon2.strHash(pw, .{
 135         .allocator = alloc.allocator(),
 136         .params = std.crypto.pwhash.argon2.Params.fromLimits(1000, 1024 * 10),
 137     }, &hash_buffer);
 138
 139     print("{s}\n", .{result});
 140
 141     if (std.crypto.pwhash.argon2.strVerify(result, "affeaffe", .{
 142         .allocator = alloc.allocator(),
 143     })) {
 144         print("verified\n", .{});
 145     } else |err| {
 146         print("not verified: {}\n", .{err});
 147     }
 148 }