You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
105 lines
3.8 KiB
105 lines
3.8 KiB
import * as sqlite3 from '@gristlabs/sqlite3';
|
|
import { fromCallback } from 'app/server/lib/serverUtils';
|
|
import { MinDB, PreparedStatement, ResultRow, SqliteVariant } from 'app/server/lib/SqliteCommon';
|
|
import { OpenMode, RunResult } from 'app/server/lib/SQLiteDB';
|
|
|
|
export class NodeSqliteVariant implements SqliteVariant {
|
|
public opener(dbPath: string, mode: OpenMode): Promise<MinDB> {
|
|
return NodeSqlite3DatabaseAdapter.opener(dbPath, mode);
|
|
}
|
|
}
|
|
|
|
export class NodeSqlite3PreparedStatement implements PreparedStatement {
|
|
public constructor(private _statement: sqlite3.Statement) {
|
|
}
|
|
|
|
public async run(...params: any[]): Promise<RunResult> {
|
|
return fromCallback(cb => this._statement.run(...params, cb));
|
|
}
|
|
|
|
public async finalize() {
|
|
await fromCallback(cb => this._statement.finalize(cb));
|
|
}
|
|
|
|
public columns(): string[] {
|
|
// This method is only needed if marshalling is not built in -
|
|
// and node-sqlite3 has marshalling built in.
|
|
throw new Error('not available (but should not be needed)');
|
|
}
|
|
}
|
|
|
|
export class NodeSqlite3DatabaseAdapter implements MinDB {
|
|
public static async opener(dbPath: string, mode: OpenMode): Promise<any> {
|
|
const sqliteMode: number =
|
|
// tslint:disable-next-line:no-bitwise
|
|
(mode === OpenMode.OPEN_READONLY ? sqlite3.OPEN_READONLY : sqlite3.OPEN_READWRITE) |
|
|
(mode === OpenMode.OPEN_CREATE || mode === OpenMode.CREATE_EXCL ? sqlite3.OPEN_CREATE : 0);
|
|
let _db: sqlite3.Database;
|
|
await fromCallback(cb => { _db = new sqlite3.Database(dbPath, sqliteMode, cb); });
|
|
const result = new NodeSqlite3DatabaseAdapter(_db!);
|
|
await result.limitAttach(0); // Outside of VACUUM, we don't allow ATTACH.
|
|
return result;
|
|
}
|
|
|
|
public constructor(protected _db: sqlite3.Database) {
|
|
// Default database to serialized execution. See https://github.com/mapbox/node-sqlite3/wiki/Control-Flow
|
|
// This isn't enough for transactions, which we serialize explicitly.
|
|
this._db.serialize();
|
|
}
|
|
|
|
public async exec(sql: string): Promise<void> {
|
|
return fromCallback(cb => this._db.exec(sql, cb));
|
|
}
|
|
|
|
public async run(sql: string, ...params: any[]): Promise<RunResult> {
|
|
return new Promise((resolve, reject) => {
|
|
function callback(this: RunResult, err: Error | null) {
|
|
if (err) {
|
|
reject(err);
|
|
} else {
|
|
resolve(this);
|
|
}
|
|
}
|
|
this._db.run(sql, ...params, callback);
|
|
});
|
|
}
|
|
|
|
public async get(sql: string, ...params: any[]): Promise<ResultRow|undefined> {
|
|
return fromCallback(cb => this._db.get(sql, ...params, cb));
|
|
}
|
|
|
|
public async all(sql: string, ...params: any[]): Promise<ResultRow[]> {
|
|
return fromCallback(cb => this._db.all(sql, params, cb));
|
|
}
|
|
|
|
public async prepare(sql: string): Promise<PreparedStatement> {
|
|
let stmt: sqlite3.Statement|undefined;
|
|
// The original interface is a little strange; we resolve to Statement if prepare() succeeded.
|
|
await fromCallback(cb => { stmt = this._db.prepare(sql, cb); }).then(() => stmt);
|
|
if (!stmt) { throw new Error('could not prepare statement'); }
|
|
return new NodeSqlite3PreparedStatement(stmt);
|
|
}
|
|
|
|
public async close() {
|
|
this._db.close();
|
|
}
|
|
|
|
public async allMarshal(sql: string, ...params: any[]): Promise<Buffer> {
|
|
// allMarshal isn't in the typings, because it is our addition to our fork of sqlite3 JS lib.
|
|
return fromCallback(cb => (this._db as any).allMarshal(sql, ...params, cb));
|
|
|
|
}
|
|
|
|
public async runAndGetId(sql: string, ...params: any[]): Promise<number> {
|
|
const result = await this.run(sql, ...params);
|
|
return (result as any).lastID;
|
|
}
|
|
|
|
public async limitAttach(maxAttach: number) {
|
|
const SQLITE_LIMIT_ATTACHED = (sqlite3 as any).LIMIT_ATTACHED;
|
|
// Cast because types out of date.
|
|
(this._db as any).configure('limit', SQLITE_LIMIT_ATTACHED, maxAttach);
|
|
}
|
|
}
|
|
|