tiny.sql.PreparedStatement

1pub const Prepared = struct {2    allocator: Allocator,3    catalog: catalog_mod.Catalog,4    source: []u8,5    statement: ast_mod.Statement,6    parameters: []ast_mod.Parameter,7    bindings: []result_mod.Binding,8    relation: ?plan.PreparedRelation,9    execution: Execution,10    validation: plan.Validation = .content,1112    pub fn deinit(self: *Prepared) void {13        for (self.bindings) |*binding| binding.deinit(self.allocator);14        self.allocator.free(self.bindings);15        self.allocator.free(self.parameters);16        self.execution.deinit(self.allocator);17        if (self.relation) |*relation| relation.deinit();18        self.statement.deinit(self.allocator);19        self.allocator.free(self.source);20        self.* = undefined;21    }2223    pub fn execute(self: *Prepared, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!result_mod.Result {24        return self.executeResolved(result_allocator, options) catch |err| switch (err) {25            error.RelationNotFound => error.TableNotFound,26            else => err,27        };28    }2930    fn executeResolved(self: *Prepared, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!result_mod.Result {31        return self.executeOnce(result_allocator, options) catch |err| switch (err) {32            error.PlanChanged => {33                try self.reprepare();34                return try self.executeOnce(result_allocator, options);35            },36            else => err,37        };38    }3940    /// Opens a cursor over the rows the select returns in `target`, which the41    /// cursor fills in place. `target` is undefined after an error.42    pub fn openCursor(43        self: *Prepared,44        target: *cursor_mod.Cursor,45        result_allocator: Allocator,46    ) ast_mod.Error!void {47        self.openCursorResolved(target, result_allocator) catch |err| return switch (err) {48            error.RelationNotFound => error.TableNotFound,49            else => err,50        };51    }5253    fn openCursorResolved(54        self: *Prepared,55        target: *cursor_mod.Cursor,56        result_allocator: Allocator,57    ) ast_mod.Error!void {58        self.openCursorOnce(target, result_allocator) catch |err| switch (err) {59            error.PlanChanged => {60                try self.reprepare();61                try self.openCursorOnce(target, result_allocator);62            },63            else => return err,64        };65    }6667    pub fn parameterCount(self: *const Prepared) usize {68        return self.parameters.len;69    }7071    pub fn cacheKey(self: *const Prepared) plan.PlanKey {72        return self.relation.?.cacheKey();73    }7475    pub fn currentCacheKey(self: *Prepared) ast_mod.Error!plan.PlanKey {76        const relation = try self.relationPtr();77        return try relation.currentCacheKey();78    }7980    pub fn parameterName(self: *const Prepared, index: usize) ast_mod.Error!?[]const u8 {81        if (index == 0 or index > self.parameters.len) return error.ParameterIndexOutOfBounds;82        return self.parameters[index - 1].name;83    }8485    pub fn parameterIndex(self: *const Prepared, name: []const u8) ?usize {86        for (self.parameters, 0..) |parameter, offset| {87            if (parameter.name) |parameter_name| {88                if (std.mem.eql(u8, parameter_name, name)) return offset + 1;89            }90        }91        return null;92    }9394    pub fn bind(self: *Prepared, index: usize, bound_value: row.Value) ast_mod.Error!void {95        if (index == 0 or index > self.bindings.len) return error.ParameterIndexOutOfBounds;96        try self.bindings[index - 1].set(self.allocator, bound_value);97    }9899    pub fn bindName(self: *Prepared, name: []const u8, bound_value: row.Value) ast_mod.Error!void {100        const index = self.parameterIndex(name) orelse return error.ParameterNotFound;101        try self.bind(index, bound_value);102    }103104    pub fn clearBinding(self: *Prepared, index: usize) ast_mod.Error!void {105        if (index == 0 or index > self.bindings.len) return error.ParameterIndexOutOfBounds;106        self.bindings[index - 1].clear();107    }108109    pub fn clearBindings(self: *Prepared) void {110        for (self.bindings) |*binding| binding.clear();111    }112113    fn executeOnce(self: *Prepared, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!result_mod.Result {114        const phase = trace.scope("statement.execute");115        defer phase.end();116117        return switch (self.statement) {118            .insert => |insert| try self.executeInsert(insert, result_allocator, options),119            .select => |select| .{120                .rows = try self.executeSelect(select, result_allocator),121            },122            .update => |update| try self.executeUpdate(update, result_allocator, options),123            .delete => |delete| try self.executeDelete(delete, result_allocator, options),124            .create_table => |create_table| .{125                .catalog = try self.executeCreateTable(create_table, result_allocator, options),126            },127            .create_index => |create_index| .{128                .catalog = try self.executeCreateIndex(create_index, result_allocator, options),129            },130            .drop_table => |drop_table| .{131                .catalog = try self.executeDropTable(drop_table, result_allocator, options),132            },133            .analyze => |analyze| .{134                .catalog = try self.executeAnalyze(analyze, result_allocator, options),135            },136        };137    }138139    fn executeInsert(self: *Prepared, insert: ast_mod.Insert, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!result_mod.Result {140        const insert_execution = switch (self.execution) {141            .insert => |*execution| execution,142            else => unreachable,143        };144        const relation = try self.relationPtr();145        const rowid_slot = insert_execution.rowidSlot();146        std.debug.assert(rowid_slot < insert.values.len);147        const rowid = try self.rowidValue(insert.values[rowid_slot]);148        const values = insert_execution.resolve(149            insert,150            relation.handle.definitions,151            self,152        );153        return try applyEdits(relation, result_allocator, options, &.{.{ .put = .{154            .rowid = rowid,155            .values = values,156        } }});157    }158159    fn executeUpdate(self: *Prepared, update: ast_mod.Update, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!result_mod.Result {160        const update_execution = switch (self.execution) {161            .update => |execution| execution,162            else => unreachable,163        };164        const relation = try self.relationPtr();165        const assignments = try result_allocator.alloc(relation_mod.Edit.Assignment, update.assignments.len);166        defer result_allocator.free(assignments);167        for (assignments, update.assignments, update_execution.assignment_fields) |*target, assignment, field| {168            target.* = .{169                .column = field,170                .value = self.expressionValue(assignment.value),171            };172        }173        if (predicate_mod.rowidEqualityOnly(update.predicates)) |expression| {174            return try applyEdits(relation, result_allocator, options, &.{.{ .update = .{175                .rowid = try self.rowidValue(expression),176                .assignments = assignments,177            } }});178        }179        const matched = try self.matchedRowids(relation, update.predicates, result_allocator, options);180        defer result_allocator.free(matched);181        const edits = try result_allocator.alloc(PendingEdit, matched.len);182        defer result_allocator.free(edits);183        for (edits, matched) |*edit, rowid| {184            edit.* = .{ .update = .{185                .rowid = rowid,186                .assignments = assignments,187            } };188        }189        return try applyEdits(relation, result_allocator, options, edits);190    }191192    fn executeDelete(self: *Prepared, delete: ast_mod.Delete, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!result_mod.Result {193        const relation = try self.relationPtr();194        if (predicate_mod.rowidEqualityOnly(delete.predicates)) |expression| {195            return try applyEdits(relation, result_allocator, options, &.{.{196                .delete = try self.rowidValue(expression),197            }});198        }199        const matched = try self.matchedRowids(relation, delete.predicates, result_allocator, options);200        defer result_allocator.free(matched);201        const edits = try result_allocator.alloc(PendingEdit, matched.len);202        defer result_allocator.free(edits);203        for (edits, matched) |*edit, rowid| edit.* = .{ .delete = rowid };204        return try applyEdits(relation, result_allocator, options, edits);205    }206207    fn matchedRowids(self: *Prepared, relation: *plan.PreparedRelation, predicates: []const ast_mod.Predicate, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error![]i64 {208        const phase = trace.scope("statement.matched_rowids");209        defer phase.end();210211        var reader = try relation.execute();212        defer reader.deinit();213        var predicate_stack: [relation_mod.max_index_fields + 1]ast_mod.Predicate = undefined;214        var value_stack: [relation_mod.max_index_fields + 1]row.Value = undefined;215        const runtime = try predicate_mod.runtimePredicates(self, predicates, result_allocator, &predicate_stack, &value_stack);216        defer runtime.deinit(result_allocator);217        var overlay = try StagedOverlay.init(218            result_allocator,219            options,220            relation,221            reader.borrow(),222        );223        defer overlay.deinit();224        var matched: std.ArrayList(i64) = .empty;225        errdefer matched.deinit(result_allocator);226        if (predicate_mod.firstRowidPredicate(predicates, .eq)) |offset| {227            const rowid = try predicate_mod.rowidFromValue(runtime.values[offset]);228            if (overlay.visible(rowid)) |staged| {229                if (staged) |bytes| {230                    if (try predicate_mod.rowBytesMatchPredicates(runtime.predicates, runtime.values, &relation.handle, rowid, bytes)) {231                        try matched.append(result_allocator, rowid);232                    }233                }234            } else if (try reader.get(result_allocator, rowid)) |bytes| {235                defer result_allocator.free(bytes);236                if (try predicate_mod.rowBytesMatchPredicates(runtime.predicates, runtime.values, &relation.handle, rowid, bytes)) {237                    try matched.append(result_allocator, rowid);238                }239            }240            return try matched.toOwnedSlice(result_allocator);241        }242        var start: ?i64 = null;243        var end: ?i64 = null;244        if (predicate_mod.firstRowidRangePredicate(predicates)) |offset| {245            const rowid = try predicate_mod.rowidFromValue(runtime.values[offset]);246            start = predicate_mod.rowidStart(predicates[offset].operator, rowid);247            end = predicate_mod.rowidEnd(predicates[offset].operator, rowid);248        }249        var scan: sql.TableScan = undefined;250        try reader.scan(&scan, result_allocator, start, end);251        defer scan.deinit();252        while (try scan.next()) |entry| {253            if (overlay.shadows(entry.rowid)) continue;254            if (!try predicate_mod.rowBytesMatchPredicates(runtime.predicates, runtime.values, &relation.handle, entry.rowid, entry.bytes)) continue;255            try matched.append(result_allocator, entry.rowid);256        }257        var overlay_rows = overlay.rows.iterator();258        while (overlay_rows.next()) |staged| {259            const bytes = staged.value_ptr.* orelse continue;260            if (!try predicate_mod.rowBytesMatchPredicates(runtime.predicates, runtime.values, &relation.handle, staged.key_ptr.*, bytes)) continue;261            try matched.append(result_allocator, staged.key_ptr.*);262        }263        std.mem.sort(i64, matched.items, {}, std.sort.asc(i64));264        return try matched.toOwnedSlice(result_allocator);265    }266267    fn executeCreateTable(self: *Prepared, create_table: ast_mod.CreateTable, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!session_mod.CatalogFlush {268        const database_session = try options.databaseSession();269        return try database_session.createRelation(result_allocator, &self.catalog, create_table.relationDefinition(), options.commit());270    }271272    fn executeCreateIndex(self: *Prepared, create_index: ast_mod.CreateIndex, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!session_mod.CatalogFlush {273        const database_session = try options.databaseSession();274        const create_index_execution = switch (self.execution) {275            .create_index => |execution| execution,276            else => unreachable,277        };278        return try database_session.createIndex(result_allocator, &self.catalog, create_index.table, .{279            .name = create_index.name,280            .fields = create_index_execution.fields,281            .columns = create_index_execution.columns,282        }, options.commit());283    }284285    fn executeDropTable(self: *Prepared, drop_table: ast_mod.DropTable, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!session_mod.CatalogFlush {286        const database_session = try options.databaseSession();287        return try database_session.dropRelation(result_allocator, &self.catalog, drop_table.table, options.commit());288    }289290    fn executeAnalyze(self: *Prepared, analyze: ast_mod.Analyze, result_allocator: Allocator, options: ExecuteOptions) ast_mod.Error!session_mod.CatalogFlush {291        const database_session = try options.databaseSession();292        return try database_session.analyzeRelation(result_allocator, &self.catalog, analyze.table, options.commit());293    }294295    fn executeSelect(self: *Prepared, select: ast_mod.Select, result_allocator: Allocator) ast_mod.Error!result_mod.Rows {296        const select_execution = switch (self.execution) {297            .select => |execution| execution,298            else => unreachable,299        };300        if (select_execution.order_fields.len != 0 and !orderIsRowidAscending(select_execution.order_fields)) {301            return try self.executeSortedSelect(select, result_allocator);302        }303        const relation = try self.relationPtr();304        var reader = try relation.execute();305        defer reader.deinit();306        var predicate_stack: [relation_mod.max_index_fields + 1]ast_mod.Predicate = undefined;307        var value_stack: [relation_mod.max_index_fields + 1]row.Value = undefined;308        const predicates = try predicate_mod.runtimePredicates(self, select.predicates, result_allocator, &predicate_stack, &value_stack);309        defer predicates.deinit(result_allocator);310        const access = try access_mod.runtimeSelectAccess(select, relation, select_execution.fields, predicates.values);311        if (select_execution.order_fields.len != 0 and312            (access == .index or access == .covering))313        {314            return try self.executeSortedSelect(select, result_allocator);315        }316        var window = try self.selectWindow(select);317        switch (access) {318            .rowid => |rowid_access| if (rowid_access.operator == .eq) {319                const rowid = try predicate_mod.rowidFromValue(predicates.values[rowid_access.predicate_index]);320                const bytes = (try reader.get(result_allocator, rowid)) orelse return .{321                    .allocator = result_allocator,322                    .storage = .{ .single = null },323                };324                errdefer result_allocator.free(bytes);325                if (!try predicate_mod.rowBytesMatchPredicates(predicates.predicates, predicates.values, &relation.handle, rowid, bytes)) {326                    result_allocator.free(bytes);327                    return .{328                        .allocator = result_allocator,329                        .storage = .{ .single = null },330                    };331                }332                if (!window.admit()) {333                    result_allocator.free(bytes);334                    return .{335                        .allocator = result_allocator,336                        .storage = .{ .single = null },337                    };338                }339                if (select_execution.fields.len == 0) {340                    return .{341                        .allocator = result_allocator,342                        .storage = .{ .single = bytes },343                    };344                }345                const projected = try result_mod.selectedRow(result_allocator, select_execution.fields, rowid, bytes);346                result_allocator.free(bytes);347                return .{348                    .allocator = result_allocator,349                    .storage = .{ .single = projected },350                };351            },352            else => {},353        }354        var selected: std.ArrayList([]u8) = .empty;355        errdefer result_mod.freeSelectedRows(result_allocator, selected.items);356        switch (access) {357            .rowid => |rowid_access| {358                const rowid = try predicate_mod.rowidFromValue(predicates.values[rowid_access.predicate_index]);359                var scan: sql.TableScan = undefined;360                try reader.scan(361                    &scan,362                    result_allocator,363                    predicate_mod.rowidStart(rowid_access.operator, rowid),364                    predicate_mod.rowidEnd(rowid_access.operator, rowid),365                );366                defer scan.deinit();367                while (try scan.next()) |entry| {368                    if (window.full()) break;369                    if (!predicate_mod.rowidMatches(entry.rowid, rowid_access.operator, rowid)) continue;370                    if (!try predicate_mod.rowBytesMatchPredicates(predicates.predicates, predicates.values, &relation.handle, entry.rowid, entry.bytes)) continue;371                    if (!window.admit()) continue;372                    try result_mod.appendSelectedRow(result_allocator, &selected, select_execution.fields, entry.rowid, entry.bytes);373                }374            },375            .index => |indexed| {376                var bound_storage: [relation_mod.max_index_fields]row.Value = undefined;377                const bound_values = predicate_mod.indexedPrefixValues(indexed, predicates.values, &bound_storage);378                const covered = access_mod.indexCoversPredicates(&relation.handle, indexed.index_slot, select_execution.fields, predicates.predicates);379                var index_scan: sql.IndexScan = undefined;380                switch (indexed.operator) {381                    .eq => try reader.lookup(382                        &index_scan,383                        result_allocator,384                        indexed.index_slot,385                        bound_values,386                    ),387                    .lt, .lte, .gt, .gte => try reader.indexRange(388                        &index_scan,389                        result_allocator,390                        indexed.index_slot,391                        predicate_mod.indexedRangeStart(indexed, bound_values),392                        predicate_mod.indexedRangeEnd(indexed, bound_values),393                    ),394                }395                defer index_scan.deinit();396                while (try index_scan.next()) |entry| {397                    if (window.full()) break;398                    if (covered) {399                        var index_values: [catalog_mod.max_columns]row.Value = undefined;400                        var index_scratch: [page.size]u8 = undefined;401                        const values = try predicate_mod.coveredIndexValues(402                            predicates.predicates,403                            predicates.values,404                            &relation.handle,405                            indexed.index_slot,406                            entry,407                            &index_values,408                            &index_scratch,409                        ) orelse continue;410                        if (!window.admit()) continue;411                        try result_mod.appendSelectedIndexRow(412                            result_allocator,413                            &selected,414                            select_execution.fields,415                            &relation.handle,416                            indexed.index_slot,417                            values,418                            entry.rowid,419                        );420                        continue;421                    }422                    const bytes = (try reader.get(result_allocator, entry.rowid)) orelse continue;423                    errdefer result_allocator.free(bytes);424                    if (!try predicate_mod.rowBytesMatchPredicates(predicates.predicates, predicates.values, &relation.handle, entry.rowid, bytes)) {425                        result_allocator.free(bytes);426                        continue;427                    }428                    if (!window.admit()) {429                        result_allocator.free(bytes);430                        continue;431                    }432                    try result_mod.appendSelectedRow(result_allocator, &selected, select_execution.fields, entry.rowid, bytes);433                    result_allocator.free(bytes);434                }435            },436            .covering => unreachable,437            .scan => {438                var scan: sql.TableScan = undefined;439                try reader.scan(&scan, result_allocator, null, null);440                defer scan.deinit();441                while (try scan.next()) |entry| {442                    if (window.full()) break;443                    if (!try predicate_mod.rowBytesMatchPredicates(predicates.predicates, predicates.values, &relation.handle, entry.rowid, entry.bytes)) continue;444                    if (!window.admit()) continue;445                    try result_mod.appendSelectedRow(result_allocator, &selected, select_execution.fields, entry.rowid, entry.bytes);446                }447            },448        }449        return .{450            .allocator = result_allocator,451            .storage = .{ .many = try selected.toOwnedSlice(result_allocator) },452        };453    }454455    fn executeSortedSelect(self: *Prepared, select: ast_mod.Select, result_allocator: Allocator) ast_mod.Error!result_mod.Rows {456        const phase = trace.scope("statement.execute_sorted_select");457        defer phase.end();458459        const relation = try self.relationPtr();460        var reader = try relation.execute();461        defer reader.deinit();462        return .{463            .allocator = result_allocator,464            .storage = .{ .many = try self.sortedSelectedRows(select, result_allocator, &reader) },465        };466    }467468    fn sortedSelectedRows(469        self: *Prepared,470        select: ast_mod.Select,471        result_allocator: Allocator,472        reader: *const plan.RelationRead,473    ) ast_mod.Error![][]u8 {474        const select_execution = switch (self.execution) {475            .select => |execution| execution,476            else => unreachable,477        };478        const collected = try self.collectSortedRows(select, result_allocator, reader);479        errdefer result_mod.freeSortedRows(result_allocator, collected);480        std.mem.sort(result_mod.SortedRow, collected, result_mod.SortedRowContext{481            .order_fields = select_execution.order_fields,482        }, result_mod.sortedRowLessThan);483        const window = try self.selectWindow(select);484        const start = @min(window.skip, collected.len);485        const end = if (window.remaining) |remaining| @min(start +| remaining, collected.len) else collected.len;486        std.debug.assert(start <= end);487        std.debug.assert(end <= collected.len);488        const selected = try result_allocator.alloc([]u8, end - start);489        for (selected, collected[start..end]) |*out, sorted_row| out.* = sorted_row.projected;490        for (collected[0..start]) |sorted_row| result_allocator.free(sorted_row.projected);491        for (collected[end..]) |sorted_row| result_allocator.free(sorted_row.projected);492        for (collected) |sorted_row| result_mod.freeSortedKeys(result_allocator, sorted_row.keys);493        result_allocator.free(collected);494        return selected;495    }496497    fn collectSortedRows(498        self: *Prepared,499        select: ast_mod.Select,500        result_allocator: Allocator,501        reader: *const plan.RelationRead,502    ) ast_mod.Error![]result_mod.SortedRow {503        const select_execution = switch (self.execution) {504            .select => |execution| execution,505            else => unreachable,506        };507        const relation = try self.relationPtr();508        var predicate_stack: [relation_mod.max_index_fields + 1]ast_mod.Predicate = undefined;509        var value_stack: [relation_mod.max_index_fields + 1]row.Value = undefined;510        const predicates = try predicate_mod.runtimePredicates(self, select.predicates, result_allocator, &predicate_stack, &value_stack);511        defer predicates.deinit(result_allocator);512        const access = try access_mod.runtimeSelectAccess(select, relation, select_execution.fields, predicates.values);513        var collected: std.ArrayList(result_mod.SortedRow) = .empty;514        errdefer {515            result_mod.freeSortedRowContents(result_allocator, collected.items);516            collected.deinit(result_allocator);517        }518        switch (access) {519            .rowid => |rowid_access| {520                const rowid = try predicate_mod.rowidFromValue(predicates.values[rowid_access.predicate_index]);521                if (rowid_access.operator == .eq) {522                    const bytes = (try reader.get(result_allocator, rowid)) orelse return try collected.toOwnedSlice(result_allocator);523                    defer result_allocator.free(bytes);524                    if (!try predicate_mod.rowBytesMatchPredicates(predicates.predicates, predicates.values, &relation.handle, rowid, bytes)) {525                        return try collected.toOwnedSlice(result_allocator);526                    }527                    try result_mod.appendSortedRow(result_allocator, &collected, select_execution.fields, select_execution.order_fields, rowid, bytes);528                    return try collected.toOwnedSlice(result_allocator);529                }530                var scan: sql.TableScan = undefined;531                try reader.scan(532                    &scan,533                    result_allocator,534                    predicate_mod.rowidStart(rowid_access.operator, rowid),535                    predicate_mod.rowidEnd(rowid_access.operator, rowid),536                );537                defer scan.deinit();538                while (try scan.next()) |entry| {539                    if (!predicate_mod.rowidMatches(entry.rowid, rowid_access.operator, rowid)) continue;540                    if (!try predicate_mod.rowBytesMatchPredicates(predicates.predicates, predicates.values, &relation.handle, entry.rowid, entry.bytes)) continue;541                    try result_mod.appendSortedRow(result_allocator, &collected, select_execution.fields, select_execution.order_fields, entry.rowid, entry.bytes);542                }543            },544            .index => |indexed| {545                var bound_storage: [relation_mod.max_index_fields]row.Value = undefined;546                const bound_values = predicate_mod.indexedPrefixValues(indexed, predicates.values, &bound_storage);547                var index_scan: sql.IndexScan = undefined;548                switch (indexed.operator) {549                    .eq => try reader.lookup(550                        &index_scan,551                        result_allocator,552                        indexed.index_slot,553                        bound_values,554                    ),555                    .lt, .lte, .gt, .gte => try reader.indexRange(556                        &index_scan,557                        result_allocator,558                        indexed.index_slot,559                        predicate_mod.indexedRangeStart(indexed, bound_values),560                        predicate_mod.indexedRangeEnd(indexed, bound_values),561                    ),562                }563                defer index_scan.deinit();564                const covered = access_mod.indexCoversPredicates(565                    &relation.handle,566                    indexed.index_slot,567                    select_execution.fields,568                    predicates.predicates,569                ) and access_mod.indexCoversOrder(570                    &relation.handle,571                    indexed.index_slot,572                    select.order,573                );574                try collectIndexRows(575                    result_allocator,576                    &collected,577                    reader,578                    &index_scan,579                    select_execution,580                    &relation.handle,581                    predicates,582                    indexed.index_slot,583                    covered,584                );585            },586            .covering => |index_slot| {587                var index_scan: sql.IndexScan = undefined;588                try reader.indexScan(&index_scan, result_allocator, index_slot, null, null);589                defer index_scan.deinit();590                try collectIndexRows(591                    result_allocator,592                    &collected,593                    reader,594                    &index_scan,595                    select_execution,596                    &relation.handle,597                    predicates,598                    index_slot,599                    true,600                );601            },602            .scan => {603                var scan: sql.TableScan = undefined;604                try reader.scan(&scan, result_allocator, null, null);605                defer scan.deinit();606                while (try scan.next()) |entry| {607                    if (!try predicate_mod.rowBytesMatchPredicates(predicates.predicates, predicates.values, &relation.handle, entry.rowid, entry.bytes)) continue;608                    try result_mod.appendSortedRow(result_allocator, &collected, select_execution.fields, select_execution.order_fields, entry.rowid, entry.bytes);609                }610            },611        }612        return try collected.toOwnedSlice(result_allocator);613    }614615    /// Appends a sorted row for each entry an open index scan yields. A covered scan builds the616    /// row from the decoded key, and an uncovered scan reads the table row.617    fn collectIndexRows(618        result_allocator: Allocator,619        collected: *std.ArrayList(result_mod.SortedRow),620        reader: *const plan.RelationRead,621        index_scan: *sql.IndexScan,622        select_execution: SelectExecution,623        handle: *const catalog_mod.RelationHandle,624        predicates: predicate_mod.RuntimePredicates,625        index_slot: usize,626        covered: bool,627    ) ast_mod.Error!void {628        while (try index_scan.next()) |entry| {629            if (covered) {630                var index_values: [catalog_mod.max_columns]row.Value = undefined;631                var index_scratch: [page.size]u8 = undefined;632                const values = try predicate_mod.coveredIndexValues(633                    predicates.predicates,634                    predicates.values,635                    handle,636                    index_slot,637                    entry,638                    &index_values,639                    &index_scratch,640                ) orelse continue;641                try result_mod.appendSortedIndexRow(642                    result_allocator,643                    collected,644                    select_execution.fields,645                    select_execution.order_fields,646                    handle,647                    index_slot,648                    values,649                    entry.rowid,650                );651                continue;652            }653            const bytes = (try reader.get(result_allocator, entry.rowid)) orelse continue;654            defer result_allocator.free(bytes);655            if (!try predicate_mod.rowBytesMatchPredicates(656                predicates.predicates,657                predicates.values,658                handle,659                entry.rowid,660                bytes,661            )) continue;662            try result_mod.appendSortedRow(663                result_allocator,664                collected,665                select_execution.fields,666                select_execution.order_fields,667                entry.rowid,668                bytes,669            );670        }671    }672673    fn openCursorOnce(674        self: *Prepared,675        target: *cursor_mod.Cursor,676        result_allocator: Allocator,677    ) ast_mod.Error!void {678        const phase = trace.scope("statement.cursor.open");679        defer phase.end();680681        const select = switch (self.statement) {682            .select => |select_statement| select_statement,683            else => return error.UnsupportedStatement,684        };685        const select_execution = switch (self.execution) {686            .select => |execution| execution,687            else => unreachable,688        };689        const relation = try self.relationPtr();690        var reader = try relation.execute();691        var reader_live = true;692        errdefer if (reader_live) reader.deinit();693        var owned_predicates = try predicate_mod.ownedPredicates(result_allocator, self, select.predicates);694        var owned_predicates_live = true;695        errdefer if (owned_predicates_live) owned_predicates.deinit(result_allocator);696        const access = try access_mod.runtimeSelectAccess(select, relation, select_execution.fields, owned_predicates.values);697        const sort_needed = select_execution.order_fields.len != 0 and698            (!orderIsRowidAscending(select_execution.order_fields) or699                access == .index or access == .covering);700        target.* = .{701            .allocator = result_allocator,702            .relation = relation,703            .reader = null,704            .fields = select_execution.fields,705            .access = access,706            .predicates = owned_predicates.predicates,707            .predicate_values = owned_predicates.values,708            .state = .empty,709            .window = if (sort_needed) .{} else try self.selectWindow(select),710        };711        owned_predicates_live = false;712        errdefer target.deinit();713        if (sort_needed) {714            const rows = try self.sortedSelectedRows(select, result_allocator, &reader);715            target.state = .{ .sorted = .{ .rows = rows } };716            reader.deinit();717            reader_live = false;718            return;719        }720        target.reader = reader;721        reader_live = false;722        switch (access) {723            .rowid => |rowid_access| {724                const rowid = try predicate_mod.rowidFromValue(725                    target.predicate_values[rowid_access.predicate_index],726                );727                if (rowid_access.operator == .eq) {728                    const bytes = (try reader.get(result_allocator, rowid)) orelse {729                        target.state = .empty;730                        return;731                    };732                    errdefer result_allocator.free(bytes);733                    if (!try predicate_mod.rowBytesMatchPredicates(734                        target.predicates,735                        target.predicate_values,736                        &relation.handle,737                        rowid,738                        bytes,739                    )) {740                        result_allocator.free(bytes);741                        target.state = .empty;742                        return;743                    }744                    if (select_execution.fields.len == 0) {745                        target.state = .{ .single = .{ .bytes = bytes } };746                        return;747                    }748                    const projected = try result_mod.selectedRow(result_allocator, select_execution.fields, rowid, bytes);749                    result_allocator.free(bytes);750                    target.state = .{ .single = .{ .bytes = projected } };751                    return;752                }753                target.state = .{ .rowid = undefined };754                errdefer target.state = .empty;755                try reader.scan(756                    &target.state.rowid,757                    result_allocator,758                    predicate_mod.rowidStart(rowid_access.operator, rowid),759                    predicate_mod.rowidEnd(rowid_access.operator, rowid),760                );761            },762            .index => |indexed| {763                var bound_storage: [relation_mod.max_index_fields]row.Value = undefined;764                const bound_values = predicate_mod.indexedPrefixValues(765                    indexed,766                    target.predicate_values,767                    &bound_storage,768                );769                const covered = access_mod.indexCoversPredicates(770                    &relation.handle,771                    indexed.index_slot,772                    select_execution.fields,773                    target.predicates,774                );775                target.state = .{ .index = .{ .scan = undefined, .covered = covered } };776                errdefer target.state = .empty;777                const index_scan = &target.state.index.scan;778                switch (indexed.operator) {779                    .eq => try reader.lookup(780                        index_scan,781                        result_allocator,782                        indexed.index_slot,783                        bound_values,784                    ),785                    .lt, .lte, .gt, .gte => try reader.indexRange(786                        index_scan,787                        result_allocator,788                        indexed.index_slot,789                        predicate_mod.indexedRangeStart(indexed, bound_values),790                        predicate_mod.indexedRangeEnd(indexed, bound_values),791                    ),792                }793            },794            .covering => unreachable,795            .scan => {796                target.state = .{ .scan = undefined };797                errdefer target.state = .empty;798                try reader.scan(&target.state.scan, result_allocator, null, null);799            },800        }801    }802803    fn selectWindow(self: *const Prepared, select: ast_mod.Select) ast_mod.Error!Window {804        var window = Window{};805        if (select.limit) |expression| window.remaining = try self.windowCount(expression);806        if (select.offset) |expression| window.skip = try self.windowCount(expression);807        return window;808    }809810    fn windowCount(self: *const Prepared, expression: ast_mod.Expression) ast_mod.Error!usize {811        return switch (self.expressionValue(expression)) {812            .integer => |integer| if (integer < 0) error.InvalidLimit else @intCast(integer),813            else => error.InvalidLimit,814        };815    }816817    fn rowidValue(self: *const Prepared, expression: ast_mod.Expression) ast_mod.Error!i64 {818        return try predicate_mod.rowidFromValue(self.expressionValue(expression));819    }820821    pub fn expressionValue(self: *const Prepared, expression: ast_mod.Expression) row.Value {822        return switch (expression) {823            .literal => |literal| literal,824            .parameter => |index| self.bindings[index].value(),825        };826    }827828    fn reprepare(self: *Prepared) ast_mod.Error!void {829        const phase = trace.scope("statement.reprepare");830        defer phase.end();831832        if (self.relation == null) return;833        var relation = try prepareStatementRelation(&self.catalog, self.allocator, self.statement, ast_mod.parameterShape(self.parameters), self.validation) orelse return;834        errdefer relation.deinit();835        var execution = try prepareExecution(self.allocator, self.statement, &relation);836        errdefer execution.deinit(self.allocator);837        self.execution.deinit(self.allocator);838        self.relation.?.deinit();839        self.relation = relation;840        self.execution = execution;841    }842843    fn relationPtr(self: *Prepared) ast_mod.Error!*plan.PreparedRelation {844        if (self.relation) |*relation| return relation;845        return error.UnsupportedStatement;846    }847};

1pub const PreparedStatement = statement.Prepared;