1 files changed, 68 insertions, 16 deletions

diff --git a/sqlite.zig b/sqlite.zig
index bbf7043..abeea55 100644
--- a/sqlite.zig
+++ b/sqlite.zig
@@ -906,6 +906,17 @@ pub fn Iterator(comptime Type: type) type {
                     .Array => try self.readArray(FieldType, i),
                     .Pointer => try self.readPointer(FieldType, options.allocator, i),
                     .Optional => try self.readOptional(FieldType, options, i),
+                    .Enum => |TI| {
+                        const innervalue = try self.readField(FieldType.BaseType, i, options);
+
+                        if (comptime std.meta.trait.isZigString(FieldType.BaseType)) {
+                            return std.meta.stringToEnum(FieldType, innervalue) orelse unreachable;
+                        }
+                        if (@typeInfo(FieldType.BaseType) == .Int) {
+                            return @intToEnum(FieldType, @intCast(TI.tag_type, innervalue));
+                        }
+                        @compileError("enum column " ++ @typeName(FieldType) ++ " must have a BaseType of either string or int");
+                    },
                     else => @compileError("cannot populate field of type " ++ @typeName(FieldType)),
                 },
             };
@@ -1039,8 +1050,15 @@ pub fn Statement(comptime opts: StatementOptions, comptime query: ParsedQuery) t
             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));
+                    .Typed => |typ| {
+                        const FieldTypeInfo = @typeInfo(struct_field.field_type);
+                        switch (FieldTypeInfo) {
+                            .Struct, .Enum, .Union => comptime assertMarkerType(
+                                if (@hasDecl(struct_field.field_type, "BaseType")) struct_field.field_type.BaseType else struct_field.field_type,
+                                typ,
+                            ),
+                            else => comptime assertMarkerType(struct_field.field_type, typ),
+                        }
                     },
                     .Untyped => {},
                 }
@@ -1051,6 +1069,12 @@ pub fn Statement(comptime opts: StatementOptions, comptime query: ParsedQuery) t
             }
         }
 
+        fn assertMarkerType(comptime Actual: type, comptime Expected: type) void {
+            if (Actual != Expected) {
+                @compileError("value type " ++ @typeName(Actual) ++ " is not the bind marker type " ++ @typeName(Expected));
+            }
+        }
+
         fn bindField(self: *Self, comptime FieldType: type, comptime field_name: []const u8, i: c_int, field: FieldType) void {
             const field_type_info = @typeInfo(FieldType);
             const column = i + 1;
@@ -1089,6 +1113,15 @@ pub fn Statement(comptime opts: StatementOptions, comptime query: ParsedQuery) t
                         _ = c.sqlite3_bind_null(self.stmt, column);
                     },
                     .Null => _ = c.sqlite3_bind_null(self.stmt, column),
+                    .Enum => {
+                        if (comptime std.meta.trait.isZigString(FieldType.BaseType)) {
+                            return self.bindField(FieldType.BaseType, field_name, i, @tagName(field));
+                        }
+                        if (@typeInfo(FieldType.BaseType) == .Int) {
+                            return self.bindField(FieldType.BaseType, field_name, i, @enumToInt(field));
+                        }
+                        @compileError("enum column " ++ @typeName(FieldType) ++ " must have a BaseType of either string or int to bind");
+                    },
                     else => @compileError("cannot bind field " ++ field_name ++ " of type " ++ @typeName(FieldType)),
                 },
             }
@@ -1240,12 +1273,30 @@ const TestUser = struct {
     id: usize,
     age: usize,
     weight: f32,
+    favorite_color: Color,
+
+    pub const Color = enum {
+        red,
+        majenta,
+        violet,
+        indigo,
+        blue,
+        cyan,
+        green,
+        lime,
+        yellow,
+        //
+        orange,
+        //
+
+        pub const BaseType = []const u8;
+    };
 };
 
 const test_users = &[_]TestUser{
-    .{ .name = "Vincent", .id = 20, .age = 33, .weight = 85.4 },
-    .{ .name = "Julien", .id = 40, .age = 35, .weight = 100.3 },
-    .{ .name = "José", .id = 60, .age = 40, .weight = 240.2 },
+    .{ .name = "Vincent", .id = 20, .age = 33, .weight = 85.4, .favorite_color = .violet },
+    .{ .name = "Julien", .id = 40, .age = 35, .weight = 100.3, .favorite_color = .green },
+    .{ .name = "José", .id = 60, .age = 40, .weight = 240.2, .favorite_color = .indigo },
 };
 
 fn createTestTables(db: *Db) !void {
@@ -1254,10 +1305,11 @@ fn createTestTables(db: *Db) !void {
         "DROP TABLE IF EXISTS article",
         "DROP TABLE IF EXISTS test_blob",
         \\CREATE TABLE user(
-        \\ id integer PRIMARY KEY,
         \\ name text,
+        \\ id integer PRIMARY KEY,
         \\ age integer,
-        \\ weight real
+        \\ weight real,
+        \\ favorite_color text
         \\)
         ,
         \\CREATE TABLE article(
@@ -1279,7 +1331,7 @@ fn addTestData(db: *Db) !void {
     try createTestTables(db);
 
     for (test_users) |user| {
-        try db.exec("INSERT INTO user(name, id, age, weight) VALUES(?{[]const u8}, ?{usize}, ?{usize}, ?{f32})", .{}, user);
+        try db.exec("INSERT INTO user(name, id, age, weight, favorite_color) VALUES(?{[]const u8}, ?{usize}, ?{usize}, ?{f32}, ?{[]const u8})", .{}, user);
 
         const rows_inserted = db.rowsAffected();
         try testing.expectEqual(@as(usize, 1), rows_inserted);
@@ -1371,7 +1423,7 @@ test "sqlite: read a single user into a struct" {
     var db = try getTestDb();
     try addTestData(&db);
 
-    var stmt = try db.prepare("SELECT name, id, age, weight FROM user WHERE id = ?{usize}");
+    var stmt = try db.prepare("SELECT * FROM user WHERE id = ?{usize}");
     defer stmt.deinit();
 
     var rows = try stmt.all(TestUser, &arena.allocator, .{}, .{
@@ -1432,7 +1484,7 @@ test "sqlite: read all users into a struct" {
     var db = try getTestDb();
     try addTestData(&db);
 
-    var stmt = try db.prepare("SELECT name, id, age, weight FROM user");
+    var stmt = try db.prepare("SELECT * FROM user");
     defer stmt.deinit();
 
     var rows = try stmt.all(TestUser, &arena.allocator, .{}, .{});
@@ -1751,13 +1803,13 @@ test "sqlite: statement reset" {
 
     // Add data
 
-    var stmt = try db.prepare("INSERT INTO user(name, id, age, weight) VALUES(?{[]const u8}, ?{usize}, ?{usize}, ?{f32})");
+    var stmt = try db.prepare("INSERT INTO user(name, id, age, weight, favorite_color) VALUES(?{[]const u8}, ?{usize}, ?{usize}, ?{f32}, ?{[]const u8})");
     defer stmt.deinit();
 
     const users = &[_]TestUser{
-        .{ .id = 200, .name = "Vincent", .age = 33, .weight = 10.0 },
-        .{ .id = 400, .name = "Julien", .age = 35, .weight = 12.0 },
-        .{ .id = 600, .name = "José", .age = 40, .weight = 14.0 },
+        .{ .id = 200, .name = "Vincent", .age = 33, .weight = 10.0, .favorite_color = .violet },
+        .{ .id = 400, .name = "Julien", .age = 35, .weight = 12.0, .favorite_color = .green },
+        .{ .id = 600, .name = "José", .age = 40, .weight = 14.0, .favorite_color = .indigo },
     };
 
     for (users) |user| {
@@ -1781,14 +1833,14 @@ test "sqlite: statement iterator" {
     try db.exec("DELETE FROM user", .{}, .{});
 
     // Add data
-    var stmt = try db.prepare("INSERT INTO user(name, id, age, weight) VALUES(?{[]const u8}, ?{usize}, ?{usize}, ?{f32})");
+    var stmt = try db.prepare("INSERT INTO user(name, id, age, weight, favorite_color) VALUES(?{[]const u8}, ?{usize}, ?{usize}, ?{f32}, ?{[]const u8})");
     defer stmt.deinit();
 
     var expected_rows = std.ArrayList(TestUser).init(allocator);
     var i: usize = 0;
     while (i < 20) : (i += 1) {
         const name = try std.fmt.allocPrint(allocator, "Vincent {d}", .{i});
-        const user = TestUser{ .id = i, .name = name, .age = i + 200, .weight = @intToFloat(f32, i + 200) };
+        const user = TestUser{ .id = i, .name = name, .age = i + 200, .weight = @intToFloat(f32, i + 200), .favorite_color = .indigo };
 
         try expected_rows.append(user);