sqlmath 0.0.1 → 2021.11.20

package/sqlmath.js

@@ -1,238 +0,0 @@
-var path = require("path");
-var EventEmitter = require("events").EventEmitter;
-var sqlite3 = require(
-    "./.sqlmath-binding"
-    + "-" + "napi" + process.versions.napi
-    + "-" + process.platform
-    + "-" + process.arch
-    + ".node"
-);
-module.exports = sqlite3;
-
-function normalizeMethod (fn) {
-    return function (sql) {
-        var errBack;
-        var args = Array.prototype.slice.call(arguments, 1);
-        if (typeof args[args.length - 1] === "function") {
-            var callback = args[args.length - 1];
-            errBack = function(err) {
-                if (err) {
-                    callback(err);
-                }
-            };
-        }
-        var statement = new Statement(this, sql, errBack);
-        return fn.call(this, statement, args);
-    };
-}
-
-sqlite3.cached = {
-    Database: function(file, a, b) {
-        if (file === "" || file === ":memory:") {
-            // Don't cache special databases.
-            return new Database(file, a, b);
-        }
-
-        var db;
-        file = path.resolve(file);
-        function cb() { callback.call(db, null); }
-
-        if (!sqlite3.cached.objects[file]) {
-            db = sqlite3.cached.objects[file] = new Database(file, a, b);
-        }
-        else {
-            // Make sure the callback is called.
-            db = sqlite3.cached.objects[file];
-            var callback = (typeof a === "number") ? b : a;
-            if (typeof callback === "function") {
-                if (db.open) process.nextTick(cb);
-                else db.once("open", cb);
-            }
-        }
-
-        return db;
-    },
-    objects: {}
-};
-
-
-var Database = sqlite3.Database;
-var Statement = sqlite3.Statement;
-var Backup = sqlite3.Backup;
-
-Object.assign(Database.prototype, EventEmitter.prototype);
-Object.assign(Statement.prototype, EventEmitter.prototype);
-Object.assign(Backup.prototype, EventEmitter.prototype);
-
-// Database#prepare(sql, [bind1, bind2, ...], [callback])
-Database.prototype.prepare = normalizeMethod(function(statement, params) {
-    return params.length
-        ? statement.bind.apply(statement, params)
-        : statement;
-});
-
-// Database#run(sql, [bind1, bind2, ...], [callback])
-Database.prototype.run = normalizeMethod(function(statement, params) {
-    statement.run.apply(statement, params).finalize();
-    return this;
-});
-
-// Database#get(sql, [bind1, bind2, ...], [callback])
-Database.prototype.get = normalizeMethod(function(statement, params) {
-    statement.get.apply(statement, params).finalize();
-    return this;
-});
-
-// Database#all(sql, [bind1, bind2, ...], [callback])
-Database.prototype.all = normalizeMethod(function(statement, params) {
-    statement.all.apply(statement, params).finalize();
-    return this;
-});
-
-// Database#each(sql, [bind1, bind2, ...], [callback], [complete])
-Database.prototype.each = normalizeMethod(function(statement, params) {
-    statement.each.apply(statement, params).finalize();
-    return this;
-});
-
-Database.prototype.map = normalizeMethod(function(statement, params) {
-    statement.map.apply(statement, params).finalize();
-    return this;
-});
-
-// Database#backup(filename, [callback])
-// Database#backup(filename, destName, sourceName, filenameIsDest, [callback])
-Database.prototype.backup = function() {
-    var backup;
-    if (arguments.length <= 2) {
-        // By default, we write the main database out to the main database of the named file.
-        // This is the most likely use of the backup api.
-        backup = new Backup(this, arguments[0], "main", "main", true, arguments[1]);
-    } else {
-        // Otherwise, give the user full control over the sqlite3_backup_init arguments.
-        backup = new Backup(this, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]);
-    }
-    // Per the sqlite docs, exclude the following errors as non-fatal by default.
-    backup.retryErrors = [sqlite3.BUSY, sqlite3.LOCKED];
-    return backup;
-};
-
-Statement.prototype.map = function() {
-    var params = Array.prototype.slice.call(arguments);
-    var callback = params.pop();
-    params.push(function(err, rows) {
-        if (err) return callback(err);
-        var result = {};
-        if (rows.length) {
-            var keys = Object.keys(rows[0]), key = keys[0];
-            if (keys.length > 2) {
-                // Value is an object
-                for (var i = 0; i < rows.length; i++) {
-                    result[rows[i][key]] = rows[i];
-                }
-            } else {
-                var value = keys[1];
-                // Value is a plain value
-                for (i = 0; i < rows.length; i++) {
-                    result[rows[i][key]] = rows[i][value];
-                }
-            }
-        }
-        callback(err, result);
-    });
-    return this.all.apply(this, params);
-};
-
-var isVerbose = false;
-
-var supportedEvents = [ "trace", "profile", "insert", "update", "delete" ];
-
-Database.prototype.addListener = Database.prototype.on = function(type) {
-    var val = EventEmitter.prototype.addListener.apply(this, arguments);
-    if (supportedEvents.indexOf(type) >= 0) {
-        this.configure(type, true);
-    }
-    return val;
-};
-
-Database.prototype.removeListener = function(type) {
-    var val = EventEmitter.prototype.removeListener.apply(this, arguments);
-    if (supportedEvents.indexOf(type) >= 0 && !this._events[type]) {
-        this.configure(type, false);
-    }
-    return val;
-};
-
-Database.prototype.removeAllListeners = function(type) {
-    var val = EventEmitter.prototype.removeAllListeners.apply(this, arguments);
-    if (supportedEvents.indexOf(type) >= 0) {
-        this.configure(type, false);
-    }
-    return val;
-};
-
-// Save the stack trace over EIO callbacks.
-// Inspired by https://github.com/tlrobinson/long-stack-traces
-var util = require("util");
-function trace(object, property, pos) {
-    var old = object[property];
-    object[property] = function() {
-        var error = new Error();
-        var name = object.constructor.name + "#" + property + "(" +
-            Array.prototype.slice.call(arguments).map(function(el) {
-                return util.inspect(el, false, 0);
-            }).join(", ") + ")";
-
-        if (typeof pos === "undefined") pos = -1;
-        if (pos < 0) pos += arguments.length;
-        var cb = arguments[pos];
-        if (typeof arguments[pos] === "function") {
-            arguments[pos] = function replacement() {
-                var err = arguments[0];
-                if (err && err.stack && !err.__augmented) {
-                    err.stack = err.stack.split("\n").filter(function(line) {
-                        return line.indexOf(__filename) < 0;
-                    }).join("\n");
-                    err.stack += "\n--> in " + name;
-                    err.stack += "\n" + error.stack.split("\n").filter(function(line) {
-                        return line.indexOf(__filename) < 0;
-                    }).slice(1).join("\n");
-                    err.__augmented = true;
-                }
-                return cb.apply(this, arguments);
-            };
-        }
-        return old.apply(this, arguments);
-    };
-}
-sqlite3.verbose = function() {
-    if (!isVerbose) {
-        [
-            "prepare",
-            "get",
-            "run",
-            "all",
-            "each",
-            "map",
-            "close",
-            "exec"
-        ].forEach(function (name) {
-            trace(Database.prototype, name);
-        });
-        [
-            "bind",
-            "get",
-            "run",
-            "all",
-            "each",
-            "map",
-            "reset",
-            "finalize",
-        ].forEach(function (name) {
-            trace(Statement.prototype, name);
-        });
-        isVerbose = true;
-    }
-
-    return this;
-};

package/test/backup.test.js

@@ -1,279 +0,0 @@
-var sqlite3 = require("..");
-var assert = require("assert");
-var fs = require("fs");
-var helper = require("./support/helper");
-
-// Check that the number of rows in two tables matches.
-function assertRowsMatchDb(db1, table1, db2, table2, done) {
-    db1.get("SELECT COUNT(*) as count FROM " + table1, function(err, row) {
-        if (err) throw err;
-        db2.get("SELECT COUNT(*) as count FROM " + table2, function(err, row2) {
-            if (err) throw err;
-            assert.equal(row.count, row2.count);
-            done();
-        });
-    });
-}
-
-// Check that the number of rows in the table "foo" is preserved in a backup.
-function assertRowsMatchFile(db, backupName, done) {
-    var db2 = new sqlite3.Database(backupName, sqlite3.OPEN_READONLY, function(err) {
-        if (err) throw err;
-        assertRowsMatchDb(db, "foo", db2, "foo", function() {
-            db2.close(done);
-        });
-    });
-}
-
-describe("backup", function() {
-    before(function() {
-        helper.ensureExists("test/tmp");
-    });
-
-    var db;
-    beforeEach(function(done) {
-        helper.deleteFile("test/tmp/backup.db");
-        helper.deleteFile("test/tmp/backup2.db");
-        db = new sqlite3.Database("test/support/prepare.db", sqlite3.OPEN_READONLY, done);
-    });
-
-    afterEach(function(done) {
-        if (!db) { done(); }
-        db.close(done);
-    });
-
-    it ("output db created once step is called", function(done) {
-        var backup = db.backup("test/tmp/backup.db", function(err) {
-            if (err) throw err;
-            backup.step(1, function(err) {
-                if (err) throw err;
-                assert.fileExists("test/tmp/backup.db");
-                backup.finish(done);
-            });
-        });
-    });
-
-    it ("copies source fully with step(-1)", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        backup.step(-1, function(err) {
-            if (err) throw err;
-            assert.fileExists("test/tmp/backup.db");
-            backup.finish(function(err) {
-                if (err) throw err;
-                assertRowsMatchFile(db, "test/tmp/backup.db", done);
-            });
-        });
-    });
-
-    it ("backup db not created if finished immediately", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        backup.finish(function(err) {
-            if (err) throw err;
-            assert.fileDoesNotExist("test/tmp/backup.db");
-            done();
-        });
-    });
-
-    it ("error closing db if backup not finished", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        db.close(function(err) {
-            db = null;
-            if (!err) throw new Error("should have an error");
-            if (err.errno == sqlite3.BUSY) {
-                done();
-            }
-            else throw err;
-        });
-    });
-
-    it ("using the backup after finished is an error", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        backup.finish(function(err) {
-            if (err) throw err;
-            backup.step(1, function(err) {
-                if (!err) throw new Error("should have an error");
-                if (err.errno == sqlite3.MISUSE &&
-                    err.message === "SQLITE_MISUSE: Backup is already finished") {
-                    done();
-                }
-                else throw err;
-            });
-        });
-    });
-
-    it ("remaining/pageCount are available after call to step", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        backup.step(0, function(err) {
-            if (err) throw err;
-            assert.equal(typeof this.pageCount, "number");
-            assert.equal(typeof this.remaining, "number");
-            assert.equal(this.remaining, this.pageCount);
-            var prevRemaining = this.remaining;
-            var prevPageCount = this.pageCount;
-            backup.step(1, function(err) {
-                if (err) throw err;
-                assert.notEqual(this.remaining, prevRemaining);
-                assert.equal(this.pageCount, prevPageCount);
-                backup.finish(done);
-            });
-        });
-    });
-
-    it ("backup works if database is modified half-way through", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        backup.step(-1, function(err) {
-            if (err) throw err;
-            backup.finish(function(err) {
-                if (err) throw err;
-                var db2 = new sqlite3.Database("test/tmp/backup.db", function(err) {
-                    if (err) throw err;
-                    var backup2 = db2.backup("test/tmp/backup2.db");
-                    backup2.step(1, function(err, completed) {
-                        if (err) throw err;
-                        assert.equal(completed, false);  // Page size for the test db
-                        // should not be raised to high.
-                        db2.exec("insert into foo(txt) values('hello')", function(err) {
-                            if (err) throw err;
-                            backup2.step(-1, function(err, completed) {
-                                if (err) throw err;
-                                assert.equal(completed, true);
-                                assertRowsMatchFile(db2, "test/tmp/backup2.db", function() {
-                                    backup2.finish(function(err) {
-                                        if (err) throw err;
-                                        db2.close(done);
-                                    });
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-    });
-
-    (sqlite3.VERSION_NUMBER < 3026000 ? it.skip : it) ("can backup from temp to main", function(done) {
-        db.exec("CREATE TEMP TABLE space (txt TEXT)", function(err) {
-            if (err) throw err;
-            db.exec("INSERT INTO space(txt) VALUES('monkey')", function(err) {
-                if (err) throw err;
-                var backup = db.backup("test/tmp/backup.db", "temp", "main", true, function(err) {
-                    if (err) throw err;
-                    backup.step(-1, function(err) {
-                        if (err) throw err;
-                        backup.finish(function(err) {
-                            if (err) throw err;
-                            var db2 = new sqlite3.Database("test/tmp/backup.db", function(err) {
-                                if (err) throw err;
-                                db2.get("SELECT * FROM space", function(err, row) {
-                                    if (err) throw err;
-                                    assert.equal(row.txt, "monkey");
-                                    db2.close(done);
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-    });
-
-    (sqlite3.VERSION_NUMBER < 3026000 ? it.skip : it) ("can backup from main to temp", function(done) {
-        var backup = db.backup("test/support/prepare.db", "main", "temp", false, function(err) {
-            if (err) throw err;
-            backup.step(-1, function(err) {
-                if (err) throw err;
-                backup.finish(function(err) {
-                    if (err) throw err;
-                    assertRowsMatchDb(db, "temp.foo", db, "main.foo", done);
-                });
-            });
-        });
-    });
-
-    it ("cannot backup to a locked db", function(done) {
-        var db2 = new sqlite3.Database("test/tmp/backup.db", function(err) {
-            db2.exec("PRAGMA locking_mode = EXCLUSIVE");
-            db2.exec("BEGIN EXCLUSIVE", function(err) {
-                if (err) throw err;
-                var backup = db.backup("test/tmp/backup.db");
-                backup.step(-1, function(stepErr) {
-                    db2.close(function(err) {
-                        if (err) throw err;
-                        if (stepErr.errno == sqlite3.BUSY) {
-                            backup.finish(done);
-                        }
-                        else throw stepErr;
-                    });
-                });
-            });
-        });
-    });
-
-    it ("fuss-free incremental backups work", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        var timer;
-        function makeProgress() {
-            if (backup.idle) {
-                backup.step(1);
-            }
-            if (backup.completed || backup.failed) {
-                clearInterval(timer);
-                assert.equal(backup.completed, true);
-                assert.equal(backup.failed, false);
-                done();
-            }
-        }
-        timer = setInterval(makeProgress, 2);
-    });
-
-    it ("setting retryErrors to empty disables automatic finishing", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        backup.retryErrors = [];
-        backup.step(-1, function(err) {
-            if (err) throw err;
-            db.close(function(err) {
-                db = null;
-                if (!err) throw new Error("should have an error");
-                assert.equal(err.errno, sqlite3.BUSY);
-                done();
-            });
-        });
-    });
-
-    it ("setting retryErrors enables automatic finishing", function(done) {
-        var backup = db.backup("test/tmp/backup.db");
-        backup.retryErrors = [sqlite3.OK];
-        backup.step(-1, function(err) {
-            if (err) throw err;
-            db.close(function(err) {
-                if (err) throw err;
-                db = null;
-                done();
-            });
-        });
-    });
-
-    it ("default retryErrors will retry on a locked/busy db", function(done) {
-        var db2 = new sqlite3.Database("test/tmp/backup.db", function(err) {
-            db2.exec("PRAGMA locking_mode = EXCLUSIVE");
-            db2.exec("BEGIN EXCLUSIVE", function(err) {
-                if (err) throw err;
-                var backup = db.backup("test/tmp/backup.db");
-                backup.step(-1, function(stepErr) {
-                    db2.close(function(err) {
-                        if (err) throw err;
-                        assert.equal(stepErr.errno, sqlite3.BUSY);
-                        assert.equal(backup.completed, false);
-                        assert.equal(backup.failed, false);
-                        backup.step(-1, function(err) {
-                            if (err) throw err;
-                            assert.equal(backup.completed, true);
-                            assert.equal(backup.failed, false);
-                            done();
-                        });
-                    });
-                });
-            });
-        });
-    });
-});

package/test/blob.test.js

@@ -1,54 +0,0 @@
-var sqlite3 = require(".."),
-    fs = require("fs"),
-    assert = require("assert"),
-    Buffer = require("buffer").Buffer;
-
-// lots of elmo
-var elmo = fs.readFileSync(__dirname + "/support/elmo.png");
-
-describe("blob", function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(":memory:");
-        db.run("CREATE TABLE elmos (id INT, image BLOB)", done);
-    });
-
-    var total = 10;
-    var inserted = 0;
-    var retrieved = 0;
-
-
-    it("should insert blobs", function(done) {
-        for (var i = 0; i < total; i++) {
-            db.run("INSERT INTO elmos (id, image) VALUES (?, ?)", i, elmo, function(err) {
-                if (err) throw err;
-                inserted++;
-            });
-        }
-        db.wait(function() {
-            assert.equal(inserted, total);
-            done();
-        });
-    });
-
-    it("should retrieve the blobs", function(done) {
-        db.all("SELECT id, image FROM elmos ORDER BY id", function(err, rows) {
-            if (err) throw err;
-            for (var i = 0; i < rows.length; i++) {
-                assert.ok(Buffer.isBuffer(rows[i].image));
-                assert.ok(elmo.length, rows[i].image);
-
-                for (var j = 0; j < elmo.length; j++) {
-                    if (elmo[j] !== rows[i].image[j]) {
-                        assert.ok(false, "Wrong byte");
-                    }
-                }
-
-                retrieved++;
-            }
-
-            assert.equal(retrieved, total);
-            done();
-        });
-    });
-});

package/test/cache.test.js

@@ -1,42 +0,0 @@
-var sqlite3 = require("..");
-var assert = require("assert");
-var helper = require("./support/helper");
-
-describe("cache", function() {
-    before(function() {
-        helper.ensureExists("test/tmp");
-    });
-
-    it("should cache Database objects while opening", function(done) {
-        var filename = "test/tmp/test_cache.db";
-        helper.deleteFile(filename);
-        var opened1 = false, opened2 = false;
-        var db1 = new sqlite3.cached.Database(filename, function(err) {
-            if (err) throw err;
-            opened1 = true;
-            if (opened1 && opened2) done();
-        });
-        var db2 = new sqlite3.cached.Database(filename, function(err) {
-            if (err) throw err;
-            opened2 = true;
-            if (opened1 && opened2) done();
-        });
-        assert.equal(db1, db2);
-    });
-
-    it("should cache Database objects after they are open", function(done) {
-        var filename = "test/tmp/test_cache2.db";
-        helper.deleteFile(filename);
-        var db1, db2;
-        db1 = new sqlite3.cached.Database(filename, function(err) {
-            if (err) throw err;
-            process.nextTick(function() {
-                db2 = new sqlite3.cached.Database(filename, function(err) {
-                    done();
-
-                });
-                assert.equal(db1, db2);
-            });
-        });
-    });
-});

package/test/constants.test.js

@@ -1,44 +0,0 @@
-var sqlite3 = require("..");
-var assert = require("assert");
-
-describe("constants", function() {
-    it("should have the right OPEN_* flags", function() {
-        assert.ok(sqlite3.OPEN_READONLY === 1);
-        assert.ok(sqlite3.OPEN_READWRITE === 2);
-        assert.ok(sqlite3.OPEN_CREATE === 4);
-        assert.ok(sqlite3.OPEN_URI === 0x00000040);
-        assert.ok(sqlite3.OPEN_FULLMUTEX === 0x00010000);
-        assert.ok(sqlite3.OPEN_SHAREDCACHE === 0x00020000);
-        assert.ok(sqlite3.OPEN_PRIVATECACHE === 0x00040000);
-    });
-
-    it("should have the right error flags", function() {
-        assert.ok(sqlite3.OK === 0);
-        assert.ok(sqlite3.ERROR === 1);
-        assert.ok(sqlite3.INTERNAL === 2);
-        assert.ok(sqlite3.PERM === 3);
-        assert.ok(sqlite3.ABORT === 4);
-        assert.ok(sqlite3.BUSY === 5);
-        assert.ok(sqlite3.LOCKED === 6);
-        assert.ok(sqlite3.NOMEM === 7);
-        assert.ok(sqlite3.READONLY === 8);
-        assert.ok(sqlite3.INTERRUPT === 9);
-        assert.ok(sqlite3.IOERR === 10);
-        assert.ok(sqlite3.CORRUPT === 11);
-        assert.ok(sqlite3.NOTFOUND === 12);
-        assert.ok(sqlite3.FULL === 13);
-        assert.ok(sqlite3.CANTOPEN === 14);
-        assert.ok(sqlite3.PROTOCOL === 15);
-        assert.ok(sqlite3.EMPTY === 16);
-        assert.ok(sqlite3.SCHEMA === 17);
-        assert.ok(sqlite3.TOOBIG === 18);
-        assert.ok(sqlite3.CONSTRAINT === 19);
-        assert.ok(sqlite3.MISMATCH === 20);
-        assert.ok(sqlite3.MISUSE === 21);
-        assert.ok(sqlite3.NOLFS === 22);
-        assert.ok(sqlite3.AUTH === 23);
-        assert.ok(sqlite3.FORMAT === 24);
-        assert.ok(sqlite3.RANGE === 25);
-        assert.ok(sqlite3.NOTADB === 26);
-    });
-});