Merge branch 'bind-parameters-types' into master

2 files changed, 319 insertions, 57 deletions

diff --git a/query.zig b/query.zig
new file mode 100644
index 0000000..81f7333
--- /dev/null
+++ b/query.zig
@@ -0,0 +1,212 @@
+const builtin = @import("builtin");
+const std = @import("std");
+const mem = std.mem;
+const testing = std.testing;
+
+/// Blob is used to represent a SQLite BLOB value when binding a parameter or reading a column.
+pub const Blob = struct { data: []const u8 };
+
+/// Text is used to represent a SQLite TEXT value when binding a parameter or reading a column.
+pub const Text = struct { data: []const u8 };
+
+const BindMarker = union(enum) {
+    Typed: type,
+    Untyped: void,
+};
+
+pub const ParsedQuery = struct {
+    const Self = @This();
+
+    bind_markers: [128]BindMarker,
+    nb_bind_markers: usize,
+
+    query: [1024]u8,
+    query_size: usize,
+
+    pub fn from(comptime query: []const u8) Self {
+        const State = enum {
+            Start,
+            BindMarker,
+            BindMarkerType,
+        };
+
+        comptime var buf: [query.len]u8 = undefined;
+        comptime var pos = 0;
+        comptime var state = .Start;
+
+        comptime var current_bind_marker_type: [256]u8 = undefined;
+        comptime var current_bind_marker_type_pos = 0;
+
+        comptime var parsed_query: ParsedQuery = undefined;
+        parsed_query.nb_bind_markers = 0;
+
+        inline for (query) |c, i| {
+            switch (state) {
+                .Start => switch (c) {
+                    '?' => {
+                        state = .BindMarker;
+                        buf[pos] = c;
+                        pos += 1;
+                    },
+                    else => {
+                        buf[pos] = c;
+                        pos += 1;
+                    },
+                },
+                .BindMarker => switch (c) {
+                    '{' => {
+                        state = .BindMarkerType;
+                        current_bind_marker_type_pos = 0;
+                    },
+                    else => {
+                        // This is a bind marker without a type.
+                        state = .Start;
+
+                        parsed_query.bind_markers[parsed_query.nb_bind_markers] = BindMarker{ .Untyped = {} };
+                        parsed_query.nb_bind_markers += 1;
+
+                        buf[pos] = c;
+                        pos += 1;
+                    },
+                },
+                .BindMarkerType => switch (c) {
+                    '}' => {
+                        state = .Start;
+
+                        const typ = parsed_query.parseType(current_bind_marker_type[0..current_bind_marker_type_pos]);
+
+                        parsed_query.bind_markers[parsed_query.nb_bind_markers] = BindMarker{ .Typed = typ };
+                        parsed_query.nb_bind_markers += 1;
+                    },
+                    else => {
+                        current_bind_marker_type[current_bind_marker_type_pos] = c;
+                        current_bind_marker_type_pos += 1;
+                    },
+                },
+                else => {
+                    @compileError("invalid state " ++ @tagName(state));
+                },
+            }
+        }
+
+        // The last character was ? so this must be an untyped bind marker.
+        if (state == .BindMarker) {
+            parsed_query.bind_markers[parsed_query.nb_bind_markers] = BindMarker{ .Untyped = {} };
+            parsed_query.nb_bind_markers += 1;
+        }
+
+        if (state == .BindMarkerType) {
+            @compileError("invalid final state " ++ @tagName(state) ++ ", this means you wrote an incomplete bind marker type");
+        }
+
+        mem.copy(u8, &parsed_query.query, &buf);
+        parsed_query.query_size = pos;
+
+        return parsed_query;
+    }
+
+    fn parseType(comptime self: *Self, type_info: []const u8) type {
+        if (type_info.len <= 0) @compileError("invalid type info " ++ type_info);
+
+        // Integer
+        if (mem.eql(u8, "usize", type_info)) return usize;
+        if (mem.eql(u8, "isize", type_info)) return isize;
+
+        if (type_info[0] == 'u' or type_info[0] == 'i') {
+            return @Type(builtin.TypeInfo{
+                .Int = builtin.TypeInfo.Int{
+                    .is_signed = type_info[0] == 'i',
+                    .bits = std.fmt.parseInt(usize, type_info[1..type_info.len], 10) catch {
+                        @compileError("invalid type info " ++ type_info);
+                    },
+                },
+            });
+        }
+
+        // Float
+        if (mem.eql(u8, "f16", type_info)) return f16;
+        if (mem.eql(u8, "f32", type_info)) return f32;
+        if (mem.eql(u8, "f64", type_info)) return f64;
+        if (mem.eql(u8, "f128", type_info)) return f128;
+
+        // Strings
+        if (mem.eql(u8, "[]const u8", type_info) or mem.eql(u8, "[]u8", type_info)) {
+            return []const u8;
+        }
+        if (mem.eql(u8, "text", type_info)) return Text;
+        if (mem.eql(u8, "blob", type_info)) return Blob;
+
+        @compileError("invalid type info " ++ type_info);
+    }
+
+    pub fn getQuery(comptime self: *const Self) []const u8 {
+        return self.query[0..self.query_size];
+    }
+};
+
+test "parsed query: query" {
+    const testCase = struct {
+        query: []const u8,
+        expected_query: []const u8,
+    };
+
+    const testCases = &[_]testCase{
+        .{
+            .query = "INSERT INTO user(id, name, age) VALUES(?{usize}, ?{[]const u8}, ?{u32})",
+            .expected_query = "INSERT INTO user(id, name, age) VALUES(?, ?, ?)",
+        },
+        .{
+            .query = "SELECT id, name, age FROM user WHER age > ?{u32} AND age < ?{u32}",
+            .expected_query = "SELECT id, name, age FROM user WHER age > ? AND age < ?",
+        },
+        .{
+            .query = "SELECT id, name, age FROM user WHER age > ? AND age < ?",
+            .expected_query = "SELECT id, name, age FROM user WHER age > ? AND age < ?",
+        },
+    };
+
+    inline for (testCases) |tc| {
+        comptime var parsed_query = ParsedQuery.from(tc.query);
+        std.debug.print("parsed query: {}\n", .{parsed_query.getQuery()});
+        testing.expectEqualStrings(tc.expected_query, parsed_query.getQuery());
+    }
+}
+
+test "parsed query: bind markers types" {
+    const testCase = struct {
+        query: []const u8,
+        expected_marker: BindMarker,
+    };
+
+    const testCases = &[_]testCase{
+        .{
+            .query = "foobar ?{usize}",
+            .expected_marker = .{ .Typed = usize },
+        },
+        .{
+            .query = "foobar ?{text}",
+            .expected_marker = .{ .Typed = Text },
+        },
+        .{
+            .query = "foobar ?{blob}",
+            .expected_marker = .{ .Typed = Blob },
+        },
+        .{
+            .query = "foobar ?",
+            .expected_marker = .{ .Untyped = {} },
+        },
+    };
+
+    inline for (testCases) |tc| {
+        comptime var parsed_query = ParsedQuery.from(tc.query);
+        std.debug.print("parsed query: {}\n", .{parsed_query.getQuery()});
+
+        testing.expectEqual(1, parsed_query.nb_bind_markers);
+
+        const bind_marker = parsed_query.bind_markers[0];
+        switch (tc.expected_marker) {
+            .Typed => |typ| testing.expectEqual(typ, bind_marker.Typed),
+            .Untyped => |typ| testing.expectEqual(typ, bind_marker.Untyped),
+        }
+    }
+}
diff --git a/sqlite.zig b/sqlite.zig
index 5844c34..53e1a6a 100644
--- a/sqlite.zig
+++ b/sqlite.zig
@@ -8,6 +8,8 @@ const c = @cImport({
     @cInclude("sqlite3.h");
 });
 
+usingnamespace @import("query.zig");
+
 const logger = std.log.scoped(.sqlite);
 
 /// Db is a wrapper around a SQLite database, providing high-level functions for executing queries.
@@ -106,8 +108,10 @@ pub const Db = struct {
     /// The statement returned is only compatible with the number of bind markers in the input query.
     /// This is done because we type check the bind parameters when executing the statement later.
     ///
-    pub fn prepare(self: *Self, comptime query: []const u8) !Statement(StatementOptions.from(query)) {
-        return Statement(comptime StatementOptions.from(query)).prepare(self, 0, query);
+    pub fn prepare(self: *Self, comptime query: []const u8) !Statement(.{}, ParsedQuery.from(query)) {
+        @setEvalBranchQuota(3000);
+        const parsed_query = ParsedQuery.from(query);
+        return Statement(.{}, comptime parsed_query).prepare(self, 0);
     }
 
     /// rowsAffected returns the number of rows affected by the last statement executed.
@@ -116,28 +120,7 @@ pub const Db = struct {
     }
 };
 
-/// Bytes is used to represent a byte slice with its SQLite datatype.
-///
-/// Since Zig doesn't have strings we can't tell if a []u8 must be stored as a SQLite TEXT or BLOB,
-/// this type can be used to communicate this when executing a statement.
-///
-/// If a []u8 or []const u8 is passed as bind parameter it will be treated as TEXT.
-pub const Bytes = union(enum) {
-    Blob: []const u8,
-    Text: []const u8,
-};
-
-pub const StatementOptions = struct {
-    const Self = @This();
-
-    bind_markers: usize,
-
-    fn from(comptime query: []const u8) Self {
-        return Self{
-            .bind_markers = std.mem.count(u8, query, "?"),
-        };
-    }
-};
+pub const StatementOptions = struct {};
 
 /// Statement is a wrapper around a SQLite statement, providing high-level functions to execute
 /// a statement and retrieve rows for SELECT queries.
@@ -172,19 +155,21 @@ pub const StatementOptions = struct {
 ///
 /// Look at aach function for more complete documentation.
 ///
-pub fn Statement(comptime opts: StatementOptions) type {
+pub fn Statement(comptime opts: StatementOptions, comptime query: ParsedQuery) type {
     return struct {
         const Self = @This();
 
         stmt: *c.sqlite3_stmt,
 
-        fn prepare(db: *Db, flags: c_uint, comptime query: []const u8) !Self {
+        fn prepare(db: *Db, flags: c_uint) !Self {
             var stmt = blk: {
+                const real_query = query.getQuery();
+
                 var tmp: ?*c.sqlite3_stmt = undefined;
                 const result = c.sqlite3_prepare_v3(
                     db.db,
-                    query.ptr,
-                    @intCast(c_int, query.len),
+                    real_query.ptr,
+                    @intCast(c_int, real_query.len),
                     flags,
                     &tmp,
                     null,
@@ -212,11 +197,19 @@ pub fn Statement(comptime opts: StatementOptions) type {
             const StructType = @TypeOf(values);
             const StructTypeInfo = @typeInfo(StructType).Struct;
 
-            if (comptime opts.bind_markers != StructTypeInfo.fields.len) {
+            if (comptime query.nb_bind_markers != StructTypeInfo.fields.len) {
                 @compileError("number of bind markers not equal to number of fields");
             }
 
             inline for (StructTypeInfo.fields) |struct_field, _i| {
+                const bind_marker = query.bind_markers[_i];
+                switch (bind_marker) {
+                    .Typed => |typ| if (struct_field.field_type != typ) {
+                        @compileError("value type " ++ @typeName(struct_field.field_type) ++ " is not the bind marker type " ++ @typeName(typ));
+                    },
+                    .Untyped => {},
+                }
+
                 const i = @as(usize, _i);
                 const field_type_info = @typeInfo(struct_field.field_type);
                 const field_value = @field(values, struct_field.name);
@@ -226,10 +219,8 @@ pub fn Statement(comptime opts: StatementOptions) type {
                     []const u8, []u8 => {
                         _ = c.sqlite3_bind_text(self.stmt, column, field_value.ptr, @intCast(c_int, field_value.len), null);
                     },
-                    Bytes => switch (field_value) {
-                        .Text => |v| _ = c.sqlite3_bind_text(self.stmt, column, v.ptr, @intCast(c_int, v.len), null),
-                        .Blob => |v| _ = c.sqlite3_bind_blob(self.stmt, column, v.ptr, @intCast(c_int, v.len), null),
-                    },
+                    Text => _ = c.sqlite3_bind_text(self.stmt, column, field_value.data.ptr, @intCast(c_int, field_value.data.len), null),
+                    Blob => _ = c.sqlite3_bind_blob(self.stmt, column, field_value.data.ptr, @intCast(c_int, field_value.data.len), null),
                     else => switch (field_type_info) {
                         .Int, .ComptimeInt => _ = c.sqlite3_bind_int64(self.stmt, column, @intCast(c_longlong, field_value)),
                         .Float, .ComptimeFloat => _ = c.sqlite3_bind_double(self.stmt, column, field_value),
@@ -385,6 +376,39 @@ pub fn Statement(comptime opts: StatementOptions) type {
             return @intCast(Type, n);
         }
 
+        const ReadBytesMode = enum {
+            Blob,
+            Text,
+        };
+
+        fn readBytes(self: *Self, allocator: *mem.Allocator, mode: ReadBytesMode, _i: usize, ptr: *[]const u8) !void {
+            const i = @intCast(c_int, _i);
+            switch (mode) {
+                .Blob => {
+                    const data = c.sqlite3_column_blob(self.stmt, i);
+                    if (data == null) ptr.* = "";
+
+                    const size = @intCast(usize, c.sqlite3_column_bytes(self.stmt, i));
+
+                    var tmp = try allocator.alloc(u8, size);
+                    mem.copy(u8, tmp, @ptrCast([*c]const u8, data)[0..size]);
+
+                    ptr.* = tmp;
+                },
+                .Text => {
+                    const data = c.sqlite3_column_text(self.stmt, i);
+                    if (data == null) ptr.* = "";
+
+                    const size = @intCast(usize, c.sqlite3_column_bytes(self.stmt, i));
+
+                    var tmp = try allocator.alloc(u8, size);
+                    mem.copy(u8, tmp, @ptrCast([*c]const u8, data)[0..size]);
+
+                    ptr.* = tmp;
+                },
+            }
+        }
+
         fn readStruct(self: *Self, comptime Type: type, options: anytype) !Type {
             var value: Type = undefined;
 
@@ -394,17 +418,13 @@ pub fn Statement(comptime opts: StatementOptions) type {
 
                 switch (field.field_type) {
                     []const u8, []u8 => {
-                        const data = c.sqlite3_column_blob(self.stmt, i);
-                        if (data == null) {
-                            @field(value, field.name) = "";
-                        } else {
-                            const size = @intCast(usize, c.sqlite3_column_bytes(self.stmt, i));
-
-                            var tmp = try options.allocator.alloc(u8, size);
-                            mem.copy(u8, tmp, @ptrCast([*c]const u8, data)[0..size]);
-
-                            @field(value, field.name) = tmp;
-                        }
+                        try self.readBytes(options.allocator, .Blob, i, &@field(value, field.name));
+                    },
+                    Blob => {
+                        try self.readBytes(options.allocator, .Blob, i, &@field(value, field.name).data);
+                    },
+                    Text => {
+                        try self.readBytes(options.allocator, .Text, i, &@field(value, field.name).data);
                     },
                     else => switch (field_type_info) {
                         .Int => {
@@ -490,7 +510,7 @@ test "sqlite: statement exec" {
     };
 
     for (users) |user| {
-        try db.exec("INSERT INTO user(id, name, age) VALUES(?, ?, ?)", user);
+        try db.exec("INSERT INTO user(id, name, age) VALUES(?{usize}, ?{[]const u8}, ?{usize})", user);
 
         const rows_inserted = db.rowsAffected();
         testing.expectEqual(@as(usize, 1), rows_inserted);
@@ -499,10 +519,10 @@ test "sqlite: statement exec" {
     // Read a single user
 
     {
-        var stmt = try db.prepare("SELECT id, name, age FROM user WHERE id = ?");
+        var stmt = try db.prepare("SELECT id, name, age FROM user WHERE id = ?{usize}");
         defer stmt.deinit();
 
-        var rows = try stmt.all(User, .{ .allocator = allocator }, .{ .id = 20 });
+        var rows = try stmt.all(User, .{ .allocator = allocator }, .{ .id = @as(usize, 20) });
         for (rows) |row| {
             testing.expectEqual(users[0].id, row.id);
             testing.expectEqualStrings(users[0].name, row.name);
@@ -529,7 +549,7 @@ test "sqlite: statement exec" {
     // Test with anonymous structs
 
     {
-        var stmt = try db.prepare("SELECT id, name, age FROM user WHERE id = ?");
+        var stmt = try db.prepare("SELECT id, name, age FROM user WHERE id = ?{usize}");
         defer stmt.deinit();
 
         var row = try stmt.one(
@@ -539,7 +559,7 @@ test "sqlite: statement exec" {
                 age: usize,
             },
             .{ .allocator = allocator },
-            .{ .id = 20 },
+            .{ .id = @as(usize, 20) },
         );
         testing.expect(row != null);
 
@@ -552,26 +572,56 @@ test "sqlite: statement exec" {
     // Test with a single integer
 
     {
-        const query = "SELECT age FROM user WHERE id = ?";
+        const query = "SELECT age FROM user WHERE id = ?{usize}";
 
-        var stmt: Statement(StatementOptions.from(query)) = try db.prepare(query);
+        var stmt: Statement(.{}, ParsedQuery.from(query)) = try db.prepare(query);
         defer stmt.deinit();
 
-        var age = try stmt.one(usize, .{}, .{ .id = 20 });
+        var age = try stmt.one(usize, .{}, .{ .id = @as(usize, 20) });
         testing.expect(age != null);
 
         testing.expectEqual(@as(usize, 33), age.?);
     }
 
-    // Test with a Bytes struct
+    // Test with a Blob struct
+    {
+        try db.exec("INSERT INTO user(id, name, age) VALUES(?{usize}, ?{blob}, ?{u32})", .{
+            .id = @as(usize, 200),
+            .name = Blob{ .data = "hello" },
+            .age = @as(u32, 20),
+        });
+    }
 
+    // Test with a Text struct
     {
-        try db.exec("INSERT INTO user(id, name, age) VALUES(?, ?, ?)", .{
-            .id = 200,
-            .name = Bytes{ .Text = "hello" },
-            .age = 20,
+        try db.exec("INSERT INTO user(id, name, age) VALUES(?{usize}, ?{text}, ?{u32})", .{
+            .id = @as(usize, 201),
+            .name = Text{ .data = "hello" },
+            .age = @as(u32, 20),
         });
     }
+
+    // Read in a Text struct
+    {
+        var stmt = try db.prepare("SELECT id, name, age FROM user WHERE id = ?{usize}");
+        defer stmt.deinit();
+
+        var row = try stmt.one(
+            struct {
+                id: usize,
+                name: Text,
+                age: usize,
+            },
+            .{ .allocator = allocator },
+            .{@as(usize, 20)},
+        );
+        testing.expect(row != null);
+
+        const exp = users[0];
+        testing.expectEqual(exp.id, row.?.id);
+        testing.expectEqualStrings(exp.name, row.?.name.data);
+        testing.expectEqual(exp.age, row.?.age);
+    }
 }
 
 fn dbMode() Db.Mode {