rado 0.1.49 → 0.1.51

package/dist/driver/better-sqlite3.js

@@ -1,5 +1,6 @@
 // src/driver/better-sqlite3.ts
 import { Driver } from "../lib/Driver.js";
+import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var PreparedStatement = class {
@@ -32,7 +33,11 @@ var BetterSqlite3Driver = class extends Driver.Sync {
   tableData;
   indexData;
   prepareStatement(stmt) {
-    return new PreparedStatement(this.db.prepare(stmt.sql));
+    try {
+      return new PreparedStatement(this.db.prepare(stmt.sql));
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
   }
   schemaInstructions(tableName) {
     const columnData = this.tableData(tableName);

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

@@ -1,18 +1,18 @@
-/// <reference types="bun-types" />
-import type { Database } from 'bun:sqlite';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-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;
+/// <reference types="bun-types" />
+import type { Database } from 'bun:sqlite';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+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

@@ -2,6 +2,7 @@
 import { Cursor } from "../define/Cursor.js";
 import { Query } from "../define/Query.js";
 import { Driver } from "../lib/Driver.js";
+import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var PreparedStatement = class {
@@ -47,7 +48,11 @@ var BunSqliteDriver = class extends Driver.Sync {
   indexData;
   lastChanges;
   prepareStatement(stmt) {
-    return new PreparedStatement(this.lastChanges, this.db.prepare(stmt.sql));
+    try {
+      return new PreparedStatement(this.lastChanges, this.db.prepare(stmt.sql));
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
   }
   schemaInstructions(tableName) {
     const columnData = this.tableData(tableName);

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

@@ -1,15 +1,15 @@
-import type { Database } from 'sql.js';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-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: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): SqlJsDriver;
+import type { Database } from 'sql.js';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+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: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): SqlJsDriver;

package/dist/driver/sql.js.js

@@ -1,5 +1,6 @@
 // src/driver/sql.js.ts
 import { Driver } from "../lib/Driver.js";
+import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var PreparedStatement = class {
@@ -43,11 +44,15 @@ var SqlJsDriver = class extends Driver.Sync {
   tableData;
   indexData;
   prepareStatement(stmt, discardAfter) {
-    return new PreparedStatement(
-      this.db,
-      this.db.prepare(stmt.sql),
-      discardAfter
-    );
+    try {
+      return new PreparedStatement(
+        this.db,
+        this.db.prepare(stmt.sql),
+        discardAfter
+      );
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
   }
   schemaInstructions(tableName) {
     const columnData = this.tableData(tableName);

package/dist/driver/sqlite3.d.ts

@@ -1,18 +1,18 @@
-import type { Database } from 'sqlite3';
-import { Query } from '../define/Query';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
-export declare class Sqlite3Driver extends Driver.Async {
-    private db;
-    lock: Promise<void> | undefined;
-    tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
-    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: Statement): Driver.Async.PreparedStatement;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: Driver.Async, release: () => Promise<void>];
-}
-export declare function connect(db: Database): Sqlite3Driver;
+import type { Database } from 'sqlite3';
+import { Query } from '../define/Query';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class Sqlite3Driver extends Driver.Async {
+    private db;
+    lock: Promise<void> | undefined;
+    tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
+    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: Statement): Driver.Async.PreparedStatement;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: Driver.Async, release: () => Promise<void>];
+}
+export declare function connect(db: Database): Sqlite3Driver;

package/dist/driver/sqlite3.js

@@ -1,5 +1,6 @@
 // src/driver/sqlite3.ts
 import { Driver } from "../lib/Driver.js";
+import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var PreparedStatement = class {
@@ -93,7 +94,11 @@ var Sqlite3Driver = class extends Driver.Async {
     return super.executeQuery(query, stmt, params);
   }
   prepareStatement(stmt) {
-    return new PreparedStatement(this.db.prepare(stmt.sql));
+    try {
+      return new PreparedStatement(this.db.prepare(stmt.sql));
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
   }
   async schemaInstructions(tableName) {
     const columnData = await this.tableData(tableName);

package/dist/index.d.ts

@@ -1,20 +1,21 @@
-export * from './define/Column';
-export * from './define/Cursor';
-export * from './define/Expr';
-export * from './define/Fields';
-export * from './define/Functions';
-export * from './define/Id';
-export * from './define/Index';
-export * from './define/Ops';
-export * from './define/OrderBy';
-export * from './define/Param';
-export * from './define/Query';
-export * from './define/Schema';
-export * from './define/Selection';
-export * from './define/Table';
-export * from './define/Target';
-export * from './define/Update';
-export type { Driver } from './lib/Driver';
-export type { FormatContext, Formatter } from './lib/Formatter';
-export type { Sanitizer } from './lib/Sanitizer';
-export type { Statement } from './lib/Statement';
+export * from './define/Column';
+export * from './define/Cursor';
+export * from './define/Expr';
+export * from './define/Fields';
+export * from './define/Functions';
+export * from './define/Id';
+export * from './define/Index';
+export * from './define/Ops';
+export * from './define/OrderBy';
+export * from './define/Param';
+export * from './define/Query';
+export * from './define/Schema';
+export * from './define/Selection';
+export * from './define/Table';
+export * from './define/Target';
+export * from './define/Update';
+export type { Driver } from './lib/Driver';
+export type { FormatContext, Formatter } from './lib/Formatter';
+export type { Sanitizer } from './lib/Sanitizer';
+export * from './lib/SqlError';
+export type { Statement } from './lib/Statement';

package/dist/index.js

@@ -15,3 +15,4 @@ export * from "./define/Selection.js";
 export * from "./define/Table.js";
 export * from "./define/Target.js";
 export * from "./define/Update.js";
+export * from "./lib/SqlError.js";

package/dist/lib/Driver.d.ts

@@ -1,110 +1,110 @@
-import { Cursor } from '../define/Cursor';
-import { Expr } from '../define/Expr';
-import { Query } from '../define/Query';
-import { SchemaInstructions } from '../define/Schema';
-import { Table } from '../define/Table';
-import { Formatter } from './Formatter';
-import { Statement } from './Statement';
-declare class Callable extends Function {
-    constructor(fn: 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>, Statement];
-    all(...args: Array<any>): any;
-    get(...args: Array<any>): any;
-    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
-    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
-    abstract executeQuery(query: Query<any>): any;
-}
-type ParamTypes<Params extends [...any[]]> = {
-    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
-} & {
-    length: Params['length'];
-};
-interface SyncDriver {
-    <T>(query: Cursor<T>): T;
-    <T>(...queries: Array<Cursor<any>>): T;
-    (strings: TemplateStringsArray, ...values: any[]): any;
-}
-declare abstract class SyncDriver extends DriverBase {
-    transactionId: number;
-    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;
-    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
-    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Cursor<T>): T;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-    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;
-}
-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;
-}
-interface AsyncDriver {
-    <T>(query: Cursor<T>): Promise<T>;
-    <T>(...queries: Array<Cursor<any>>): Promise<T>;
-    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-}
-declare abstract class AsyncDriver extends DriverBase {
-    transactionId: number;
-    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-    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>;
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
-    all<T>(cursor: Cursor<T>): Promise<T>;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-    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 {
-    private sync;
-    lock: Promise<void> | undefined;
-    constructor(sync: SyncDriver);
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-}
-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>;
-}
-export type Driver = SyncDriver | AsyncDriver;
-export declare namespace Driver {
-    type Sync = SyncDriver;
-    const Sync: typeof SyncDriver;
-    namespace Sync {
-        type PreparedStatement = SyncPreparedStatement;
-    }
-    type Async = AsyncDriver;
-    const Async: typeof AsyncDriver;
-    namespace Async {
-        type PreparedStatement = AsyncPreparedStatement;
-    }
-}
-export {};
+import { Cursor } from '../define/Cursor';
+import { Expr } from '../define/Expr';
+import { Query } from '../define/Query';
+import { SchemaInstructions } from '../define/Schema';
+import { Table } from '../define/Table';
+import { Formatter } from './Formatter';
+import { Statement } from './Statement';
+declare class Callable extends Function {
+    constructor(fn: 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>, Statement];
+    all(...args: Array<any>): any;
+    get(...args: Array<any>): any;
+    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
+    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
+    abstract executeQuery(query: Query<any>): any;
+}
+type ParamTypes<Params extends [...any[]]> = {
+    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
+} & {
+    length: Params['length'];
+};
+interface SyncDriver {
+    <T>(query: Cursor<T>): T;
+    <T>(...queries: Array<Cursor<any>>): T;
+    (strings: TemplateStringsArray, ...values: any[]): any;
+}
+declare abstract class SyncDriver extends DriverBase {
+    transactionId: number;
+    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;
+    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
+    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
+    all<T>(cursor: Cursor<T>): T;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
+    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;
+}
+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;
+}
+interface AsyncDriver {
+    <T>(query: Cursor<T>): Promise<T>;
+    <T>(...queries: Array<Cursor<any>>): Promise<T>;
+    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+}
+declare abstract class AsyncDriver extends DriverBase {
+    transactionId: number;
+    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    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>;
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
+    all<T>(cursor: Cursor<T>): Promise<T>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
+    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 {
+    private sync;
+    lock: Promise<void> | undefined;
+    constructor(sync: SyncDriver);
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+}
+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>;
+}
+export type Driver = SyncDriver | AsyncDriver;
+export declare namespace Driver {
+    type Sync = SyncDriver;
+    const Sync: typeof SyncDriver;
+    namespace Sync {
+        type PreparedStatement = SyncPreparedStatement;
+    }
+    type Async = AsyncDriver;
+    const Async: typeof AsyncDriver;
+    namespace Async {
+        type PreparedStatement = AsyncPreparedStatement;
+    }
+}
+export {};

package/dist/lib/Formatter.d.ts

@@ -1,67 +1,67 @@
-import { ColumnData, ColumnType } from '../define/Column';
-import { ExprData } from '../define/Expr';
-import { OrderBy } from '../define/OrderBy';
-import { Query } from '../define/Query';
-import { Target } from '../define/Target';
-import { Sanitizer } from './Sanitizer';
-import { Statement } from './Statement';
-export interface FormatContext {
-    stmt: Statement;
-    nameResult?: string;
-    /** Skip prefixing fields with their table name */
-    skipTableName?: boolean;
-    /**
-     * In SQLite table names are used as expressions in the FTS5 plugin.
-     * To distinguish between formatting a row of the table and just the table name
-     * this flag can be used.
-     **/
-    tableAsExpr?: boolean;
-    /** Inline all parameters */
-    forceInline?: boolean;
-    formatAsJson?: boolean;
-    formatAsDefault?: boolean;
-    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>, options?: Partial<FormatContext>): Statement;
-    format<T>(ctx: FormatContext, query: Query<T>): Statement;
-    formatSelect(ctx: FormatContext, query: Query.Select): Statement;
-    formatInsert(ctx: FormatContext, query: Query.Insert): Statement;
-    formatUpdate(ctx: FormatContext, query: Query.Update): Statement;
-    formatDelete(ctx: FormatContext, query: Query.Delete): Statement;
-    formatCreateTable(ctx: FormatContext, query: Query.CreateTable): Statement;
-    formatCreateIndex(ctx: FormatContext, query: Query.CreateIndex): Statement;
-    formatDropIndex(ctx: FormatContext, query: Query.DropIndex): Statement;
-    formatAlterTable(ctx: FormatContext, query: Query.AlterTable): Statement;
-    formatTransaction(ctx: FormatContext, { op, id }: Query.Transaction): Statement;
-    formatBatch(ctx: FormatContext, { queries }: Query.Batch): Statement;
-    formatRaw(ctx: FormatContext, { strings, params }: Query.Raw): Statement;
-    formatColumn(ctx: FormatContext, column: ColumnData): Statement;
-    formatContraintReference(ctx: FormatContext, reference: ExprData): Statement;
-    formatType(ctx: FormatContext, type: ColumnType): Statement;
-    formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
-    formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;
-    formatTarget(ctx: FormatContext, target: Target): Statement;
-    formatWhere(ctx: FormatContext, expr: ExprData | undefined): Statement;
-    formatHaving(ctx: FormatContext, expr: ExprData | undefined): Statement;
-    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, formatSubject?: FormatSubject): Statement;
-    formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
-    formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
-    formatIn(ctx: FormatContext, expr: ExprData): Statement;
-    retrieveField(expr: ExprData, field: string): ExprData | undefined;
-    formatField(ctx: FormatContext, expr: ExprData, field: string): Statement;
-    formatString(ctx: FormatContext, input: string): Statement;
-    formatInlineValue(ctx: FormatContext, rawValue: any): Statement;
-    formatValue(ctx: FormatContext, rawValue: any): Statement;
-    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
-}
-export {};
+import { ColumnData, ColumnType } from '../define/Column';
+import { ExprData } from '../define/Expr';
+import { OrderBy } from '../define/OrderBy';
+import { Query } from '../define/Query';
+import { Target } from '../define/Target';
+import { Sanitizer } from './Sanitizer';
+import { Statement } from './Statement';
+export interface FormatContext {
+    stmt: Statement;
+    nameResult?: string;
+    /** Skip prefixing fields with their table name */
+    skipTableName?: boolean;
+    /**
+     * In SQLite table names are used as expressions in the FTS5 plugin.
+     * To distinguish between formatting a row of the table and just the table name
+     * this flag can be used.
+     **/
+    tableAsExpr?: boolean;
+    /** Inline all parameters */
+    forceInline?: boolean;
+    formatAsJson?: boolean;
+    formatAsDefault?: boolean;
+    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>, options?: Partial<FormatContext>): Statement;
+    format<T>(ctx: FormatContext, query: Query<T>): Statement;
+    formatSelect(ctx: FormatContext, query: Query.Select): Statement;
+    formatInsert(ctx: FormatContext, query: Query.Insert): Statement;
+    formatUpdate(ctx: FormatContext, query: Query.Update): Statement;
+    formatDelete(ctx: FormatContext, query: Query.Delete): Statement;
+    formatCreateTable(ctx: FormatContext, query: Query.CreateTable): Statement;
+    formatCreateIndex(ctx: FormatContext, query: Query.CreateIndex): Statement;
+    formatDropIndex(ctx: FormatContext, query: Query.DropIndex): Statement;
+    formatAlterTable(ctx: FormatContext, query: Query.AlterTable): Statement;
+    formatTransaction(ctx: FormatContext, { op, id }: Query.Transaction): Statement;
+    formatBatch(ctx: FormatContext, { queries }: Query.Batch): Statement;
+    formatRaw(ctx: FormatContext, { strings, params }: Query.Raw): Statement;
+    formatColumn(ctx: FormatContext, column: ColumnData): Statement;
+    formatContraintReference(ctx: FormatContext, reference: ExprData): Statement;
+    formatType(ctx: FormatContext, type: ColumnType): Statement;
+    formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
+    formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;
+    formatTarget(ctx: FormatContext, target: Target): Statement;
+    formatWhere(ctx: FormatContext, expr: ExprData | undefined): Statement;
+    formatHaving(ctx: FormatContext, expr: ExprData | undefined): Statement;
+    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, formatSubject?: FormatSubject): Statement;
+    formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
+    formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
+    formatIn(ctx: FormatContext, expr: ExprData): Statement;
+    retrieveField(expr: ExprData, field: string): ExprData | undefined;
+    formatField(ctx: FormatContext, expr: ExprData, field: string): Statement;
+    formatString(ctx: FormatContext, input: string): Statement;
+    formatInlineValue(ctx: FormatContext, rawValue: any): Statement;
+    formatValue(ctx: FormatContext, rawValue: any): Statement;
+    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
+}
+export {};