rado 0.0.0 → 0.1.1

package/dist/Formatter.js

@@ -65,6 +65,12 @@ var Formatter = class {
         return this.formatDelete(query, ctx);
       case QueryType.CreateTable:
         return this.formatCreateTable(query, ctx);
+      case QueryType.CreateIndex:
+        return this.formatCreateIndex(query, ctx);
+      case QueryType.DropIndex:
+        return this.formatDropIndex(query, ctx);
+      case QueryType.AlterTable:
+        return this.formatAlterTable(query, ctx);
       case QueryType.Transaction:
         return this.formatTransaction(query, ctx);
       case QueryType.Batch:
@@ -114,6 +120,29 @@ var Formatter = class {
       })
     );
   }
+  formatCreateIndex(query, ctx = {}) {
+    return raw("create index").addIf(query.ifNotExists, "if not exists").addIdentifier(query.index.name).add("on").addIdentifier(query.table.name).parenthesis(
+      separated(
+        query.index.on.map(
+          (expr) => this.formatExprValue(expr, { ...ctx, skipTableName: true })
+        )
+      )
+    ).add(this.formatWhere(query.where, ctx));
+  }
+  formatDropIndex(query, ctx) {
+    return raw("drop index").addIf(query.ifExists, "if exists").addIdentifier(query.index.name);
+  }
+  formatAlterTable(query, ctx) {
+    let stmt = raw("alter table").addIdentifier(query.table.name);
+    if (query.addColumn) {
+      stmt = stmt.add("add column").add(this.formatColumn(query.addColumn));
+    } else if (query.dropColumn) {
+      stmt = stmt.add("drop column").addIdentifier(query.dropColumn);
+    } else if (query.alterColumn) {
+      throw new Error(`Not available in this formatter: alter column`);
+    }
+    return stmt;
+  }
   formatTransaction({ op, id }, ctx) {
     switch (op) {
       case Query.TransactionOperation.Begin:
@@ -131,23 +160,32 @@ var Formatter = class {
     );
   }
   formatRaw({ strings, params }, ctx) {
-    return Statement.ofTemplate(strings, params);
+    return Statement.tag(strings, ...params);
   }
   formatColumn(column) {
     return identifier(column.name).add(this.formatType(column.type)).addIf(column.unique, "unique").addIf(column.autoIncrement, "autoincrement").addIf(column.primaryKey, "primary key").addIf(!column.nullable, "not null").addIf(
       column.defaultValue !== void 0,
-      raw("default").value(column.defaultValue)
-    );
+      raw("default").add(this.formatInlineValue(column.defaultValue))
+    ).addIf(column.references, () => {
+      return this.formatContraintReference(column.references);
+    });
+  }
+  formatContraintReference(reference) {
+    if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
+      throw new Error("not supported");
+    const from = reference.expr.target;
+    return raw("references").addIdentifier(Target.source(from).name).parenthesis(identifier(reference.field));
   }
   formatType(type) {
     switch (type) {
       case ColumnType.String:
-      case ColumnType.Object:
-      case ColumnType.Array:
         return raw("text");
+      case ColumnType.Json:
+        return raw("json");
       case ColumnType.Number:
-      case ColumnType.Boolean:
         return raw("numeric");
+      case ColumnType.Boolean:
+        return raw("boolean");
       case ColumnType.Integer:
         return raw("integer");
     }
@@ -184,14 +222,10 @@ var Formatter = class {
         if (typeof columnValue !== "boolean")
           throw new TypeError(`Expected boolean for column ${column.name}`);
         return value(columnValue);
-      case ColumnType.Object:
+      case ColumnType.Json:
         if (typeof columnValue !== "object")
           throw new TypeError(`Expected object for column ${column.name}`);
         return value(JSON.stringify(columnValue));
-      case ColumnType.Array:
-        if (!Array.isArray(columnValue))
-          throw new TypeError(`Expected array for column ${column.name}`);
-        return value(JSON.stringify(columnValue));
     }
   }
   formatTarget(target, ctx) {
@@ -283,13 +317,10 @@ var Formatter = class {
       case ExprType.Row:
         switch (expr.target.type) {
           case TargetType.Table:
-            const selection = identifier(
-              expr.target.table.alias || expr.target.table.name
-            ).raw(".").identifier(field);
+            const selection = ctx.skipTableName ? identifier(field) : identifier(expr.target.table.alias || expr.target.table.name).raw(".").identifier(field);
             const column = expr.target.table.columns[field];
             switch (column?.type) {
-              case ColumnType.Array:
-              case ColumnType.Object:
+              case ColumnType.Json:
                 return call("json", selection);
               default:
                 return selection;
@@ -306,6 +337,18 @@ var Formatter = class {
   formatString(input) {
     return raw(this.escapeValue(String(input)));
   }
+  formatInlineValue(rawValue) {
+    switch (true) {
+      case (rawValue === null || rawValue === void 0):
+        return raw("null");
+      case typeof rawValue === "boolean":
+        return rawValue ? raw("true") : raw("false");
+      case (typeof rawValue === "string" || typeof rawValue === "number"):
+        return this.formatString(rawValue);
+      default:
+        return this.formatString(JSON.stringify(rawValue));
+    }
+  }
   formatValue(rawValue, formatAsJson) {
     switch (true) {
       case (rawValue === null || rawValue === void 0):
@@ -407,7 +450,7 @@ var Formatter = class {
         return call(
           "json_object",
           ...Object.entries(expr.fields).map(([key, value2]) => {
-            return this.formatString(key).raw(",").newline().concat(this.formatExpr(value2, { ...ctx, formatAsJson: true }));
+            return this.formatString(key).raw(", ").concat(this.formatExpr(value2, { ...ctx, formatAsJson: true }));
           })
         );
       case ExprType.Filter: {

package/dist/Ops.js

@@ -2,38 +2,37 @@
 import { Cursor } from "./Cursor.js";
 import { ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
+import { Schema } from "./Schema.js";
 import { Target } from "./Target.js";
 function selectAll(table) {
   return new Cursor.SelectMultiple(
     Query.Select({
-      from: Target.Table(table.data()),
-      selection: ExprData.Row(Target.Table(table.data()))
+      from: Target.Table(table.schema()),
+      selection: ExprData.Row(Target.Table(table.schema()))
     })
   );
 }
 function selectFirst(table) {
   return new Cursor.SelectSingle(
     Query.Select({
-      from: Target.Table(table.data()),
-      selection: ExprData.Row(Target.Table(table.data())),
+      from: Target.Table(table.schema()),
+      selection: ExprData.Row(Target.Table(table.schema())),
       singleResult: true
     })
   );
 }
 function update(table) {
-  return new Cursor.Update(Query.Update({ table: table.data() }));
+  return new Cursor.Update(Query.Update({ table: table.schema() }));
 }
 function insertInto(table) {
-  return new Cursor.Insert(table.data());
+  return new Cursor.Insert(table.schema());
 }
 function deleteFrom(table) {
-  return new Cursor.Delete(Query.Delete({ table: table.data() }));
+  return new Cursor.Delete(Query.Delete({ table: table.schema() }));
 }
 function create(...tables) {
   return new Cursor.Batch(
-    tables.map(
-      (table) => Query.CreateTable({ table: table.data(), ifNotExists: true })
-    )
+    tables.flatMap((table) => Schema.create(table.schema()).queries)
   );
 }
 export {

package/dist/Query.d.ts

@@ -1,6 +1,7 @@
+import { ColumnData } from './Column';
 import { ExprData } from './Expr';
 import { OrderBy } from './OrderBy';
-import { TableData } from './Table';
+import { Index, Schema } from './Schema';
 import { Target } from './Target';
 export declare const enum QueryType {
     Insert = "Insert",
@@ -8,11 +9,14 @@ export declare const enum QueryType {
     Update = "Update",
     Delete = "Delete",
     CreateTable = "CreateTable",
+    CreateIndex = "CreateIndex",
+    DropIndex = "DropIndex",
+    AlterTable = "AlterTable",
     Batch = "Batch",
     Transaction = "Transaction",
     Raw = "Raw"
 }
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.Batch | Query.Transaction | Query.Raw;
+export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
 export declare namespace Query {
     interface QueryBase {
         limit?: number;
@@ -27,42 +31,52 @@ export declare namespace Query {
     }
     interface Insert extends QueryBase {
         type: QueryType.Insert;
-        into: TableData;
+        into: Schema;
         data: Array<any>;
     }
-    function Insert<T>(insert: Omit<Insert, 'type'>): Query<T>;
+    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
     interface Select extends QueryBase {
         type: QueryType.Select;
         selection: ExprData;
         from: Target;
     }
-    function Select<T>(select: Omit<Select, 'type'>): Query<T>;
+    function Select(select: Omit<Select, 'type'>): Query.Select;
     interface Update extends QueryBase {
         type: QueryType.Update;
-        table: TableData;
+        table: Schema;
         set?: Record<string, any>;
     }
-    function Update<T>(update: Omit<Update, 'type'>): Query<{
-        rowsAffected: number;
-    }>;
+    function Update(update: Omit<Update, 'type'>): Query.Update;
     interface Delete extends QueryBase {
         type: QueryType.Delete;
-        table: TableData;
+        table: Schema;
     }
-    function Delete<T>(del: Omit<Delete, 'type'>): Query<{
-        rowsAffected: number;
-    }>;
+    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
     interface CreateTable extends QueryBase {
         type: QueryType.CreateTable;
-        table: TableData;
+        table: Schema;
         ifNotExists?: boolean;
     }
-    function CreateTable<T>(create: Omit<CreateTable, 'type'>): Query<void>;
+    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
+    interface CreateIndex extends QueryBase {
+        type: QueryType.CreateIndex;
+        table: Schema;
+        index: Index;
+        ifNotExists?: boolean;
+    }
+    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
+    interface DropIndex extends QueryBase {
+        type: QueryType.DropIndex;
+        table: Schema;
+        index: Index;
+        ifExists?: boolean;
+    }
+    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
     interface Batch extends QueryBase {
         type: QueryType.Batch;
         queries: Array<Query<any>>;
     }
-    function Batch<T>(batch: Omit<Batch, 'type'>): Query<void>;
+    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
     enum TransactionOperation {
         Begin = "Begin",
         Commit = "Commit",
@@ -73,7 +87,7 @@ export declare namespace Query {
         id: string;
         op: TransactionOperation;
     }
-    function Transaction<T>(transaction: Omit<Transaction, 'type'>): Query<T>;
+    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
     type RawReturn = 'row' | 'rows' | undefined;
     interface Raw extends QueryBase {
         type: QueryType.Raw;
@@ -81,5 +95,13 @@ export declare namespace Query {
         strings: ReadonlyArray<string>;
         params: Array<any>;
     }
-    function Raw<T>(raw: Omit<Raw, 'type'>): Query<T>;
+    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
+    interface AlterTable extends QueryBase {
+        type: QueryType.AlterTable;
+        table: Schema;
+        alterColumn?: ColumnData;
+        addColumn?: ColumnData;
+        dropColumn?: string;
+    }
+    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
 }

package/dist/Query.js

@@ -5,6 +5,9 @@ var QueryType = /* @__PURE__ */ ((QueryType2) => {
   QueryType2["Update"] = "Update";
   QueryType2["Delete"] = "Delete";
   QueryType2["CreateTable"] = "CreateTable";
+  QueryType2["CreateIndex"] = "CreateIndex";
+  QueryType2["DropIndex"] = "DropIndex";
+  QueryType2["AlterTable"] = "AlterTable";
   QueryType2["Batch"] = "Batch";
   QueryType2["Transaction"] = "Transaction";
   QueryType2["Raw"] = "Raw";
@@ -32,6 +35,14 @@ var Query;
     return { type: "CreateTable" /* CreateTable */, ...create };
   }
   Query2.CreateTable = CreateTable;
+  function CreateIndex(create) {
+    return { type: "CreateIndex" /* CreateIndex */, ...create };
+  }
+  Query2.CreateIndex = CreateIndex;
+  function DropIndex(drop) {
+    return { type: "DropIndex" /* DropIndex */, ...drop };
+  }
+  Query2.DropIndex = DropIndex;
   function Batch(batch) {
     return { type: "Batch" /* Batch */, ...batch };
   }
@@ -50,6 +61,10 @@ var Query;
     return { type: "Raw" /* Raw */, ...raw };
   }
   Query2.Raw = Raw;
+  function AlterTable(alter) {
+    return { type: "AlterTable" /* AlterTable */, ...alter };
+  }
+  Query2.AlterTable = AlterTable;
 })(Query || (Query = {}));
 export {
   Query,

package/dist/Sanitizer.d.ts

@@ -1,4 +1,4 @@
 export interface Sanitizer {
     escapeValue(value: any): string;
-    escapeIdent(ident: string): string;
+    escapeIdentifier(ident: string): string;
 }

package/dist/Schema.d.ts

@@ -0,0 +1,23 @@
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { Formatter } from './Formatter';
+import { Query } from './Query';
+export interface Index {
+    name: string;
+    on: Array<ExprData>;
+    where?: ExprData;
+}
+export interface Schema {
+    name: string;
+    alias?: string;
+    columns: Record<string, ColumnData>;
+    indexes: Record<string, Index>;
+}
+export interface SchemaInstructions {
+    columns: Record<string, string>;
+    indexes: Record<string, string>;
+}
+export declare namespace Schema {
+    function create(schema: Schema): Query.Batch;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
+}

package/dist/Schema.js

@@ -0,0 +1,60 @@
+// src/Schema.ts
+import { Query } from "./Query.js";
+var Schema;
+((Schema2) => {
+  function create(schema) {
+    const queries = [];
+    queries.push(Query.CreateTable({ table: schema, ifNotExists: true }));
+    for (const index of Object.values(schema.indexes))
+      queries.push(Query.CreateIndex({ table: schema, index, ifNotExists: true }));
+    return Query.Batch({ queries });
+  }
+  Schema2.create = create;
+  function upgrade(formatter, local, schema) {
+    const columnNames = /* @__PURE__ */ new Set([
+      ...Object.keys(local.columns),
+      ...Object.keys(schema.columns)
+    ]);
+    const res = [];
+    for (const columnName of columnNames) {
+      const localInstruction = local.columns[columnName];
+      const schemaCol = schema.columns[columnName];
+      if (!localInstruction) {
+        res.push(Query.AlterTable({ table: schema, addColumn: schemaCol }));
+      } else if (!schemaCol) {
+        res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
+      } else {
+        const [instruction] = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
+        if (localInstruction !== instruction) {
+          res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
+        }
+      }
+    }
+    const indexNames = /* @__PURE__ */ new Set([
+      ...Object.keys(local.indexes),
+      ...Object.keys(schema.indexes)
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = local.indexes[indexName];
+      const schemaIndex = schema.indexes[indexName];
+      if (!localInstruction) {
+        res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+      } else if (!schemaIndex) {
+        res.push(Query.DropIndex({ table: schema, index: schemaIndex }));
+      } else {
+        const [instruction] = formatter.formatCreateIndex(
+          Query.CreateIndex({ table: schema, index: schemaIndex })
+        ).compile(formatter);
+        if (localInstruction !== instruction) {
+          res.push(Query.DropIndex({ table: schema, index: schemaIndex }));
+          res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+        }
+      }
+    }
+    return res;
+  }
+  Schema2.upgrade = upgrade;
+})(Schema || (Schema = {}));
+export {
+  Schema
+};

package/dist/Statement.d.ts

@@ -21,7 +21,7 @@ export declare class Statement {
     constructor(tokens: Array<Token>);
     concat(...tokens: Array<Token | Statement>): Statement;
     static create(from: string | Statement): Statement;
-    static ofTemplate(strings: ReadonlyArray<string>, params: Array<any>): Statement;
+    static tag(strings: ReadonlyArray<string>, ...params: Array<any>): Statement;
     space(): Statement;
     call(method: string, ...args: Array<Statement>): Statement;
     addCall(method: string, ...args: Array<Statement>): Statement;
@@ -41,7 +41,10 @@ export declare class Statement {
     separated(input: Array<Statement>, separator?: string): Statement;
     addSeparated(input: Array<Statement>, separator?: string): Statement;
     isEmpty(): boolean;
-    compile(sanitizer: Sanitizer, formatInline?: boolean): [string, Array<any>];
+    compile(sanitizer: Sanitizer, formatInline?: boolean): Statement.Compiled;
+}
+export declare namespace Statement {
+    type Compiled = [sql: string, params: Array<any>];
 }
 export declare function newline(): Statement;
 export declare function raw(raw: string): Statement;

package/dist/Statement.js

@@ -37,7 +37,7 @@ var Statement = class {
   static create(from) {
     return typeof from === "string" ? raw(from) : from;
   }
-  static ofTemplate(strings, params) {
+  static tag(strings, ...params) {
     return new Statement(
       strings.flatMap((s, i) => [Token.Raw(s), Token.Value(params[i])]).slice(0, -1)
     );
@@ -126,7 +126,7 @@ var Statement = class {
             sql += token.data;
           break;
         case "Identifier" /* Identifier */:
-          sql += sanitizer.escapeIdent(token.data);
+          sql += sanitizer.escapeIdentifier(token.data);
           break;
         case "Value" /* Value */:
           if (formatInline) {

package/dist/Table.d.ts

@@ -1,18 +1,13 @@
-import { Column, ColumnData } from './Column';
+import { Column } from './Column';
 import { Cursor } from './Cursor';
 import { Expr } from './Expr';
 import { Fields } from './Fields';
+import { Schema } from './Schema';
 import { Update } from './Update';
-export interface TableData {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes?: Record<string, Array<Expr<any>>>;
-}
 export declare class Table<T> extends Cursor.SelectMultiple<T> {
     /** @internal */
     protected __tableType: T;
-    constructor(data: TableData);
+    constructor(schema: Schema);
     insertOne(record: Table.Insert<T>): Cursor.Batch<T>;
     insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
     set(data: Update<T>): Cursor.Update<T>;
@@ -20,8 +15,7 @@ export declare class Table<T> extends Cursor.SelectMultiple<T> {
     as(alias: string): Table<T> & Fields<T>;
     get(name: string): Expr<any>;
     toExpr(): Expr<T>;
-    /** @internal */
-    data(): TableData;
+    schema(): Schema;
 }
 export declare namespace Table {
     type Intersection<A, B> = A & B extends infer U ? {
@@ -45,6 +39,10 @@ export interface TableOptions<T> {
     columns: {
         [K in keyof T]: Column<T[K]>;
     };
+    indexes?: (this: Fields<T>) => Record<string, {
+        on: Array<Expr<any>>;
+        where?: Expr<boolean>;
+    }>;
 }
 export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
 export declare namespace table {

package/dist/Table.js

@@ -4,19 +4,19 @@ import { Expr, ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
 import { Target } from "./Target.js";
 var Table = class extends Cursor.SelectMultiple {
-  constructor(data) {
+  constructor(schema) {
     super(
       Query.Select({
-        from: Target.Table(data),
-        selection: ExprData.Row(Target.Table(data))
+        from: Target.Table(schema),
+        selection: ExprData.Row(Target.Table(schema))
       })
     );
-    Object.defineProperty(this, "data", {
+    Object.defineProperty(this, "schema", {
       enumerable: false,
-      value: () => data
+      value: () => schema
     });
-    if (data.columns)
-      for (const column of Object.keys(data.columns)) {
+    if (schema.columns)
+      for (const column of Object.keys(schema.columns)) {
         Object.defineProperty(this, column, {
           enumerable: true,
           get: () => this.get(column)
@@ -31,49 +31,65 @@ var Table = class extends Cursor.SelectMultiple {
   insertOne(record) {
     return new Cursor.Batch([
       Query.Insert({
-        into: this.data(),
+        into: this.schema(),
         data: [record],
-        selection: ExprData.Row(Target.Table(this.data())),
+        selection: ExprData.Row(Target.Table(this.schema())),
         singleResult: true
       })
     ]);
   }
   insertAll(data) {
-    return new Cursor.Insert(this.data()).values(...data);
+    return new Cursor.Insert(this.schema()).values(...data);
   }
   set(data) {
     return new Cursor.Update(
       Query.Update({
-        table: this.data()
+        table: this.schema()
       })
     ).set(data);
   }
   createTable() {
-    return new Cursor.Create(this.data());
+    return new Cursor.Create(this.schema());
   }
   as(alias) {
-    return new Table({ ...this.data(), alias });
+    return new Table({ ...this.schema(), alias });
   }
   get(name) {
     return new Expr(ExprData.Field(this.toExpr().expr, name));
   }
   toExpr() {
-    return new Expr(ExprData.Row(Target.Table(this.data())));
+    return new Expr(ExprData.Row(Target.Table(this.schema())));
   }
-  /** @internal */
-  data() {
+  schema() {
     throw new Error("Not implemented");
   }
 };
 function table(options) {
-  return new Table({
+  const schema = {
     ...options,
     columns: Object.fromEntries(
       Object.entries(options.columns).map(([key, column]) => {
         const { data } = column;
         return [key, { ...data, name: data.name || key }];
       })
-    )
+    ),
+    indexes: {}
+  };
+  const indexes = Object.fromEntries(
+    Object.entries(
+      options.indexes ? options.indexes.call(
+        new Expr(ExprData.Row(Target.Table(schema)))
+      ) : {}
+    ).map(([key, index]) => {
+      return [
+        key,
+        { name: key, on: index.on.map(ExprData.create), where: index.where?.expr }
+      ];
+    })
+  );
+  return new Table({
+    ...schema,
+    indexes
   });
 }
 export {

package/dist/Target.d.ts

@@ -1,5 +1,5 @@
 import { ExprData } from './Expr';
-import { TableData } from './Table';
+import { Schema } from './Schema';
 export declare const enum TargetType {
     Each = "Each",
     Table = "Table",
@@ -15,9 +15,9 @@ export declare namespace Target {
     function Each(expr: ExprData, alias: string): Each;
     interface Table {
         type: TargetType.Table;
-        table: TableData;
+        table: Schema;
     }
-    function Table(table: TableData): Table;
+    function Table(table: Schema): Table;
     interface Join {
         type: TargetType.Join;
         left: Target;
@@ -26,5 +26,5 @@ export declare namespace Target {
         on: ExprData;
     }
     function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
-    function source(from: Target): TableData | undefined;
+    function source(from: Target): Schema | undefined;
 }

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

@@ -1,12 +1,17 @@
 import type { Database } from 'better-sqlite3';
 import { Driver } from '../Driver';
-import { Query } from '../Query';
-import { SqliteFormatter } from '../sqlite/SqliteFormatter';
+import { SchemaInstructions } from '../Schema';
+import { Statement } from '../Statement';
 export declare class BetterSqlite3Driver extends Driver.Sync {
-    private db;
-    formatter: SqliteFormatter;
+    db: Database;
     constructor(db: Database);
-    execute(query: Query): any;
+    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
+    values([sql, params]: Statement.Compiled): Array<Array<any>>;
+    execute([sql, params]: Statement.Compiled): void;
+    mutate([sql, params]: Statement.Compiled): {
+        rowsAffected: number;
+    };
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
     export(): Uint8Array;
 }
 export declare function connect(db: Database): BetterSqlite3Driver;