fediglam/src/sql/lib.zig

248 lines
8.1 KiB
Zig
Raw Normal View History

2022-07-15 00:58:08 +00:00
const std = @import("std");
2022-07-18 07:37:10 +00:00
const util = @import("util");
2022-07-15 00:58:08 +00:00
const c = @cImport({
@cInclude("sqlite3.h");
});
2022-07-18 07:37:10 +00:00
const Uuid = util.Uuid;
const DateTime = util.DateTime;
2022-07-16 19:00:33 +00:00
2022-09-08 01:55:55 +00:00
const UnexpectedError = error{Unexpected};
pub const OpenError = error{
DbCorrupt,
BadPathName,
IsDir,
InputOutput,
NoSpaceLeft,
} || UnexpectedError;
pub const PrepareError = UnexpectedError;
pub const RowGetError = error{ InvalidData, StreamTooLong, OutOfMemory } || UnexpectedError;
pub const BindError = UnexpectedError;
fn getCharPos(text: []const u8, offset: c_int) struct { row: usize, col: usize } {
var row: usize = 0;
var col: usize = 0;
var i: usize = 0;
if (offset > text.len) return .{ .row = 0, .col = 0 };
while (i != offset) : (i += 1) {
if (text[i] == '\n') {
row += 1;
col = 0;
} else {
col += 1;
}
}
return .{ .row = row, .col = col };
}
fn handleUnexpectedError(db: *c.sqlite3, code: c_int, sql_text: ?[]const u8) UnexpectedError {
std.log.err("Unexpected error in SQLite engine: {s} ({})", .{ c.sqlite3_errstr(code), code });
std.log.debug("Additional details:", .{});
std.log.debug("{?s}", .{c.sqlite3_errmsg(db)});
if (sql_text) |sql| {
const byte_offset = c.sqlite3_error_offset(db);
if (byte_offset >= 0) {
const pos = getCharPos(sql, byte_offset);
std.log.debug("Failed at char ({}:{}) of SQL:\n{s}", .{ pos.row, pos.col, sql });
}
}
std.log.debug("{?s}", .{@errorReturnTrace()});
return error.Unexpected;
}
2022-07-15 00:58:08 +00:00
pub const Sqlite = struct {
db: *c.sqlite3,
2022-09-08 01:55:55 +00:00
pub fn open(path: [:0]const u8) OpenError!Sqlite {
const flags = c.SQLITE_OPEN_READWRITE | c.SQLITE_OPEN_CREATE | c.SQLITE_OPEN_EXRESCODE;
2022-07-15 00:58:08 +00:00
var db: ?*c.sqlite3 = undefined;
2022-09-08 01:55:55 +00:00
switch (c.sqlite3_open_v2(@ptrCast([*c]const u8, path), &db, flags, null)) {
c.SQLITE_OK => {},
c.SQLITE_NOTADB, c.SQLITE_CORRUPT => return error.DbCorrupt,
c.SQLITE_IOERR_WRITE, c.SQLITE_IOERR_READ => return error.InputOutput,
c.SQLITE_CANTOPEN_ISDIR => return error.IsDir,
c.SQLITE_CANTOPEN_FULLPATH => return error.BadPathName,
c.SQLITE_FULL => return error.NoSpaceLeft,
else => |err| {
std.log.err(
\\Unable to open SQLite DB "{s}"
\\Error: {s} ({})
, .{ path, c.sqlite3_errstr(err), err });
return error.Unexpected;
},
}
2022-07-15 00:58:08 +00:00
return Sqlite{
.db = db.?,
};
}
2022-09-08 01:55:55 +00:00
pub fn close(self: Sqlite) void {
switch (c.sqlite3_close(self.db)) {
c.SQLITE_OK => {},
c.SQLITE_BUSY => {
std.log.err("SQLite DB could not be closed as it is busy.\n{s}", .{c.sqlite3_errmsg(self.db)});
},
else => |err| {
std.log.err("Could not close SQLite DB", .{});
handleUnexpectedError(self.db, err, null) catch {};
},
}
2022-07-15 00:58:08 +00:00
}
2022-09-08 01:55:55 +00:00
pub fn prepare(self: *Sqlite, sql: []const u8) PrepareError!PreparedStmt {
2022-07-15 07:27:27 +00:00
var stmt: ?*c.sqlite3_stmt = undefined;
const err = c.sqlite3_prepare_v2(self.db, sql.ptr, @intCast(c_int, sql.len), &stmt, null);
2022-09-08 01:55:55 +00:00
if (err != c.SQLITE_OK) return handleUnexpectedError(self.db, err, sql);
2022-07-15 00:58:08 +00:00
2022-07-15 07:27:27 +00:00
return PreparedStmt{ .stmt = stmt.?, .db = self.db };
2022-07-15 00:58:08 +00:00
}
};
pub const Row = struct {
stmt: *c.sqlite3_stmt,
2022-07-15 07:27:27 +00:00
db: *c.sqlite3,
2022-07-15 00:58:08 +00:00
2022-09-08 01:55:55 +00:00
pub fn isNull(self: Row, idx: u15) RowGetError!bool {
2022-07-24 04:29:38 +00:00
return c.sqlite3_column_type(self.stmt, idx) == c.SQLITE_NULL;
}
2022-09-08 01:55:55 +00:00
pub fn getI64(self: Row, idx: u15) RowGetError!i64 {
2022-07-15 00:58:08 +00:00
return @intCast(i64, c.sqlite3_column_int64(self.stmt, idx));
}
2022-09-08 01:55:55 +00:00
pub fn getText(self: Row, idx: u15, buf: []u8) RowGetError![]u8 {
2022-07-15 00:58:08 +00:00
const ptr = c.sqlite3_column_text(self.stmt, idx);
2022-07-15 07:27:27 +00:00
const size = @intCast(usize, c.sqlite3_column_bytes(self.stmt, idx));
2022-07-15 00:58:08 +00:00
if (size > buf.len) return error.StreamTooLong;
for (ptr[0..size]) |ch, i| buf[i] = ch;
return buf[0..size];
}
2022-09-08 01:55:55 +00:00
pub fn getTextAlloc(self: Row, idx: u15, alloc: std.mem.Allocator) RowGetError![]u8 {
2022-07-15 00:58:08 +00:00
const size = c.sqlite3_column_bytes(self.stmt, idx);
2022-07-15 07:27:27 +00:00
var buf = try alloc.alloc(u8, @intCast(usize, size));
2022-07-15 00:58:08 +00:00
errdefer alloc.free(buf);
return self.getText(idx, buf);
}
2022-07-17 23:21:03 +00:00
2022-09-08 01:55:55 +00:00
pub fn getBlob(self: Row, idx: u15, buf: []u8) RowGetError![]u8 {
2022-09-07 23:14:52 +00:00
const ptr = @ptrCast([*]const u8, c.sqlite3_column_blob(self.stmt, idx));
2022-07-24 04:14:46 +00:00
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];
}
2022-09-08 01:55:55 +00:00
pub fn getBlobAlloc(self: Row, idx: u15, alloc: std.mem.Allocator) RowGetError![]u8 {
2022-07-24 04:14:46 +00:00
const size = c.sqlite3_column_bytes(self.stmt, idx);
var buf = try alloc.alloc(u8, @intCast(usize, size));
errdefer alloc.free(buf);
return self.getBlob(idx, buf);
}
2022-09-08 01:55:55 +00:00
pub fn getUuid(self: Row, idx: u15) RowGetError!Uuid {
2022-07-17 23:21:03 +00:00
var buf: [Uuid.string_len + 1]u8 = undefined;
_ = try self.getText(idx, &buf);
2022-09-08 01:55:55 +00:00
return Uuid.parse(buf[0..Uuid.string_len]) catch return error.InvalidData;
2022-07-17 23:21:03 +00:00
}
2022-07-18 07:37:10 +00:00
2022-09-08 01:55:55 +00:00
pub fn getDateTime(self: Row, idx: u15) RowGetError!DateTime {
2022-07-18 07:37:10 +00:00
return DateTime{ .seconds_since_epoch = try self.getI64(idx) };
}
2022-07-15 00:58:08 +00:00
};
pub const PreparedStmt = struct {
stmt: *c.sqlite3_stmt,
2022-07-15 07:27:27 +00:00
db: *c.sqlite3,
2022-07-15 00:58:08 +00:00
2022-09-08 01:55:55 +00:00
pub fn bindNull(self: PreparedStmt, idx: u15) BindError!void {
2022-07-15 00:58:08 +00:00
return switch (c.sqlite3_bind_null(self.stmt, idx)) {
2022-07-22 04:18:43 +00:00
c.SQLITE_OK => {},
2022-09-08 01:55:55 +00:00
else => |err| handleUnexpectedError(self.db, err, null),
2022-07-15 00:58:08 +00:00
};
}
2022-09-08 01:55:55 +00:00
pub fn bindUuid(self: PreparedStmt, idx: u15, id: Uuid) BindError!void {
2022-07-16 19:00:33 +00:00
const str = id.toCharArray();
return self.bindText(idx, &str);
}
2022-09-08 01:55:55 +00:00
pub fn bindText(self: PreparedStmt, idx: u15, str: []const u8) BindError!void {
2022-07-27 05:02:09 +00:00
// Work around potential null pointer in empty string
const eff_str = if (str.len == 0) (" ")[0..0] else str;
return switch (c.sqlite3_bind_text(self.stmt, idx, eff_str.ptr, @intCast(c_int, eff_str.len), c.SQLITE_TRANSIENT)) {
2022-07-15 07:27:27 +00:00
c.SQLITE_OK => {},
2022-09-08 01:55:55 +00:00
else => |err| handleUnexpectedError(self.db, err, null),
2022-07-15 00:58:08 +00:00
};
}
2022-09-08 01:55:55 +00:00
pub fn bindBlob(self: PreparedStmt, idx: u15, blob: []const u8) BindError!void {
2022-07-24 04:14:46 +00:00
return switch (c.sqlite3_bind_blob64(self.stmt, idx, blob.ptr, blob.len, c.SQLITE_TRANSIENT)) {
c.SQLITE_OK => {},
2022-09-08 01:55:55 +00:00
else => |err| handleUnexpectedError(self.db, err, null),
2022-07-24 04:14:46 +00:00
};
}
2022-09-08 01:55:55 +00:00
pub fn bindI64(self: PreparedStmt, idx: u15, val: i64) BindError!void {
2022-07-15 00:58:08 +00:00
return switch (c.sqlite3_bind_int64(self.stmt, idx, val)) {
2022-07-18 07:37:10 +00:00
c.SQLITE_OK => {},
2022-09-08 01:55:55 +00:00
else => |err| handleUnexpectedError(self.db, err, null),
2022-07-15 00:58:08 +00:00
};
}
2022-09-08 01:55:55 +00:00
pub fn bindDateTime(self: PreparedStmt, idx: u15, val: DateTime) BindError!void {
2022-07-18 07:37:10 +00:00
return self.bindI64(idx, val.seconds_since_epoch);
}
2022-09-08 01:55:55 +00:00
pub const StepError = UnexpectedError;
2022-07-24 04:29:38 +00:00
pub fn step(self: PreparedStmt) !?Row {
2022-07-15 00:58:08 +00:00
return switch (c.sqlite3_step(self.stmt)) {
2022-07-15 07:27:27 +00:00
c.SQLITE_ROW => Row{ .stmt = self.stmt, .db = self.db },
c.SQLITE_DONE => null,
2022-07-15 00:58:08 +00:00
2022-09-08 01:55:55 +00:00
else => |err| handleUnexpectedError(self.db, err, self.getGeneratingSql()),
2022-07-15 00:58:08 +00:00
};
}
2022-07-24 04:29:38 +00:00
pub fn finalize(self: PreparedStmt) void {
2022-09-08 01:55:55 +00:00
switch (c.sqlite3_finalize(self.stmt)) {
c.SQLITE_OK => {},
else => |err| {
handleUnexpectedError(self.db, err, self.getGeneratingSql()) catch {};
},
}
2022-07-15 00:58:08 +00:00
}
2022-07-24 04:29:38 +00:00
pub fn reset(self: PreparedStmt) void {
2022-09-08 01:55:55 +00:00
switch (c.sqlite3_reset(self.stmt)) {
c.SQLITE_OK => {},
else => |err| {
handleUnexpectedError(self.db, err, self.getGeneratingSql()) catch {};
},
}
2022-07-15 00:58:08 +00:00
}
2022-07-22 04:18:20 +00:00
2022-09-08 01:55:55 +00:00
fn getGeneratingSql(self: PreparedStmt) ?[]const u8 {
const ptr = c.sqlite3_sql(self.stmt) orelse return null;
return ptr[0..std.mem.len(ptr)];
2022-07-22 04:18:20 +00:00
}
2022-07-15 00:58:08 +00:00
};