use better-sqlite3

src/routes/api/export.js

@@ -23,7 +23,11 @@ async function exportBranch(req, res) {
 
     try {
         if (type === 'subtree' && (format === 'html' || format === 'markdown')) {
+            const start = Date.now();
+
             await zipExportService.exportToZip(taskContext, branch, format, res);
+
+            console.log("Export took", Date.now() - start, "ms");
         }
         else if (type === 'single') {
             await singleExportService.exportSingleNote(taskContext, branch, format, res);

src/routes/api/import.js

@@ -50,7 +50,11 @@ async function importToBranch(req) {
         if (extension === '.tar' && options.explodeArchives) {
             note = await tarImportService.importTar(taskContext, file.buffer, parentNote);
         } else if (extension === '.zip' && options.explodeArchives) {
+            const start = Date.now();
+
             note = await zipImportService.importZip(taskContext, file.buffer, parentNote);
+
+            console.log("Import took", Date.now() - start, "ms");
         } else if (extension === '.opml' && options.explodeArchives) {
             note = await opmlImportService.importOpml(taskContext, file.buffer, parentNote);
         } else if (extension === '.enex' && options.explodeArchives) {
@@ -85,4 +89,4 @@ async function importToBranch(req) {
 
 module.exports = {
     importToBranch
-};
+};

src/services/sql.js

@@ -33,7 +33,7 @@ async function insert(tableName, rec, replace = false) {
 
     const res = await execute(query, Object.values(rec));
 
-    return res.lastID;
+    return res.lastInsertRowid;
 }
 
 async function replace(tableName, rec) {
@@ -49,34 +49,46 @@ async function upsert(tableName, primaryKey, rec) {
 
     const columns = keys.join(", ");
 
-    let i = 0;
+    const questionMarks = keys.map(colName => "@" + colName).join(", ");
 
-    const questionMarks = keys.map(p => ":" + i++).join(", ");
-
-    i = 0;
-
-    const updateMarks = keys.map(key => `${key} = :${i++}`).join(", ");
+    const updateMarks = keys.map(colName => `${colName} = @${colName}`).join(", ");
 
     const query = `INSERT INTO ${tableName} (${columns}) VALUES (${questionMarks}) 
                    ON CONFLICT (${primaryKey}) DO UPDATE SET ${updateMarks}`;
 
-    await execute(query, Object.values(rec));
+    for (const idx in rec) {
+        if (rec[idx] === true || rec[idx] === false) {
+            rec[idx] = rec[idx] ? 1 : 0;
+        }
+    }
+
+    await execute(query, rec);
 }
 
-async function beginTransaction() {
-    return await dbConnection.run("BEGIN");
+const statementCache = {};
+
+function stmt(sql) {
+    if (!(sql in statementCache)) {
+        statementCache[sql] = dbConnection.prepare(sql);
+    }
+
+    return statementCache[sql];
 }
 
-async function commit() {
-    return await dbConnection.run("COMMIT");
+function beginTransaction() {
+    return stmt("BEGIN").run();
 }
 
-async function rollback() {
-    return await dbConnection.run("ROLLBACK");
+function commit() {
+    return stmt("COMMIT").run();
+}
+
+function rollback() {
+    return stmt("ROLLBACK").run();
 }
 
 async function getRow(query, params = []) {
-    return await wrap(async db => db.get(query, ...params), query);
+    return wrap(() => stmt(query).get(params), query);
 }
 
 async function getRowOrNull(query, params = []) {
@@ -105,18 +117,25 @@ async function getManyRows(query, params) {
         const curParams = params.slice(0, Math.min(params.length, PARAM_LIMIT));
         params = params.slice(curParams.length);
 
+        const curParamsObj = {};
+
+        let j = 1;
+        for (const param of curParams) {
+            curParamsObj['param' + j++] = param;
+        }
+
         let i = 1;
-        const questionMarks = curParams.map(() => "?" + i++).join(",");
+        const questionMarks = curParams.map(() => ":param" + i++).join(",");
         const curQuery = query.replace(/\?\?\?/g, questionMarks);
 
-        results = results.concat(await getRows(curQuery, curParams));
+        results = results.concat(await getRows(curQuery, curParamsObj));
     }
 
     return results;
 }
 
 async function getRows(query, params = []) {
-    return await wrap(async db => db.all(query, ...params), query);
+    return wrap(() => stmt(query).all(params), query);
 }
 
 async function getMap(query, params = []) {
@@ -152,11 +171,11 @@ async function getColumn(query, params = []) {
 async function execute(query, params = []) {
     await startTransactionIfNecessary();
 
-    return await wrap(async db => db.run(query, ...params), query);
+    return wrap(() => stmt(query).run(params), query);
 }
 
 async function executeWithoutTransaction(query, params = []) {
-    await dbConnection.run(query, ...params);
+    await dbConnection.run(query, params);
 }
 
 async function executeMany(query, params) {
@@ -169,10 +188,10 @@ async function executeMany(query, params) {
 async function executeScript(query) {
     await startTransactionIfNecessary();
 
-    return await wrap(async db => db.exec(query), query);
+    return wrap(() => stmt.run(query), query);
 }
 
-async function wrap(func, query) {
+function wrap(func, query) {
     if (!dbConnection) {
         throw new Error("DB connection not initialized yet");
     }
@@ -182,7 +201,7 @@ async function wrap(func, query) {
     try {
         const startTimestamp = Date.now();
 
-        const result = await func(dbConnection);
+        const result = func(dbConnection);
 
         const milliseconds = Date.now() - startTimestamp;
         if (milliseconds >= 300) {

src/services/sql_init.js

@@ -1,8 +1,6 @@
 const log = require('./log');
 const dataDir = require('./data_dir');
 const fs = require('fs');
-const sqlite = require('sqlite');
-const sqlite3 = require('sqlite3');
 const resourceDir = require('./resource_dir');
 const appInfo = require('./app_info');
 const sql = require('./sql');
@@ -12,28 +10,14 @@ const optionService = require('./options');
 const port = require('./port');
 const Option = require('../entities/option');
 const TaskContext = require('./task_context.js');
+const Database = require('better-sqlite3');
 
-const dbConnection = new Promise(async (resolve, reject) => {
-    const db = await sqlite.open({
-        filename: dataDir.DOCUMENT_PATH,
-        driver: sqlite3.Database
-    });
+const dbConnection = new Database(dataDir.DOCUMENT_PATH);
+dbConnection.pragma('journal_mode = WAL');
 
-    db.run('PRAGMA journal_mode = WAL;');
+sql.setDbConnection(dbConnection);
 
-    sql.setDbConnection(db);
-
-    resolve();
-});
-
-let dbReadyResolve = null;
-const dbReady = new Promise(async (resolve, reject) => {
-    dbReadyResolve = resolve;
-
-    await dbConnection;
-
-    initDbConnection();
-});
+const dbReady = initDbConnection();
 
 async function schemaExists() {
     const tableResults = await sql.getRows("SELECT name FROM sqlite_master WHERE type='table' AND name='options'");
@@ -78,7 +62,6 @@ async function initDbConnection() {
         await require('./options_init').initStartupOptions();
 
         log.info("DB ready.");
-        dbReadyResolve();
     });
 }
 
@@ -189,7 +172,6 @@ dbReady.then(async () => {
 
 module.exports = {
     dbReady,
-    dbConnection,
     schemaExists,
     isDbInitialized,
     initDbConnection,
@@ -197,4 +179,4 @@ module.exports = {
     createInitialDatabase,
     createDatabaseForSync,
     dbInitialized
-};
+};