1 files changed, 35 insertions, 14 deletions

diff --git a/README.md b/README.md
index 07a9845..041b715 100644
--- a/README.md
+++ b/README.md
@@ -124,6 +124,8 @@ Only the `mode` field is mandatory, the other fields have sane default values.
 sqlite works exclusively by using prepared statements. The wrapper type is `sqlite.Statement`. Here is how you get one:
 
 ```zig
+try db.exec("CREATE TABLE IF NOT EXISTS employees(id integer primary key, name text, age integer, salary integer)", .{}, .{});
+
 const query =
     \\SELECT id, name, age, salary FROM employees WHERE age > ? AND age < ?
 ;
@@ -153,15 +155,16 @@ For queries which do not return data (`INSERT`, `UPDATE`) you can use the `exec`
 
 ```zig
 const query =
-    \\UPDATE foo SET salary = ? WHERE id = ?
+    \\INSERT INTO employees(name, age, salary) VALUES(?, ?, ?)
 ;
 
 var stmt = try db.prepare(query);
 defer stmt.deinit();
 
 try stmt.exec(.{}, .{
+    .name = "José",
+    .age = 40,
     .salary = 20000,
-    .id = 40,
 });
 ```
 
@@ -172,7 +175,7 @@ See the section "Bind parameters and resultset rows" for more information on the
 You can reuse a statement by resetting it like this:
 ```zig
 const query =
-    \\UPDATE foo SET salary = ? WHERE id = ?
+    \\UPDATE employees SET salary = ? WHERE id = ?
 ;
 
 var stmt = try db.prepare(query);
@@ -284,6 +287,8 @@ const query =
 var stmt = try db.prepare(query);
 defer stmt.deinit();
 
+const allocator = std.heap.page_allocator; // Use a suitable allocator
+
 const names = try stmt.all([]const u8, allocator, .{}, .{
     .age1 = 20,
     .age2 = 40,
@@ -303,11 +308,13 @@ const query =
 var stmt = try db.prepare(query);
 defer stmt.deinit();
 
+const allocator = std.heap.page_allocator; // Use a suitable allocator
+
 const row = try stmt.oneAlloc([]const u8, allocator, .{}, .{
     .id = 200,
 });
 if (row) |name| {
-    std.log.debug("name: {}", .{name});
+    std.log.debug("name: {s}", .{name});
 }
 ```
 
@@ -326,7 +333,7 @@ Iterating is done by calling the `next` or `nextAlloc` method on an iterator. Ju
 ### `Iterator.next`
 
 ```zig
-var stmt = try db.prepare("SELECT age FROM user WHERE age < ?");
+var stmt = try db.prepare("SELECT age FROM employees WHERE age < ?");
 defer stmt.deinit();
 
 var iter = try stmt.iterator(usize, .{
@@ -341,19 +348,21 @@ while (try iter.next(.{})) |age| {
 ### `Iterator.nextAlloc`
 
 ```zig
-var stmt = try db.prepare("SELECT name FROM user WHERE age < ?");
+var stmt = try db.prepare("SELECT name FROM employees WHERE age < ?");
 defer stmt.deinit();
 
 var iter = try stmt.iterator([]const u8, .{
     .age = 20,
 });
 
+const allocator = std.heap.page_allocator; // Use a suitable allocator
+
 while (true) {
     var arena = std.heap.ArenaAllocator.init(allocator);
     defer arena.deinit();
 
     const name = (try iter.nextAlloc(arena.allocator(), .{})) orelse break;
-    std.debug.print("name: {}\n", .{name});
+    std.debug.print("name: {s}\n", .{name});
 }
 ```
 
@@ -438,6 +447,8 @@ This will do multiple allocations:
 
 To facilitate memory handling, consider using an arena allocator like this:
 ```zig
+const allocator = std.heap.page_allocator; // Use a suitable allocator
+
 var arena = std.heap.ArenaAllocator.init(allocator);
 defer arena.deinit();
 
@@ -460,7 +471,9 @@ Take the following code:
 var stmt = try db.prepare("SELECT id FROM user WHERE age > ? AND age < ? AND weight > ?");
 defer stmt.deinit();
 
-const rows = try stmt.all(usize, .{}, .{
+const allocator = std.heap.page_allocator; // Use a suitable allocator
+
+const rows = try stmt.all(usize, allocator, .{}, .{
     .age_1 = 10,
     .age_2 = 20,
 });
@@ -495,7 +508,9 @@ For example, take the same code as above but now we also bind the last parameter
 var stmt = try db.prepare("SELECT id FROM user WHERE age > ? AND age < ? AND weight > ?");
 defer stmt.deinit();
 
-const rows = try stmt.all(usize, .{ .allocator = allocator }, .{
+const allocator = std.heap.page_allocator; // Use a suitable allocator
+
+const rows = try stmt.all(usize, allocator, .{}, .{
     .age_1 = 10,
     .age_2 = 20,
     .weight = false,
@@ -510,7 +525,9 @@ We can make sure the bind parameters have the right type if we rewrite the query
 var stmt = try db.prepare("SELECT id FROM user WHERE age > ? AND age < ? AND weight > ?{usize}");
 defer stmt.deinit();
 
-const rows = try stmt.all(usize, .{ .allocator = allocator }, .{
+const allocator = std.heap.page_allocator; // Use a suitable allocator
+
+const rows = try stmt.all(usize, allocator, .{}, .{
     .age_1 = 10,
     .age_2 = 20,
     .weight = false,
@@ -554,7 +571,9 @@ To finish our example, passing the proper type allows it compile:
 var stmt = try db.prepare("SELECT id FROM user WHERE age > ? AND age < ? AND weight > ?{usize}");
 defer stmt.deinit();
 
-const rows = try stmt.all(usize, .{}, .{
+const allocator = std.heap.page_allocator; // Use a suitable allocator
+
+const rows = try stmt.all(usize, allocator, .{}, .{
     .age_1 = 10,
     .age_2 = 20,
     .weight = @as(usize, 200),
@@ -597,7 +616,7 @@ Each input arguments in the function call in the statement is passed on to the r
 
 ## Aggregate functions
 
-You can define a scalar function using `db.createAggregateFunction`:
+You can define a aggregate function using `db.createAggregateFunction`:
 ```zig
 const MyContext = struct {
     sum: u32,
@@ -608,12 +627,14 @@ try db.createAggregateFunction(
     "mySum",
     &my_ctx,
     struct {
-        fn step(ctx: *MyContext, input: u32) void {
+        fn step(fctx: sqlite.FunctionContext, input: u32) void {
+            var ctx = fctx.userContext(*MyContext) orelse return;
             ctx.sum += input;
         }
     }.step,
     struct {
-        fn finalize(ctx: *MyContext) u32 {
+        fn finalize(fctx: sqlite.FunctionContext) u32 {
+            const ctx = fctx.userContext(*MyContext) orelse return 0;
             return ctx.sum;
         }
     }.finalize,