tiny.sql.statement

1pub const Analyze = struct {2    table: []const u8,3};

1pub const Assignment = struct {2    column: []const u8,3    value: Expression,4};

1pub const CreateIndex = struct {2    name: []const u8,3    table: []const u8,4    columns: [][]const u8,5};

1pub const CreateTable = struct {2    table: []const u8,3    columns: []catalog_mod.ColumnDefinition,4    indexes: []catalog_mod.IndexDefinition,56    pub fn relationDefinition(self: CreateTable) catalog_mod.RelationDefinition {7        return .{8            .name = self.table,9            .columns = self.columns,10            .indexes = self.indexes,11        };12    }13};

1pub const Delete = struct {2    table: []const u8,3    predicates: []Predicate,4};

1pub const DropTable = struct {2    table: []const u8,3};

1pub const Expression = union(enum) {2    literal: row.Value,3    parameter: usize,4};

1pub const Insert = struct {2    table: []const u8,3    columns: ?[][]const u8 = null,4    values: []Expression,5};

1pub const OrderKey = struct {2    column: PredicateColumn,3    descending: bool = false,4};

1pub const Parsed = struct {2    statement: Statement,3    parameters: []Parameter,45    pub fn deinit(self: *Parsed, allocator: Allocator) void {6        allocator.free(self.parameters);7        self.statement.deinit(allocator);8        self.* = undefined;9    }10};

1pub const Predicate = struct {2    column: PredicateColumn,3    operator: PredicateOperator,4    value: Expression,5};

1pub const PredicateColumn = union(enum) {2    rowid,3    field: []const u8,4};

1pub const PredicateOperator = enum {2    eq,3    lt,4    lte,5    gt,6    gte,7};

1pub const Projection = union(enum) {2    all,3    columns: [][]const u8,4};

1pub const Select = struct {2    table: []const u8,3    projection: Projection,4    predicates: []Predicate = &.{},5    order: []OrderKey = &.{},6    limit: ?Expression = null,7    offset: ?Expression = null,8};

1pub const Update = struct {2    table: []const u8,3    assignments: []Assignment,4    predicates: []Predicate,5};

1pub const ExecuteOptions = struct {2    durability: file.CommitDurability = .synced,3    validate_indexes: bool = false,4    session: ?*session_mod.DatabaseSession = null,5    write: ?*session_mod.DatabaseWrite = null,67    fn commit(self: ExecuteOptions) file.CommitOptions {8        return .{9            .durability = self.durability,10            .validate_indexes = self.validate_indexes,11        };12    }1314    fn databaseSession(self: ExecuteOptions) ast_mod.Error!*session_mod.DatabaseSession {15        if (self.write) |write| return write.session;16        return self.session orelse error.WriteSessionRequired;17    }18};

1pub const Rows = struct {2    allocator: Allocator,3    storage: RowStorage,4    cursor: usize = 0,56    pub fn deinit(self: *Rows) void {7        switch (self.storage) {8            .single => |bytes| if (bytes) |owned| self.allocator.free(owned),9            .many => |rows| {10                for (rows) |bytes| self.allocator.free(bytes);11                self.allocator.free(rows);12            },13        }14        self.* = undefined;15    }1617    pub fn next(self: *Rows) ?[]const u8 {18        switch (self.storage) {19            .single => |bytes| {20                if (self.cursor != 0) return null;21                self.cursor = 1;22                return bytes;23            },24            .many => |rows| {25                if (self.cursor >= rows.len) return null;26                const bytes = rows[self.cursor];27                self.cursor += 1;28                return bytes;29            },30        }31    }3233    pub fn count(self: *const Rows) usize {34        return switch (self.storage) {35            .single => |bytes| if (bytes == null) 0 else 1,36            .many => |rows| rows.len,37        };38    }39};

1pub fn columnIndex(definitions: []const catalog_mod.ColumnDefinition, name: []const u8) ?usize {2    for (definitions, 0..) |definition, index| {3        if (std.ascii.eqlIgnoreCase(definition.name, name)) return index;4    }5    return null;6}

1pub const Error =2    plan.Error ||3    session_mod.DatabaseError ||4    std.mem.Allocator.Error ||5    StatementError;

1pub const max_parameters: usize = 1024;

1pub fn prepare(catalog: *const catalog_mod.Catalog, allocator: Allocator, source: []const u8) ast_mod.Error!Prepared {2    return try prepareWithValidation(catalog, allocator, source, .content);3}

1pub fn prepareReadOnly(catalog: *const catalog_mod.Catalog, allocator: Allocator, source: []const u8) ast_mod.Error!Prepared {2    return try prepareWithValidation(catalog, allocator, source, .shape);3}

1pub fn parse(allocator: Allocator, source: []const u8) ast_mod.Error!ast_mod.Statement {2    var parsed = try parseWithParameters(allocator, source);3    errdefer parsed.deinit(allocator);4    allocator.free(parsed.parameters);5    return parsed.statement;6}

1pub fn parseWithParameters(allocator: Allocator, source: []const u8) ast_mod.Error!ast_mod.Parsed {2    const phase = trace.scope("statement.parse");3    defer phase.end();45    var parser = Parser{ .source = source };6    defer parser.parameters.deinit(allocator);7    const statement = try parser.statement(allocator);8    errdefer {9        var owned = statement;10        owned.deinit(allocator);11    }12    try parser.finish();13    return .{14        .statement = statement,15        .parameters = try parser.parameters.toOwnedSlice(allocator),16    };17}

1pub const statement = @import("statement/root.zig");

1const ast_mod = @import("ast.zig");2const parse_mod = @import("parse.zig");3const access_mod = @import("access.zig");4const result_mod = @import("result.zig");5const cursor_mod = @import("cursor.zig");6const execute_mod = @import("execute.zig");78pub const Error = ast_mod.Error;9pub const max_parameters = ast_mod.max_parameters;10pub const Parameter = ast_mod.Parameter;11pub const Expression = ast_mod.Expression;12pub const Insert = ast_mod.Insert;13pub const Projection = ast_mod.Projection;14pub const PredicateColumn = ast_mod.PredicateColumn;15pub const PredicateOperator = ast_mod.PredicateOperator;16pub const Predicate = ast_mod.Predicate;17pub const OrderKey = ast_mod.OrderKey;18pub const Select = ast_mod.Select;19pub const Assignment = ast_mod.Assignment;20pub const Update = ast_mod.Update;21pub const Delete = ast_mod.Delete;22pub const CreateTable = ast_mod.CreateTable;23pub const CreateIndex = ast_mod.CreateIndex;24pub const Analyze = ast_mod.Analyze;25pub const DropTable = ast_mod.DropTable;26pub const Statement = ast_mod.Statement;27pub const Parsed = ast_mod.Parsed;28pub const parse = parse_mod.parse;29pub const parseWithParameters = parse_mod.parseWithParameters;30pub const Rows = result_mod.Rows;31pub const Result = result_mod.Result;32pub const Cursor = cursor_mod.Cursor;33pub const ExecuteOptions = execute_mod.ExecuteOptions;34pub const Prepared = execute_mod.Prepared;35pub const prepare = execute_mod.prepare;36pub const prepareReadOnly = execute_mod.prepareReadOnly;37pub const columnIndex = access_mod.columnIndex;