rado 0.1.39 → 0.1.41

package/dist/driver/better-sqlite3.d.ts

@@ -1,14 +1,14 @@
 import type { Database } from 'better-sqlite3';
 import { Driver } from '../lib/Driver';
 import { SchemaInstructions } from '../lib/Schema';
-import { CompiledStatement } from '../lib/Statement';
+import { Statement } from '../lib/Statement';
 import { SqliteSchema } from '../sqlite/SqliteSchema';
 export declare class BetterSqlite3Driver extends Driver.Sync {
     db: Database;
     tableData: (tableName: string) => Array<SqliteSchema.Column>;
     indexData: (tableName: string) => Array<SqliteSchema.Index>;
     constructor(db: Database);
-    prepareStatement(stmt: CompiledStatement): Driver.Sync.PreparedStatement;
+    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;
 }

package/dist/driver/better-sqlite3.js

@@ -6,6 +6,9 @@ var PreparedStatement = class {
   constructor(stmt) {
     this.stmt = stmt;
   }
+  iterate(params = []) {
+    return this.stmt.iterate(...params);
+  }
   all(params = []) {
     return this.stmt.all(...params);
   }

package/dist/driver/bun-sqlite.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="bun-types" />
+import type { Database } from 'bun:sqlite';
+import { Driver } from '../lib/Driver';
+import { SchemaInstructions } from '../lib/Schema';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class BunSqliteDriver extends Driver.Sync {
+    db: Database;
+    tableData: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData: (tableName: string) => Array<SqliteSchema.Index>;
+    lastChanges: () => {
+        rowsAffected: number;
+    };
+    constructor(db: Database);
+    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+}
+export declare function connect(db: Database): BunSqliteDriver;

package/dist/driver/bun-sqlite.js

@@ -0,0 +1,64 @@
+// src/driver/bun-sqlite.ts
+import { Cursor } from "../lib/Cursor.js";
+import { Driver } from "../lib/Driver.js";
+import { Query } from "../lib/Query.js";
+import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
+import { SqliteSchema } from "../sqlite/SqliteSchema.js";
+var PreparedStatement = class {
+  constructor(lastChanges, stmt) {
+    this.lastChanges = lastChanges;
+    this.stmt = stmt;
+  }
+  *iterate(params = []) {
+    for (const row of this.stmt.all(...params))
+      yield row;
+  }
+  all(params = []) {
+    return this.stmt.all(...params);
+  }
+  run(params = []) {
+    this.stmt.run(...params);
+    return this.lastChanges();
+  }
+  get(params = []) {
+    return this.stmt.get(...params);
+  }
+  execute(params = []) {
+    this.stmt.run(...params);
+  }
+};
+var BunSqliteDriver = class extends Driver.Sync {
+  constructor(db) {
+    super(new SqliteFormatter());
+    this.db = db;
+    this.tableData = this.prepare(SqliteSchema.tableData);
+    this.indexData = this.prepare(SqliteSchema.indexData);
+    this.lastChanges = this.prepare(() => {
+      return new Cursor.SelectSingle(
+        Query.Raw({
+          expectedReturn: "row",
+          strings: ["SELECT changes() as rowsAffected"],
+          params: []
+        })
+      );
+    });
+  }
+  tableData;
+  indexData;
+  lastChanges;
+  prepareStatement(stmt) {
+    return new PreparedStatement(this.lastChanges, this.db.prepare(stmt.sql));
+  }
+  schemaInstructions(tableName) {
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+};
+function connect(db) {
+  return new BunSqliteDriver(db);
+}
+export {
+  BunSqliteDriver,
+  connect
+};

package/dist/driver/sql.js.d.ts

@@ -1,14 +1,14 @@
 import type { Database } from 'sql.js';
 import { Driver } from '../lib/Driver';
 import { SchemaInstructions } from '../lib/Schema';
-import { CompiledStatement } from '../lib/Statement';
+import { Statement } from '../lib/Statement';
 import { SqliteSchema } from '../sqlite/SqliteSchema';
 export declare class SqlJsDriver extends Driver.Sync {
     db: Database;
     tableData: (tableName: string) => Array<SqliteSchema.Column>;
     indexData: (tableName: string) => Array<SqliteSchema.Index>;
     constructor(db: Database);
-    prepareStatement(stmt: CompiledStatement): Driver.Sync.PreparedStatement;
+    prepareStatement(stmt: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;
 }

package/dist/driver/sql.js.js

@@ -3,19 +3,25 @@ import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var PreparedStatement = class {
-  constructor(db, stmt) {
+  constructor(db, stmt, discardAfter) {
     this.db = db;
     this.stmt = stmt;
+    this.discardAfter = discardAfter;
   }
-  all(params) {
+  *iterate(params) {
     this.stmt.bind(params);
-    const res = [];
     while (this.stmt.step())
-      res.push(this.stmt.getAsObject());
-    return res;
+      yield this.stmt.getAsObject();
+    if (this.discardAfter)
+      this.stmt.free();
+  }
+  all(params) {
+    return Array.from(this.iterate(params));
   }
   run(params) {
     this.stmt.run(params);
+    if (this.discardAfter)
+      this.stmt.free();
     return { rowsAffected: this.db.getRowsModified() };
   }
   get(params) {
@@ -23,6 +29,8 @@ var PreparedStatement = class {
   }
   execute(params) {
     this.stmt.run(params);
+    if (this.discardAfter)
+      this.stmt.free();
   }
 };
 var SqlJsDriver = class extends Driver.Sync {
@@ -34,8 +42,12 @@ var SqlJsDriver = class extends Driver.Sync {
   }
   tableData;
   indexData;
-  prepareStatement(stmt) {
-    return new PreparedStatement(this.db, this.db.prepare(stmt.sql));
+  prepareStatement(stmt, discardAfter) {
+    return new PreparedStatement(
+      this.db,
+      this.db.prepare(stmt.sql),
+      discardAfter
+    );
   }
   schemaInstructions(tableName) {
     const columnData = this.tableData(tableName);

package/dist/driver/sqlite3.d.ts

@@ -2,7 +2,7 @@ import type { Database } from 'sqlite3';
 import { Driver } from '../lib/Driver';
 import { Query } from '../lib/Query';
 import { SchemaInstructions } from '../lib/Schema';
-import { CompiledStatement } from '../lib/Statement';
+import { Statement } from '../lib/Statement';
 import { SqliteSchema } from '../sqlite/SqliteSchema';
 export declare class Sqlite3Driver extends Driver.Async {
     private db;
@@ -11,7 +11,7 @@ export declare class Sqlite3Driver extends Driver.Async {
     indexData: (tableName: string) => Promise<Array<SqliteSchema.Index>>;
     constructor(db: Database);
     executeQuery<T>(query: Query<T>, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<T>;
-    prepareStatement(stmt: CompiledStatement): Driver.Async.PreparedStatement;
+    prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     isolate(): [connection: Driver.Async, release: () => Promise<void>];
 }

package/dist/driver/sqlite3.js

@@ -6,6 +6,37 @@ var PreparedStatement = class {
   constructor(stmt) {
     this.stmt = stmt;
   }
+  async *iterate(params) {
+    let rows = [], done = false, error;
+    let resolve;
+    let promise = new Promise((r) => resolve = r);
+    this.stmt.each(
+      params,
+      (err, row) => {
+        if (err)
+          error = err;
+        else
+          rows.push(row);
+        resolve();
+      },
+      () => {
+        done = true;
+        resolve();
+      }
+    );
+    while (true) {
+      const mustWait = !(rows.length || error || done);
+      if (mustWait)
+        await promise;
+      promise = new Promise((r) => resolve = r);
+      if (error)
+        throw error;
+      if (rows.length)
+        yield rows.shift();
+      if (done)
+        return;
+    }
+  }
   all(params) {
     return new Promise((resolve, reject) => {
       this.stmt.all(params, (err, rows) => {

package/dist/lib/Column.d.ts

@@ -27,7 +27,7 @@ export declare class Column<T> {
     nullable(): Column<T | null>;
     autoIncrement(): Column<Column.IsOptional<T>>;
     primaryKey<K extends string>(): Column<Column.IsPrimary<T, K>>;
-    references<X extends T>(column: Expr<X>): Column<X>;
+    references<X extends T>(column: Expr<X> | (() => Expr<X>)): Column<X>;
     unique(): Column<T>;
     defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
 }

package/dist/lib/Column.js

@@ -25,7 +25,12 @@ var Column = class {
     return new Column({ ...this.data, primaryKey: true });
   }
   references(column2) {
-    return new Column({ ...this.data, references: ExprData.create(column2) });
+    return new Column({
+      ...this.data,
+      get references() {
+        return ExprData.create(typeof column2 === "function" ? column2() : column2);
+      }
+    });
   }
   unique() {
     return new Column({ ...this.data, unique: true });

package/dist/lib/Cursor.d.ts

@@ -11,8 +11,8 @@ export declare class Cursor<T> {
     constructor(query: Query<T>);
     static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
     query(): Query<T>;
-    run(driver: Driver.Sync): T;
-    run(driver: Driver.Async): Promise<T>;
+    on(driver: Driver.Sync): T;
+    on(driver: Driver.Async): Promise<T>;
     toJSON(): Query<T>;
 }
 export declare namespace Cursor {
@@ -27,7 +27,7 @@ export declare namespace Cursor {
     class Update<T> extends Cursor<{
         rowsAffected: number;
     }> {
-        query: () => Query.Update;
+        query(): Query.Update;
         set(set: UpdateSet<T>): Update<T>;
         where(...where: Array<EV<boolean>>): Update<T>;
         take(limit: number | undefined): Update<T>;

package/dist/lib/Cursor.js

@@ -21,7 +21,7 @@ var Cursor = class {
   query() {
     throw new Error("Not implemented");
   }
-  run(driver) {
+  on(driver) {
     return driver.executeQuery(this.query());
   }
   toJSON() {
@@ -54,6 +54,9 @@ function addWhere(query, where) {
   }
   Cursor2.Delete = Delete;
   class Update extends Cursor2 {
+    query() {
+      return super.query();
+    }
     set(set) {
       return new Update({ ...this.query(), set });
     }

package/dist/lib/Driver.d.ts

@@ -3,7 +3,7 @@ import { Expr } from './Expr';
 import { Formatter } from './Formatter';
 import { Query } from './Query';
 import { SchemaInstructions } from './Schema';
-import { CompiledStatement } from './Statement';
+import { Statement } from './Statement';
 import { Table } from './Table';
 declare class Callable extends Function {
     constructor(fn: Function);
@@ -11,7 +11,7 @@ declare class Callable extends Function {
 declare abstract class DriverBase extends Callable {
     formatter: Formatter;
     constructor(formatter: Formatter);
-    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, CompiledStatement];
+    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];
     all(...args: Array<any>): any;
     get(...args: Array<any>): any;
     sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
@@ -30,7 +30,7 @@ interface SyncDriver {
 }
 declare abstract class SyncDriver extends DriverBase {
     transactionId: number;
-    abstract prepareStatement(stmt: CompiledStatement): SyncPreparedStatement;
+    abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
     abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
     prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
     migrateSchema(...tables: Array<Table<any>>): unknown;
@@ -41,6 +41,7 @@ declare abstract class SyncDriver extends DriverBase {
     get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
     get<T>(cursor: Cursor<T>): T;
     get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+    iterate<T>(cursor: Cursor.SelectMultiple<T>): Iterable<T>;
     transaction<T>(run: (query: SyncDriver) => T): T;
     toAsync(): SyncWrapper;
 }
@@ -48,6 +49,7 @@ interface SyncPreparedStatement {
     run(params?: Array<any>): {
         rowsAffected: number;
     };
+    iterate<T>(params?: Array<any>): Iterable<T>;
     all<T>(params?: Array<any>): Array<T>;
     get<T>(params?: Array<any>): T;
     execute(params?: Array<any>): void;
@@ -60,7 +62,7 @@ interface AsyncDriver {
 declare abstract class AsyncDriver extends DriverBase {
     transactionId: number;
     abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-    abstract prepareStatement(stmt: CompiledStatement): AsyncPreparedStatement;
+    abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
     migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
@@ -71,6 +73,7 @@ declare abstract class AsyncDriver extends DriverBase {
     get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
     get<T>(cursor: Cursor<T>): Promise<T>;
     get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+    iterate<T>(cursor: Cursor.SelectMultiple<T>): AsyncIterable<T>;
     transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
 }
 declare class SyncWrapper extends AsyncDriver {
@@ -78,7 +81,7 @@ declare class SyncWrapper extends AsyncDriver {
     lock: Promise<void> | undefined;
     constructor(sync: SyncDriver);
     executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    prepareStatement(stmt: CompiledStatement): AsyncPreparedStatement;
+    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
     schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
     isolate(): [connection: AsyncDriver, release: () => Promise<void>];
 }
@@ -86,6 +89,7 @@ interface AsyncPreparedStatement {
     run(params?: Array<any>): Promise<{
         rowsAffected: number;
     }>;
+    iterate<T>(params?: Array<any>): AsyncIterable<T>;
     all<T>(params?: Array<any>): Promise<Array<T>>;
     get<T>(params?: Array<any>): Promise<T>;
     execute(params?: Array<any>): Promise<void>;

package/dist/lib/Driver.js

@@ -70,7 +70,7 @@ var SyncDriver = class extends DriverBase {
   transactionId = 0;
   prepare(create) {
     const [query, compiled] = this.compile(create);
-    const prepared = this.prepareStatement(compiled);
+    const prepared = this.prepareStatement(compiled, false);
     return (...params) => {
       const namedParams = Object.fromEntries(
         params.map((value, i) => [`p${i}`, value])
@@ -109,7 +109,7 @@ var SyncDriver = class extends DriverBase {
         });
       default:
         const compiled = stmt ? void 0 : this.formatter.compile(query);
-        stmt = stmt || this.prepareStatement(compiled);
+        stmt = stmt || this.prepareStatement(compiled, true);
         params = params || compiled.params();
         if ("selection" in query) {
           const res = stmt.all(params).map((row) => JSON.parse(row.result).result);
@@ -141,6 +141,15 @@ var SyncDriver = class extends DriverBase {
   get(...args) {
     return super.get(...args);
   }
+  *iterate(cursor) {
+    const stmt = this.prepareStatement(
+      this.formatter.compile(cursor.query()),
+      true
+    );
+    for (const row of stmt.iterate()) {
+      yield JSON.parse(row.result).result;
+    }
+  }
   transaction(run) {
     const id = `t${this.transactionId++}`;
     this.executeQuery(
@@ -167,7 +176,7 @@ var AsyncDriver = class extends DriverBase {
   transactionId = 0;
   prepare(create) {
     const [query, compiled] = this.compile(create);
-    const prepared = this.prepareStatement(compiled);
+    const prepared = this.prepareStatement(compiled, false);
     return (...params) => {
       const namedParams = Object.fromEntries(
         params.map((value, i) => [`p${i}`, value])
@@ -206,7 +215,7 @@ var AsyncDriver = class extends DriverBase {
         });
       default:
         const compiled = stmt ? void 0 : this.formatter.compile(query);
-        stmt = stmt || this.prepareStatement(compiled);
+        stmt = stmt || this.prepareStatement(compiled, true);
         params = params || compiled.params();
         if ("selection" in query) {
           const res = (await stmt.all(params)).map(
@@ -240,6 +249,15 @@ var AsyncDriver = class extends DriverBase {
   get(...args) {
     return super.get(...args);
   }
+  async *iterate(cursor) {
+    const stmt = this.prepareStatement(
+      this.formatter.compile(cursor.query()),
+      true
+    );
+    for await (const row of stmt.iterate()) {
+      yield JSON.parse(row.result).result;
+    }
+  }
   async transaction(run) {
     const id = `t${this.transactionId++}`;
     const [connection, release] = this.isolate();
@@ -266,6 +284,10 @@ var SyncPreparedStatementWrapper = class {
   constructor(stmt) {
     this.stmt = stmt;
   }
+  async *iterate(params) {
+    for (const row of this.stmt.iterate(params))
+      yield row;
+  }
   async run(params) {
     return this.stmt.run(params);
   }
@@ -289,8 +311,10 @@ var SyncWrapper = class extends AsyncDriver {
     await this.lock;
     return super.executeQuery(query, stmt, params);
   }
-  prepareStatement(stmt) {
-    return new SyncPreparedStatementWrapper(this.sync.prepareStatement(stmt));
+  prepareStatement(stmt, discardAfter) {
+    return new SyncPreparedStatementWrapper(
+      this.sync.prepareStatement(stmt, discardAfter)
+    );
   }
   async schemaInstructions(tableName) {
     return this.sync.schemaInstructions(tableName);

package/dist/lib/Formatter.d.ts

@@ -19,15 +19,16 @@ export interface FormatContext {
     /** Inline all parameters */
     forceInline?: boolean;
     formatAsJson?: boolean;
-    formatSubject?: (mkSubject: () => void) => void;
+    topLevel?: boolean;
 }
+type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
 export declare abstract class Formatter implements Sanitizer {
     constructor();
     abstract escapeValue(value: any): string;
     abstract escapeIdentifier(ident: string): string;
     abstract formatParamValue(paramValue: any): any;
     abstract formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
-    compile<T>(query: Query<T>, formatInline?: boolean): import("./Statement").CompiledStatement;
+    compile<T>(query: Query<T>): Statement;
     format<T>(ctx: FormatContext, query: Query<T>): Statement;
     formatSelect(ctx: FormatContext, query: Query.Select): Statement;
     formatInsert(ctx: FormatContext, query: Query.Insert): Statement;
@@ -51,7 +52,7 @@ export declare abstract class Formatter implements Sanitizer {
     formatGroupBy(ctx: FormatContext, groupBy: Array<ExprData> | undefined): Statement;
     formatOrderBy(ctx: FormatContext, orderBy: Array<OrderBy> | undefined): Statement;
     formatLimit(ctx: FormatContext, { limit, offset, singleResult }: Query.QueryBase): Statement;
-    formatSelection(ctx: FormatContext, selection: ExprData): Statement;
+    formatSelection(ctx: FormatContext, selection: ExprData, formatSubject?: FormatSubject): Statement;
     formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
     formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
     formatIn(ctx: FormatContext, expr: ExprData): Statement;
@@ -62,3 +63,4 @@ export declare abstract class Formatter implements Sanitizer {
     formatValue(ctx: FormatContext, rawValue: any): Statement;
     formatExpr(ctx: FormatContext, expr: ExprData): Statement;
 }
+export {};

package/dist/lib/Formatter.js

@@ -31,23 +31,17 @@ var joins = {
   left: "left",
   inner: "inner"
 };
+function formatAsResultObject(stmt, mkSubject) {
+  stmt.raw("json_object('result', ");
+  mkSubject();
+  stmt.raw(")");
+}
 var Formatter = class {
   constructor() {
   }
-  compile(query, formatInline = false) {
-    const stmt = new Statement();
-    const result = this.format(
-      {
-        stmt,
-        formatSubject: (mkSubject) => {
-          stmt.raw("json_object('result', ");
-          mkSubject();
-          stmt.raw(")");
-        },
-        nameResult: "result"
-      },
-      query
-    ).compile(this, formatInline);
+  compile(query) {
+    const stmt = new Statement(this);
+    const result = this.format({ stmt, topLevel: true }, query);
     return result;
   }
   format(ctx, query) {
@@ -77,9 +71,13 @@ var Formatter = class {
     }
   }
   formatSelect(ctx, query) {
-    const { stmt } = ctx;
+    const { stmt, topLevel } = ctx;
     stmt.add("SELECT").space();
-    this.formatSelection(ctx, query.selection);
+    this.formatSelection(
+      { ...ctx, topLevel: false },
+      query.selection,
+      topLevel ? formatAsResultObject : void 0
+    );
     stmt.addLine("FROM").space();
     this.formatTarget(ctx, query.from);
     this.formatWhere(ctx, query.where);
@@ -102,7 +100,7 @@ var Formatter = class {
       this.formatInsertRow(ctx, query.into.columns, row);
     if (query.selection) {
       stmt.add("RETURNING").space();
-      this.formatSelection(ctx, query.selection);
+      this.formatSelection(ctx, query.selection, formatAsResultObject);
     }
     return stmt;
   }
@@ -341,7 +339,7 @@ var Formatter = class {
     const { stmt } = ctx;
     if (!expr)
       return stmt;
-    stmt.newline().raw("WHERE");
+    stmt.newline().raw("WHERE").space();
     this.formatExprValue(ctx, expr);
     return stmt;
   }
@@ -382,22 +380,20 @@ var Formatter = class {
       stmt.raw("OFFSET").addValue(offset);
     return stmt;
   }
-  formatSelection(ctx, selection) {
-    const { stmt, formatSubject } = ctx;
+  formatSelection(ctx, selection, formatSubject) {
+    const { stmt } = ctx;
     const mkSubject = () => this.formatExpr(
       {
         ...ctx,
-        formatSubject: void 0,
         formatAsJson: true
       },
       selection
     );
     if (formatSubject)
-      formatSubject(mkSubject);
+      formatSubject(stmt, mkSubject);
     else
       mkSubject();
-    if (ctx.nameResult)
-      stmt.add("AS").addIdentifier(ctx.nameResult);
+    stmt.add("AS").addIdentifier("result");
     return stmt;
   }
   formatExprJson(ctx, expr) {
@@ -562,11 +558,11 @@ var Formatter = class {
         }
         if (expr.query.singleResult) {
           stmt.raw("json").openParenthesis().openParenthesis();
-          this.format({ ...ctx, nameResult: "result" }, expr.query);
+          this.format(ctx, expr.query);
           return stmt.closeParenthesis().closeParenthesis();
         }
         stmt.openParenthesis().raw("SELECT json_group_array(json(result))").newline().raw("FROM").openParenthesis();
-        this.format({ ...ctx, nameResult: "result" }, expr.query);
+        this.format(ctx, expr.query);
         return stmt.closeParenthesis().closeParenthesis();
       case ExprType.Row:
         switch (expr.target.type) {
@@ -576,17 +572,14 @@ var Formatter = class {
               throw new Error(`Cannot select empty target`);
             if (ctx.tableAsExpr)
               return stmt.identifier(table.alias || table.name);
-            return this.formatExpr(
-              ctx,
-              ExprData.Record(
-                Object.fromEntries(
-                  Object.entries(table.columns).map(([key, column]) => [
-                    key,
-                    ExprData.Field(ExprData.Row(expr.target), column.name)
-                  ])
-                )
-              )
-            );
+            stmt.identifier("json_object");
+            for (const [key, column] of stmt.call(
+              Object.entries(table.columns)
+            )) {
+              this.formatString(ctx, key).raw(", ");
+              this.formatField(ctx, expr, column.name);
+            }
+            return stmt;
           case TargetType.Query:
           case TargetType.Expr:
             return stmt.identifier(expr.target.alias).raw(".value");

package/dist/lib/Id.d.ts

@@ -1,3 +1,3 @@
-export type Id<T extends {
+export type Id<T> = T extends {
     id: any;
-}> = T['id'];
+} ? T['id'] : never;

package/dist/lib/Schema.js

@@ -29,9 +29,9 @@ var Schema;
         res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
       } else {
         const { sql: instruction } = formatter.formatColumn(
-          { stmt: new Statement() },
+          { stmt: new Statement(formatter) },
           { ...schemaCol, references: void 0 }
-        ).compile(formatter);
+        );
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
           res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
         }
@@ -49,10 +49,9 @@ var Schema;
       } else if (!schemaIndex) {
         res.unshift(Query.DropIndex({ table: schema, name: indexName }));
       } else {
-        const { sql: instruction } = formatter.formatCreateIndex(
-          { stmt: new Statement() },
+        const { sql: instruction } = formatter.compile(
           Query.CreateIndex({ table: schema, index: schemaIndex })
-        ).compile(formatter);
+        );
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
           res.unshift(Query.DropIndex({ table: schema, name: indexName }));
           res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));

package/dist/lib/Statement.d.ts

@@ -1,39 +1,17 @@
 import { ParamData } from './Param';
 import { Sanitizer } from './Sanitizer';
-declare enum TokenType {
-    Raw = "Raw",
-    Identifier = "Identifier",
-    Value = "Value",
-    Param = "Param",
-    Indent = "Indent",
-    Dedent = "Dedent"
-}
-declare class Token {
-    type: TokenType;
-    data: any;
-    constructor(type: TokenType, data: any);
-    static Raw(data: string): Token;
-    static Indent(): Token;
-    static Dedent(): Token;
-    static Identifier(data: string): Token;
-    static Value(data: any): Token;
-    static Param(name: string): Token;
-}
-export interface CompileOptions {
-    formatInline?: boolean;
-    spaces?: number;
-}
 export declare class Statement {
-    tokens: Array<Token>;
-    constructor(tokens?: Array<Token>);
-    concat(...tokens: Array<Token>): this;
-    static tag(strings: ReadonlyArray<string>, params: Array<Statement>): Statement;
+    sanitizer: Sanitizer;
+    sql: string;
+    private paramData;
+    currentIndent: string;
+    constructor(sanitizer: Sanitizer, sql?: string, paramData?: Array<ParamData>);
     space(): this;
     add(addition: undefined | string): this;
     addLine(addition: undefined | string): this;
     indent(): this;
     dedent(): this;
-    newline(ignore?: boolean): this;
+    newline(): this;
     identifier(name: string): this;
     addIdentifier(name: string): this;
     value(value: any): this;
@@ -46,14 +24,6 @@ export declare class Statement {
     call<T>(parts: Array<T>, separator?: string): Generator<T, this | undefined, unknown>;
     separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
     isEmpty(): boolean;
-    compile(sanitizer: Sanitizer, formatInline?: boolean): CompiledStatement;
-}
-export declare class CompiledStatement {
-    sanitizer: Sanitizer;
-    sql: string;
-    private paramData;
-    constructor(sanitizer: Sanitizer, sql: string, paramData: Array<ParamData>);
     params(input?: Record<string, any>): Array<any>;
     toString(): string;
 }
-export {};

package/dist/lib/Statement.js

@@ -1,50 +1,18 @@
 // src/lib/Statement.ts
 import { ParamData, ParamType } from "./Param.js";
-var Token = class {
-  constructor(type, data) {
-    this.type = type;
-    this.data = data;
-  }
-  static Raw(data) {
-    return new Token("Raw" /* Raw */, data);
-  }
-  static Indent() {
-    return new Token("Indent" /* Indent */, null);
-  }
-  static Dedent() {
-    return new Token("Dedent" /* Dedent */, null);
-  }
-  static Identifier(data) {
-    return new Token("Identifier" /* Identifier */, data);
-  }
-  static Value(data) {
-    return new Token("Value" /* Value */, data);
-  }
-  static Param(name) {
-    return new Token("Param" /* Param */, name);
-  }
-};
 var SEPARATE = ", ";
 var WHITESPACE = " ";
 var NEWLINE = "\n";
+var INSERT_PARAM = "?";
 var Statement = class {
-  constructor(tokens = []) {
-    this.tokens = tokens;
-  }
-  concat(...tokens) {
-    this.tokens.push(...tokens);
-    return this;
-  }
-  static tag(strings, params) {
-    return new Statement(
-      strings.flatMap((s, i) => {
-        const param = params[i];
-        return [Token.Raw(s)].concat(param ? param.tokens : []);
-      })
-    );
+  constructor(sanitizer, sql = "", paramData = []) {
+    this.sanitizer = sanitizer;
+    this.sql = sql;
+    this.paramData = paramData;
   }
+  currentIndent = "";
   space() {
-    if (this.tokens.length === 0)
+    if (this.sql === "")
       return this;
     return this.raw(WHITESPACE);
   }
@@ -59,30 +27,32 @@ var Statement = class {
     return this.newline().add(addition);
   }
   indent() {
-    return this.concat(Token.Indent());
+    this.currentIndent = this.currentIndent + "  ";
+    return this;
   }
   dedent() {
-    return this.concat(Token.Dedent());
+    this.currentIndent = this.currentIndent.slice(0, -2);
+    return this;
   }
-  newline(ignore = false) {
-    if (ignore)
-      return this;
-    return this.raw(NEWLINE);
+  newline() {
+    return this.raw(NEWLINE + this.currentIndent);
   }
   identifier(name) {
-    return this.concat(Token.Identifier(name));
+    return this.raw(this.sanitizer.escapeIdentifier(name));
   }
   addIdentifier(name) {
     return this.space().identifier(name);
   }
   value(value) {
-    return this.concat(Token.Value(value));
+    this.paramData.push(ParamData.Value(value));
+    return this.raw(INSERT_PARAM);
   }
   addValue(value) {
     return this.space().value(value);
   }
   param(name) {
-    return this.concat(Token.Param(name));
+    this.paramData.push(ParamData.Named(name));
+    return this.raw(INSERT_PARAM);
   }
   addParam(name) {
     return this.space().param(name);
@@ -90,7 +60,8 @@ var Statement = class {
   raw(query) {
     if (!query)
       return this;
-    return this.concat(Token.Raw(query));
+    this.sql += query;
+    return this;
   }
   openParenthesis() {
     return this.raw("(").indent().newline();
@@ -113,49 +84,7 @@ var Statement = class {
     }
   }
   isEmpty() {
-    return this.tokens.length === 0 || this.tokens.length === 1 && this.tokens[0].type === "Raw" /* Raw */ && this.tokens[0].data === "";
-  }
-  compile(sanitizer, formatInline = false) {
-    let sql = "", paramData = [], indent = "";
-    for (const token of this.tokens) {
-      switch (token.type) {
-        case "Raw" /* Raw */:
-          if (token.data === NEWLINE)
-            sql += NEWLINE + indent;
-          else
-            sql += token.data;
-          break;
-        case "Identifier" /* Identifier */:
-          sql += sanitizer.escapeIdentifier(token.data);
-          break;
-        case "Value" /* Value */:
-          if (formatInline) {
-            sql += sanitizer.escapeValue(token.data);
-          } else {
-            sql += "?";
-            paramData.push(ParamData.Value(token.data));
-          }
-          break;
-        case "Param" /* Param */:
-          sql += "?";
-          paramData.push(ParamData.Named(token.data));
-          break;
-        case "Indent" /* Indent */:
-          indent += "  ";
-          break;
-        case "Dedent" /* Dedent */:
-          indent = indent.slice(0, -2);
-          break;
-      }
-    }
-    return new CompiledStatement(sanitizer, sql, paramData);
-  }
-};
-var CompiledStatement = class {
-  constructor(sanitizer, sql, paramData) {
-    this.sanitizer = sanitizer;
-    this.sql = sql;
-    this.paramData = paramData;
+    return this.sql === "";
   }
   params(input) {
     return this.paramData.map((param) => {
@@ -172,6 +101,5 @@ var CompiledStatement = class {
   }
 };
 export {
-  CompiledStatement,
   Statement
 };

package/dist/sqlite/SqliteFormatter.js

@@ -1,17 +1,12 @@
 // src/sqlite/SqliteFormatter.ts
 import { ExprType } from "../lib/Expr.js";
 import { Formatter } from "../lib/Formatter.js";
-function escapeWithin(input, outer) {
-  let buf = outer;
-  for (const char of input) {
-    if (char === outer)
-      buf += outer + outer;
-    else
-      buf += char;
-  }
-  buf += outer;
-  return buf;
-}
+var BACKTICK = "`";
+var ESCAPE_BACKTICK = "``";
+var SINGLE_QUOTE = "'";
+var ESCAPE_SINGLE_QUOTE = "''";
+var MATCH_BACKTICK = /`/g;
+var MATCH_SINGLE_QUOTE = /'/g;
 var SqliteFormatter = class extends Formatter {
   formatParamValue(paramValue) {
     if (paramValue === null || paramValue === void 0)
@@ -26,7 +21,7 @@ var SqliteFormatter = class extends Formatter {
   }
   escapeValue(value) {
     if (value === null || value === void 0)
-      return "null";
+      return "NULL";
     if (typeof value === "boolean")
       return value ? "1" : "0";
     if (typeof value === "number")
@@ -36,10 +31,10 @@ var SqliteFormatter = class extends Formatter {
     return "json(" + this.escapeString(JSON.stringify(value)) + ")";
   }
   escapeIdentifier(input) {
-    return escapeWithin(input, "`");
+    return BACKTICK + input.replace(MATCH_BACKTICK, ESCAPE_BACKTICK) + BACKTICK;
   }
   escapeString(input) {
-    return escapeWithin(input, "'");
+    return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
   }
   formatAccess(ctx, mkSubject, field) {
     const { stmt, formatAsJson } = ctx;

package/dist/sqlite/SqliteSchema.js

@@ -25,7 +25,7 @@ var SqliteSchema;
   }
   SqliteSchema2.createInstructions = createInstructions;
   function columnInstruction(column) {
-    const stmt = new Statement();
+    const stmt = new Statement(formatter);
     stmt.identifier(column.name).add(column.type);
     if (column.pk === 1)
       stmt.add("PRIMARY KEY");
@@ -34,7 +34,7 @@ var SqliteSchema;
     if (column.dflt_value !== null) {
       stmt.add("DEFAULT").space().openParenthesis().raw(column.dflt_value).closeParenthesis();
     }
-    return [column.name, stmt.compile(formatter).sql];
+    return [column.name, stmt.sql];
   }
   SqliteSchema2.columnInstruction = columnInstruction;
   function indexInstruction(index) {

package/package.json

@@ -1,26 +1,22 @@
 {
   "name": "rado",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "license": "MIT",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
-    "./*": "./dist/*.js"
+    "./*": "./dist/*.js",
+    "./driver/bun:sqlite": "./dist/driver/bun-sqlite.js"
   },
   "files": [
     "dist"
   ],
   "sideEffects": false,
-  "typesVersions": {
-    "*": {
-      "*": [
-        "./dist/*"
-      ]
-    }
-  },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsx build.ts",
     "test": "tsx test",
+    "test:bun": "bun test/index.ts --driver=bun:sqlite",
+    "profile": "cross-env PROFILE=true tsx build.ts && cd bin && (rimraf CPU*.cpuprofile || true) && node --cpu-prof --cpu-prof-interval=100 test && speedscope CPU*.cpuprofile",
     "prepublishOnly": "tsc -p tsconfig.build.json && tsx build.ts"
   },
   "devDependencies": {
@@ -28,9 +24,13 @@
     "@types/glob": "^8.0.0",
     "@types/sql.js": "^1.4.2",
     "better-sqlite3": "^7.5.1",
+    "bun-types": "^0.5.0",
+    "cross-env": "^7.0.3",
     "esbuild": "^0.16.16",
     "glob": "^8.0.3",
+    "rimraf": "^4.1.2",
     "sade": "^1.8.1",
+    "speedscope": "^1.15.0",
     "sql.js": "^1.8.0",
     "sqlite3": "^5.1.4",
     "tsx": "^3.12.1",