fediglam/src/sql/lib.zig

const std = @import("std");
const c = @cImport({
    @cInclude("sqlite3.h");
});

const Uuid = @import("util").Uuid;

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.debug.print("sql error {}\n", .{err});
            std.debug.print("{s}\n", .{c.sqlite3_errmsg(self.db)});
            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 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)) {
            .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)) {
            .SQLITE_OK => {},
            else => error.UnknownError,
        };
    }

    pub fn bind(self: *PreparedStmt, idx: u15, val: anytype) !void {
        return switch (@TypeOf(val)) {
            []const u8 => self.bindText(idx, val),
            i64 => self.bindI64(idx, val),
            Uuid => self.bindUuid(idx, val),
            @Type(.Null) => self.bindNull(idx),
            else => @compileError("Unknown Type"),
        };
    }

    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.debug.print("sql error {}\n", .{err});
                std.debug.print("{s}\n", .{c.sqlite3_errmsg(self.db)});
                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);
    }
};