sqlmath 2021.11.20 → 2022.5.20

package/sqlmath.mjs

@@ -1,11 +1,32 @@
+// MIT License
+//
+// Copyright (c) 2021 Kai Zhu
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+
 /*jslint beta, bitwise, name, node*/
 "use strict";
 import {createRequire} from "module";
 import jslint from "./jslint.mjs";
 
 let {
-    assertErrorThrownAsync,
-    assertJsonEqual,
     assertOrThrow,
     debugInline,
     noop
@@ -17,7 +38,7 @@ function assertNumericalEqual(aa, bb, message) {
 // This function will assert aa - bb <= Number.EPSILON
 
     assertOrThrow(aa, "value cannot be 0 or falsy");
-    if (!(Math.abs(aa - bb) <= Number.EPSILON)) {
+    if (!(Math.abs((aa - bb) / Math.max(aa, bb)) <= 256 * Number.EPSILON)) {
         throw new Error(
             JSON.stringify(aa) + " != " + JSON.stringify(bb) + (
                 message
@@ -58,10 +79,9 @@ file sqlmath.js
     let SQLITE_OPEN_URI = 0x00000040;           /* Ok for sqlite3_open_v2() */
     let SQLITE_OPEN_WAL = 0x00080000;           /* VFS only */
     let addon;
-    let dbDict = new WeakMap();
+    let consoleError = console.error;
+    let dbDict = new WeakMap(); // private map of sqlite-database-connections
     let requireCjs = createRequire(import.meta.url);
-    let testList;
-    // private map of sqlite-database-connections
 
     function cCall(func, argList) {
 // this function will serialize <argList> to a c <baton>,
@@ -168,8 +188,12 @@ file sqlmath.js
         bindList = [],
         db,
         responseType,
-        rowList,
-        sql
+        sql,
+        tmpColList,
+        tmpColListPriority,
+        tmpCsv,
+        tmpRowList,
+        tmpTableName
     }) {
 // this function will exec <sql> in <db> and return <result>
         let bindByKey = !Array.isArray(bindList);
@@ -180,10 +204,14 @@ file sqlmath.js
         );
         let result;
         let serialize = jsToSqlSerializer();
-        if (rowList) {
+        if (tmpCsv || tmpRowList) {
             await dbTableInsertAsync({
+                colList: tmpColList,
+                colListPriority: tmpColListPriority,
+                csv: tmpCsv,
                 db,
-                rowList
+                rowList: tmpRowList,
+                tableName: tmpTableName
             });
         }
         Object.entries(bindList).forEach(function ([
@@ -202,8 +230,6 @@ file sqlmath.js
             (
                 responseType === "lastBlob"
                 ? 1
-                : responseType === "lastMatrixDouble"
-                ? 2
                 : 0
             )
         ].concat(serialize.bufSharedList));
@@ -212,8 +238,6 @@ file sqlmath.js
         case "arraybuffer":
         case "lastBlob":
             return result;
-        case "lastMatrixDouble":
-            return new Float64Array(result);
         case "list":
             return JSON.parse(new TextDecoder().decode(result));
         default:
@@ -231,6 +255,28 @@ file sqlmath.js
         }
     }
 
+    async function dbExecWithRetryAsync(option) {
+// this function will exec <sql> in <db> and return <result> with <retryLimit>
+        let retry = option.retryLimit || 1;
+        while (true) {
+            try {
+                return await dbExecAsync(option);
+            } catch (err) {
+                assertOrThrow(retry > 0, err);
+                consoleError(err);
+                consoleError(
+                    "dbExecWithRetryAsync - retry failed sql-query with "
+                    + retry
+                    + " remaining retry"
+                );
+                retry -= 1;
+                await new Promise(function (resolve) {
+                    setTimeout(resolve, 50);
+                });
+            }
+        }
+    }
+
     function dbGetLastBlobAsync({
         bindList = [],
         db,
@@ -246,21 +292,6 @@ file sqlmath.js
         });
     }
 
-    function dbGetLastMatrixDouble({
-        bindList = [],
-        db,
-        sql
-    }) {
-// this function will exec <sql> in <db> and return last SELECT-statement
-// from execution as row x col matrix of doubles
-        return dbExecAsync({
-            bindList,
-            db,
-            responseType: "lastMatrixDouble",
-            sql
-        });
-    }
-
     async function dbMemoryLoadAsync({
         db,
         filename
@@ -296,7 +327,9 @@ file sqlmath.js
 //   const char *zVfs        /* Name of VFS module to use */
 // );
         let connPool;
-        let db = {};
+        let db = {
+            filename
+        };
         assertOrThrow(
             typeof filename === "string",
             "invalid filename " + filename
@@ -306,9 +339,12 @@ file sqlmath.js
         ), async function () {
             let finalizer;
             let ptr = await cCall("__dbOpenAsync", [
-                String(filename), undefined, flags ?? (
+                String(filename),
+                undefined,
+                flags ?? (
                     SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_URI
-                ), undefined
+                ),
+                undefined
             ]);
             ptr = ptr[0][0];
             finalizer = new BigInt64Array(addon.__dbFinalizerCreate());
@@ -318,6 +354,7 @@ file sqlmath.js
         dbDict.set(db, {
             busy: 0,
             connPool,
+            filename,
             ii: 0,
             ptr: 0n
         });
@@ -330,13 +367,14 @@ file sqlmath.js
         csv,
         db,
         rowList,
-        tableName = "tmp1"
+        tableName
     }) {
 // this function will create-or-replace temp <tablename> with <rowList>
         let serialize = jsToSqlSerializer();
         let sqlCreateTable;
         let sqlInsertRow;
         // normalize and validate tableName
+        tableName = tableName || "__tmp1";
         tableName = "temp." + JSON.stringify(tableName.replace((
             /^temp\./
         ), ""));
@@ -429,9 +467,6 @@ file sqlmath.js
         }
         function bufferSetBuffer(aa, bb, offset) {
 // this function will set buffer <bb> to buffer <aa> at <offset>
-            if (typeof bb === "string") {
-                bb = new TextEncoder().encode(bb);
-            }
             aa = new Uint8Array(aa.buffer, aa.byteOffset, aa.byteLength);
             bb = new Uint8Array(bb.buffer, bb.byteOffset, bb.byteLength);
             aa.set(bb, offset);
@@ -827,832 +862,6 @@ Definition of the CSV Format
         return rowList;
     }
 
-    function testAll() {
-// this function will run all tests
-        testList.forEach(function (testFunc) {
-            testFunc();
-        });
-    }
-
-    function testAssertXxx() {
-// this function will test assertXxx's handling-behavior
-        // test assertNumericalEqual's handling-behavior
-        assertNumericalEqual(1, 1);
-        assertErrorThrownAsync(function () {
-            assertNumericalEqual(0, 0);
-        }, "value cannot be 0 or falsy");
-        assertErrorThrownAsync(function () {
-            assertNumericalEqual(1, 2);
-        }, "1 != 2");
-        assertErrorThrownAsync(function () {
-            assertNumericalEqual(1, 2, "aa");
-        }, "aa");
-    }
-
-    function testCcall() {
-// this function will test cCall's handling-behavior
-        [
-            [-0, "0"],
-            [-Infinity, "0"],
-            [0, "0"],
-            [1 / 0, "0"],
-            [Infinity, "0"],
-            [false, "0"],
-            [null, "0"],
-            [true, "1"],
-            [undefined, "0"],
-            [{}, "0"]
-        ].forEach(async function ([
-            aa, bb
-        ]) {
-            let cc;
-            cc = String(
-                await cCall("noopAsync", [
-                    aa
-                ])
-            )[0][0];
-            assertOrThrow(bb === cc, [aa, bb, cc]);
-            cc = String(cCall("noopSync", [
-                aa
-            ]))[0][0];
-            assertOrThrow(bb === cc, [aa, bb, cc]);
-        });
-    }
-
-    async function testDbBind() {
-// this function will test db's bind handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        async function testDbGetLastBlobAsync(val) {
-            return await dbGetLastBlobAsync({
-                bindList: [
-                    val
-                ],
-                db,
-                sql: "SELECT 1, 2, 3; SELECT 1, 2, ?"
-            });
-        }
-        // test bigint-error handling-behavior
-        noop([
-            -(2n ** 63n),
-            2n ** 63n
-        ]).forEach(function (val) {
-            assertErrorThrownAsync(testDbGetLastBlobAsync.bind(undefined, val));
-        });
-        // test datatype handling-behavior
-        [
-            // -1. SharedArrayBuffer
-            // new SharedArrayBuffer(0), null,
-            // 1. bigint
-            -0n, -0,
-            -0x7fffffffffffffffn, "-9223372036854775807",
-            -1n, -1,
-            -2n, -2,
-            0n, 0,
-            0x7fffffffffffffffn, "9223372036854775807",
-            1n, 1,
-            2n, 2,
-            // 2. boolean
-            false, 0,
-            true, 1,
-            // 3. function
-            noop, null,
-            // 4. number
-            -0, 0,
-            -1 / 0, null,
-            -1e-999, 0,
-            -1e999, null,
-            -2, -2,
-            -Infinity, null,
-            -NaN, 0,
-            0, 0,
-            1 / 0, null,
-            1e-999, 0,
-            1e999, null,
-            2, 2,
-            Infinity, null,
-            NaN, 0,
-            // 5. object
-            new Uint8Array(0), null,
-            new TextEncoder().encode(""), null,
-            new TextEncoder().encode("\u0000"), null,
-            new TextEncoder().encode("\u0000\u{1f600}\u0000"), null,
-            [], "[]",
-            new Date(0), "1970-01-01T00:00:00.000Z",
-            new RegExp(), "{}",
-            null, null,
-            {}, "{}",
-            // 6. string
-            "", "",
-            "0", "0",
-            "1", "1",
-            "2", "2",
-            "\u0000", "\u0000",
-            "\u0000\u{1f600}\u0000", "\u0000\u{1f600}\u0000",
-            "a".repeat(9999), "a".repeat(9999),
-            // 7. symbol
-            Symbol(), null,
-            // 8. undefined
-            undefined, null
-        ].forEach(function (aa, ii, list) {
-            let bb = list[ii + 1];
-            if (ii % 2 === 1) {
-                return;
-            }
-            ii *= 0.5;
-            // test dbGetLastBlobAsync's bind handling-behavior
-            [
-                aa
-            ].forEach(async function (aa) {
-                let cc = String(bb);
-                let dd = new TextDecoder().decode(
-                    await testDbGetLastBlobAsync(aa)
-                );
-                switch (typeof(aa)) {
-                case "bigint":
-                    aa = Number(aa);
-                    break;
-                case "function":
-                case "symbol":
-                case "undefined":
-                    cc = "";
-                    break;
-                case "number":
-                    switch (aa) {
-                    case -2:
-                        cc = "-2.0";
-                        break;
-                    case -Infinity:
-                        cc = "-Inf";
-                        break;
-                    case 2:
-                        cc = "2.0";
-                        break;
-                    case Infinity:
-                        cc = "Inf";
-                        break;
-                    }
-                    break;
-                case "object":
-                    if (ArrayBuffer.isView(aa)) {
-                        cc = new TextDecoder().decode(aa);
-                        break;
-                    }
-                    if (aa === null) {
-                        cc = "";
-                    }
-                    break;
-                }
-                // debugInline(ii, aa, bb, cc, dd);
-                assertJsonEqual(cc, dd, {
-                    ii,
-                    aa, //jslint-quiet
-                    bb,
-                    cc,
-                    dd
-                });
-            });
-            // test dbGetLastMatrixDouble's bind handling-behavior
-            [
-                aa
-            ].forEach(async function (aa) {
-                let cc = Number(
-                    typeof aa === "symbol"
-                    ? 0
-                    : aa
-                ) || 0;
-                let dd = await dbGetLastMatrixDouble({
-                    bindList: [
-                        aa
-                    ],
-                    db,
-                    sql: "SELECT 1, 2, 3; SELECT 1, 2, ?"
-                });
-                switch (typeof(aa)) {
-                case "bigint":
-                    aa = String(aa);
-                    break;
-                case "object":
-                    if (typeof aa?.getUTCFullYear === "function") {
-                        cc = aa.getUTCFullYear();
-                    }
-                    break;
-                }
-                cc = new Float64Array([
-                    1, 3, 1, 2, cc
-                ]);
-                // debugInline(ii, aa, bb, cc, dd);
-                cc.forEach(function (val, jj) {
-                    assertJsonEqual(
-                        val,
-                        dd[jj],
-                        {
-                            ii,
-                            aa, //jslint-quiet
-                            bb,
-                            cc,
-                            dd
-                        }
-                    );
-                });
-            });
-            // test dbExecAsync's responseType handling-behavior
-            [
-                "arraybuffer",
-                "list",
-                undefined
-            ].forEach(async function (responseType) {
-                let cc = noop(
-                    await dbExecAsync({
-                        bindList: [
-                            aa
-                        ],
-                        db,
-                        responseType,
-                        sql: "SELECT ? AS val"
-                    })
-                );
-                // debugInline(ii, responseType, aa, bb, cc);
-                switch (responseType) {
-                case "arraybuffer":
-                    cc = JSON.parse(new TextDecoder().decode(cc))[0][1][0];
-                    break;
-                case "list":
-                    cc = cc[0][1][0];
-                    break;
-                default:
-                    cc = cc[0][0].val;
-                }
-                assertJsonEqual(bb, cc, {
-                    aa,
-                    bb,
-                    cc
-                });
-            });
-            // test dbExecAsync's bind handling-behavior
-            [
-                [
-                    [
-                        bb, bb, 0
-                    ],
-                    (
-                        "SELECT 0;"
-                        + " SELECT ? AS c1, ? AS c2, ? AS c3, ? AS c4"
-                        + " UNION ALL SELECT ?1, ?2, ?3, ?4"
-                        + " UNION ALL SELECT ?1, ?2, ?3, ?4"
-                    )
-                ], [
-                    {
-                        k1: bb,
-                        k2: bb,
-                        k3: 0
-                    },
-                    (
-                        "SELECT 0;"
-                        + " SELECT $k1 AS c1, $k2 AS c2, $k3 AS c3, $k4 AS c4"
-                        + " UNION ALL SELECT :k1, :k2, :k3, :k4"
-                        + " UNION ALL SELECT @k1, @k2, @k3, @k4"
-                    )
-                ]
-            ].forEach(async function ([
-                bindList, sql
-            ]) {
-                let cc = noop(
-                    await dbExecAsync({
-                        bindList,
-                        db,
-                        responseType: "list",
-                        sql
-                    })
-                );
-                // debugInline(ii, aa, bb, cc);
-                assertJsonEqual(
-                    [
-                        [
-                            [
-                                "0"
-                            ], [
-                                0
-                            ]
-                        ], [
-                            [
-                                "c1", "c2", "c3", "c4"
-                            ], [
-                                bb, bb, 0, undefined
-                            ], [
-                                bb, bb, 0, undefined
-                            ], [
-                                bb, bb, 0, undefined
-                            ]
-                        ]
-                    ],
-                    cc
-                );
-            });
-            // test dbTableInsertAsync's bind handling-behavior
-            [
-                {
-                    // test list-of-list handling-behavior
-                    rowList: [
-                        [
-                            "c1", "c2", "c3"
-                        ],
-                        [
-                            aa, aa
-                        ]
-                    ]
-                }, {
-                    // test list-of-dict handling-behavior
-                    rowList: [
-                        {
-                            "c1": aa,
-                            "c2": aa,
-                            "c3": undefined
-                        }
-                    ]
-                }, {
-                    // test colList and list-of-list handling-behavior
-                    colList: [
-                        "c1", "c2", "c3"
-                    ],
-                    rowList: [
-                        [
-                            aa, aa
-                        ]
-                    ]
-                }, {
-                    // test colList and list-of-dict handling-behavior
-                    colList: [
-                        "c1", "c2", "c3"
-                    ],
-                    rowList: [
-                        {
-                            "c1": aa,
-                            "c2": aa,
-                            "c3": undefined
-                        }
-                    ]
-                }, {
-                    // test colList and list-of-list handling-behavior
-                    colList: [
-                        "c1", "c3", "c2"
-                    ],
-                    colListPriority: [
-                        "c1", "c2"
-                    ],
-                    rowList: [
-                        [
-                            aa, undefined, aa
-                        ]
-                    ]
-                }
-            ].forEach(async function ({
-                colList,
-                colListPriority,
-                rowList
-            }, jj) {
-                let cc;
-                await dbTableInsertAsync({
-                    colList,
-                    colListPriority,
-                    db,
-                    rowList,
-                    tableName: "datatype_" + ii + "_" + jj
-                });
-                cc = noop(
-                    await dbExecAsync({
-                        db,
-                        responseType: "list",
-                        sql: "SELECT * FROM datatype_" + ii + "_" + jj
-                    })
-                )[0];
-                // debugInline(ii, jj, aa, bb, cc);
-                assertJsonEqual([
-                    [
-                        "c1", "c2", "c3"
-                    ], [
-                        bb, bb, undefined
-                    ]
-                ], cc);
-            });
-        });
-    }
-
-    async function testDbCloseAsync() {
-// this function will test dbCloseAsync's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbCloseAsync({});
-        }, "invalid or closed db");
-        // test close handling-behavior
-        await dbCloseAsync({
-            db
-        });
-    }
-
-    async function testDbExecAsync() {
-// this function will test dbExecAsync's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbExecAsync({
-                db,
-                sql: undefined
-            });
-        }, "near \"undefined\": syntax error");
-        // test race-condition handling-behavior
-        Array.from(new Array(4)).forEach(async function () {
-            let result;
-            try {
-                result = JSON.stringify(
-                    await dbExecAsync({
-                        bindList: [
-                            new TextEncoder().encode("foob"),
-                            new TextEncoder().encode("fooba"),
-                            new TextEncoder().encode("foobar")
-                        ],
-                        db,
-                        responseType: "list",
-                        sql: (`
-CREATE TABLE testDbExecAsync1 AS
-SELECT 101 AS c101, 102 AS c102
-UNION ALL
-VALUES
-    (201, 202),
-    (301, NULL);
-CREATE TABLE testDbExecAsync2 AS
-SELECT 401 AS c401, 402 AS c402, 403 AS c403
-UNION ALL
-VALUES
-    (501, 502.0123, 5030123456789),
-    (601, '602', '603_\"\x01\x08\x09\x0a\x0b\x0c\x0d\x0e'),
-    (?1, ?2, ?3),
-    (tostring(?1), tostring(?2), tostring(?3)),
-    (tobase64(?1), tobase64(?2), tobase64(?3)),
-    (
-        tobase64(uncompress(compress(?1))),
-        tobase64(uncompress(compress(?2))),
-        tobase64(uncompress(compress(?3)))
-    );
-SELECT * FROM testDbExecAsync1;
-SELECT * FROM testDbExecAsync2;
-                        `)
-                    })
-                );
-                assertJsonEqual(result, JSON.stringify([
-                    [
-                        ["c101", "c102"],
-                        [101, 102],
-                        [201, 202],
-                        [301, null]
-                    ],
-                    [
-                        ["c401", "c402", "c403"],
-                        [401, 402, 403],
-                        [501, 502.0123, 5030123456789],
-                        [601, "602", "603_\"\u0001\b\t\n\u000b\f\r\u000e"],
-                        [
-                            null, null, null
-                        ],
-                        [
-                            "foob", "fooba", "foobar"
-                        ],
-                        [
-                            "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"
-                        ],
-                        [
-                            "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"
-                        ]
-                    ]
-                ]));
-            } catch (err) {
-                assertOrThrow(
-                    err.message.indexOf(
-                        "table testDbExecAsync1 already exists"
-                    ) >= 0,
-                    err
-                );
-            }
-        });
-        // test close-while-busy handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbCloseAsync({
-                db
-            });
-        }, (
-            /db cannot close with \d+? actions pending/
-        ));
-        // test sqlmath-defined-func handling-behavior
-        [
-            "COT('-1')", -0.642092615934331,
-            "COT('0')", null,
-            "COT('1')", 0.642092615934331,
-            "COT(-1)", -0.642092615934331,
-            "COT(0)", null,
-            "COT(1)", 0.642092615934331,
-            "COTH('-1')", -1.31303528549933,
-            "COTH('0')", null,
-            "COTH('1')", 1.31303528549933,
-            "COTH(-1)", -1.31303528549933,
-            "COTH(0)", null,
-            "COTH(1)", 1.31303528549933,
-            "SIGN('-1')", -1,
-            "SIGN('0')", 0,
-            "SIGN('1')", 1,
-            "SIGN(-0x7fffffffffffffff)", -1,
-            "SIGN(-1)", -1,
-            "SIGN(-1e999)", -1,
-            "SIGN(0)", 0,
-            "SIGN(0x7fffffffffffffff)", 1,
-            "SIGN(0x8000000000000000)", -1,
-            "SIGN(0xffffffffffffffff)", -1,
-            "SIGN(1)", 1,
-            "SIGN(1e999)", 1,
-            "SIGN(NULL)", null,
-            // sentinel
-            "NULL", null
-        ].forEach(async function (sql, ii, list) {
-            let bb = list[ii + 1];
-            let cc;
-            if (ii % 2 === 1) {
-                return;
-            }
-            ii *= 0.5;
-            cc = noop(
-                await dbExecAsync({
-                    db,
-                    responseType: "dict",
-                    sql: "SELECT " + sql + " AS val"
-                })
-            )[0][0].val;
-            assertOrThrow(bb === cc, JSON.stringify([
-                ii, sql, bb, cc
-            ]));
-        });
-    }
-
-    async function testDbMemoryXxx() {
-// this function will test dbMemoryXxx's handling-behavior
-        let data;
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbMemoryLoadAsync({
-                db
-            });
-        }, "invalid filename undefined");
-        assertErrorThrownAsync(function () {
-            return dbMemorySaveAsync({
-                db
-            });
-        }, "invalid filename undefined");
-        await dbExecAsync({
-            db,
-            sql: "CREATE TABLE t01 AS SELECT 1 AS c01"
-        });
-        await dbMemorySaveAsync({
-            db,
-            filename: ".testDbMemoryXxx.sqlite"
-        });
-        db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        await dbMemoryLoadAsync({
-            db,
-            filename: ".testDbMemoryXxx.sqlite"
-        });
-        data = await dbExecAsync({
-            db,
-            sql: "SELECT * FROM t01"
-        });
-        assertJsonEqual(data, [
-            [
-                {
-                    c01: 1
-                }
-            ]
-        ]);
-    }
-
-    function testDbOpenAsync() {
-// this function will test dbOpenAsync's handling-behavior
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbOpenAsync({});
-        }, "invalid filename undefined");
-    }
-
-    async function testDbTableInsertAsync() {
-// this function will test dbTableInsertAsync's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        // test error handling-behavior
-        [
-            [
-                undefined,
-                (
-                    /invalid rowList undefined/
-                )
-            ], [
-                [
-                    []
-                ],
-                (
-                    /invalid colList \[\]/
-                )
-            ], [
-                [
-                    {}
-                ],
-                (
-                    /invalid colList \[\]/
-                )
-            ]
-        ].forEach(function ([
-            rowList, rgx
-        ]) {
-            assertErrorThrownAsync(function () {
-                return dbTableInsertAsync({
-                    rowList
-                });
-            }, rgx);
-        });
-        // test csv handling-behavior
-        [
-            [
-                "0", undefined
-            ],
-            [
-                "0,0,0\n1,1,1",
-                [
-                    [
-                        "c_0", "c_0_2", "c_0_3"
-                    ], [
-                        "1", "1", "1"
-                    ]
-                ]
-            ],
-            [
-                (
-                    "c1,c1,c2\n"
-                    + "1, 2 \n"
-                    + `"1","""2""","3\r\n"\n`
-                    + "\n"
-                    + "1,2,3\n"
-                ),
-                [
-                    [
-                        "c1", "c1_2", "c2"
-                    ], [
-                        "1", " 2 ", null
-                    ], [
-                        "1", "\"2\"", "3\n"
-                    ], [
-                        "", null, null
-                    ], [
-                        "1", "2", "3"
-                    ]
-                ]
-            ]
-        ].forEach(async function ([
-            aa, bb
-        ], ii) {
-            let cc;
-            await dbTableInsertAsync({
-                csv: aa,
-                db,
-                tableName: "csv_" + ii
-            });
-            cc = noop(
-                await dbExecAsync({
-                    db,
-                    responseType: "list",
-                    sql: "SELECT * FROM temp.csv_" + ii
-                })
-            )[0];
-            assertOrThrow(
-                JSON.stringify(bb) === JSON.stringify(cc),
-                JSON.stringify([
-                    ii, aa, bb, cc
-                ], undefined, 4)
-            );
-        });
-    }
-
-    async function testSqlError() {
-// this function will test sql-error's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        [
-            1, "SQL logic error",
-            2, "unknown error",
-            3, "access permission denied",
-            4, "query aborted",
-            5, "database is locked",
-            6, "database table is locked",
-            7, "out of memory",
-            8, "attempt to write a readonly database",
-            9, "interrupted",
-            10, "disk I/O error",
-            11, "database disk image is malformed",
-            12, "unknown operation",
-            13, "database or disk is full",
-            14, "unable to open database file",
-            15, "locking protocol",
-            16, "unknown error",
-            17, "database schema has changed",
-            18, "string or blob too big",
-            19, "constraint failed",
-            20, "datatype mismatch",
-            21, "bad parameter or other API misuse",
-            22, "unknown error",
-            23, "authorization denied",
-            24, "unknown error",
-            25, "column index out of range",
-            26, "file is not a database",
-            27, "notification message",
-            28, "warning message",
-            100, "unknown error",
-            101, "unknown error"
-        ].forEach(function (sql, ii, list) {
-            let bb = list[ii + 1];
-            if (ii % 2 === 1) {
-                return;
-            }
-            ii *= 0.5;
-            sql = "SELECT throwerror(" + sql + ")";
-            assertErrorThrownAsync(function () {
-                return dbExecAsync({
-                    db,
-                    sql
-                });
-            }, bb);
-        });
-    }
-
-    async function testSqlExt() {
-// this function will test sql-ext's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        [
-            {
-                aa: [
-                    [
-                        {
-                            "c01": ""
-                        }
-                    ]
-                ],
-                sql: "SELECT tobase64(NULL) AS c01"
-            },
-            {
-                aa: [
-                    [
-                        {
-                            "c01": ""
-                        }
-                    ]
-                ],
-                sql: "SELECT tobase64(?) AS c01"
-            },
-            {
-                aa: [
-                    [
-                        {
-                            "c01": "AAAAAAAAAAA="
-                        }
-                    ]
-                ],
-                bindList: [
-                    new Uint8Array(8)
-                ],
-                sql: "SELECT tobase64(uncompress(compress(?))) AS c01"
-            }
-        ].forEach(async function ({
-            aa,
-            bindList,
-            sql
-        }) {
-            let bb = await dbExecAsync({
-                bindList,
-                db,
-                sql
-            });
-            assertJsonEqual(aa, bb);
-        });
-    }
-
     addon = requireCjs(
         "./_binary_sqlmath"
         + "_napi8"
@@ -1660,19 +869,7 @@ SELECT * FROM testDbExecAsync2;
         + "_" + process.arch
         + ".node"
     );
-    testList = [
-        testAssertXxx,
-        testCcall,
-        testDbBind,
-        testDbCloseAsync,
-        testDbExecAsync,
-        testDbMemoryXxx,
-        testDbOpenAsync,
-        testDbTableInsertAsync,
-        testSqlError,
-        testSqlExt
-    ];
-    Object.assign(local, {
+    Object.assign(local, jslint, {
         SQLITE_MAX_LENGTH2,
         SQLITE_OPEN_AUTOPROXY,
         SQLITE_OPEN_CREATE,
@@ -1695,19 +892,22 @@ SELECT * FROM testDbExecAsync2;
         SQLITE_OPEN_TRANSIENT_DB,
         SQLITE_OPEN_URI,
         SQLITE_OPEN_WAL,
-        assertErrorThrownAsync,
         assertNumericalEqual,
+        cCall,
         dbCloseAsync,
         dbExecAsync,
+        dbExecWithRetryAsync,
         dbGetLastBlobAsync,
         dbMemoryLoadAsync,
         dbMemorySaveAsync,
         dbOpenAsync,
         dbTableInsertAsync,
-        debugInline,
-        testAll,
-        testList
+        debugInline
     });
+    if (process.env.npm_config_mode_test) {
+        // mock consoleError
+        consoleError = noop;
+    }
 }());
 
 export default Object.freeze(local);