const std = @import("std"); const util = @import("util"); const c = @cImport({ @cInclude("sqlite3.h"); }); const Uuid = util.Uuid; const DateTime = util.DateTime; pub const Sqlite = struct { db: *c.sqlite3, pub fn open(path: [:0]const u8) !Sqlite { var db: ?*c.sqlite3 = undefined; const err = c.sqlite3_open_v2(path, &db, c.SQLITE_OPEN_READWRITE | c.SQLITE_OPEN_CREATE, null); if (err != c.SQLITE_OK) return error.UnknownError; return Sqlite{ .db = db.?, }; } pub fn close(self: *Sqlite) void { _ = c.sqlite3_close_v2(self.db); } pub fn prepare(self: *Sqlite, sql: []const u8) !PreparedStmt { var stmt: ?*c.sqlite3_stmt = undefined; const err = c.sqlite3_prepare_v2(self.db, sql.ptr, @intCast(c_int, sql.len), &stmt, null); if (err != c.SQLITE_OK) { std.log.debug("sql error {}: {s}", .{ err, c.sqlite3_errmsg(self.db) }); std.log.debug("Failed on SQL:\n==========\n{s}\n==========", .{sql}); return error.UnknownError; } return PreparedStmt{ .stmt = stmt.?, .db = self.db }; } }; pub const Row = struct { stmt: *c.sqlite3_stmt, db: *c.sqlite3, pub fn getI64(self: Row, idx: u15) !i64 { return @intCast(i64, c.sqlite3_column_int64(self.stmt, idx)); } pub fn getText(self: Row, idx: u15, buf: []u8) ![]u8 { const ptr = c.sqlite3_column_text(self.stmt, idx); const size = @intCast(usize, c.sqlite3_column_bytes(self.stmt, idx)); if (size > buf.len) return error.StreamTooLong; for (ptr[0..size]) |ch, i| buf[i] = ch; return buf[0..size]; } pub fn getTextAlloc(self: Row, idx: u15, alloc: std.mem.Allocator) ![]u8 { const size = c.sqlite3_column_bytes(self.stmt, idx); var buf = try alloc.alloc(u8, @intCast(usize, size)); errdefer alloc.free(buf); return self.getText(idx, buf); } pub fn getUuid(self: Row, idx: u15) !Uuid { var buf: [Uuid.string_len + 1]u8 = undefined; _ = try self.getText(idx, &buf); return try Uuid.parse(buf[0..Uuid.string_len]); } pub fn getDateTime(self: Row, idx: u15) !DateTime { return DateTime{ .seconds_since_epoch = try self.getI64(idx) }; } pub fn getAlloc(self: Row, comptime T: type, idx: u15, alloc: std.mem.Allocator) !T { // TODO: handle optionals return switch (T) { []u8, []const u8 => self.getTextAlloc(idx, alloc), i64 => self.getI64(idx), Uuid => self.getUuid(idx), DateTime => self.getDateTime(idx), else => { switch (@typeInfo(T)) { .Optional => switch (c.sqlite3_column_type(self.stmt, idx)) { c.SQLITE_NULL => return null, else => return try self.getAlloc(std.meta.Child(T), idx, alloc), }, else => @compileError("unknown type " ++ @typeName(T)), } }, }; } }; pub const PreparedStmt = struct { stmt: *c.sqlite3_stmt, db: *c.sqlite3, pub fn bindNull(self: *PreparedStmt, idx: u15) !void { return switch (c.sqlite3_bind_null(self.stmt, idx)) { c.SQLITE_OK => {}, else => error.UnknownError, }; } pub fn bindUuid(self: *PreparedStmt, idx: u15, id: Uuid) !void { const str = id.toCharArray(); return self.bindText(idx, &str); } pub fn bindText(self: *PreparedStmt, idx: u15, str: []const u8) !void { return switch (c.sqlite3_bind_text(self.stmt, idx, str.ptr, @intCast(c_int, str.len), c.SQLITE_TRANSIENT)) { c.SQLITE_OK => {}, else => error.UnknownError, }; } pub fn bindI64(self: *PreparedStmt, idx: u15, val: i64) !void { return switch (c.sqlite3_bind_int64(self.stmt, idx, val)) { c.SQLITE_OK => {}, else => error.UnknownError, }; } pub fn bindDateTime(self: *PreparedStmt, idx: u15, val: DateTime) !void { return self.bindI64(idx, val.seconds_since_epoch); } pub fn bind(self: *PreparedStmt, idx: u15, val: anytype) !void { return switch (@TypeOf(val)) { []u8, []const u8 => self.bindText(idx, val), i64 => self.bindI64(idx, val), Uuid => self.bindUuid(idx, val), DateTime => self.bindDateTime(idx, val), @TypeOf(null) => self.bindNull(idx), else => |T| switch (@typeInfo(T)) { .Optional => if (val) |v| self.bind(idx, v) else self.bindNull(idx), else => @compileError("Unknown Type" ++ @typeName(T)), }, }; } pub fn step(self: *PreparedStmt) !?Row { return switch (c.sqlite3_step(self.stmt)) { c.SQLITE_ROW => Row{ .stmt = self.stmt, .db = self.db }, c.SQLITE_DONE => null, else => |err| blk: { std.log.debug("sql error {}: {s}", .{ err, c.sqlite3_errmsg(self.db) }); std.log.debug("Failed on SQL:\n==========\n{s}\n==========", .{self.getGeneratingSql()}); break :blk error.UnknownError; }, }; } pub fn finalize(self: *PreparedStmt) void { _ = c.sqlite3_finalize(self.stmt); } pub fn reset(self: *PreparedStmt) void { _ = c.sqlite3_reset(self.stmt); } fn getGeneratingSql(self: *PreparedStmt) ?[*:0]const u8 { return c.sqlite3_sql(self.stmt); } };