support sqlite3_limit(id, value) via db.configure('limit', id, value)

This extends `db.configure` to support the `sqlite3_limit` method.
Calling `db.configure('limit', sqlite3.LIMIT_XXX, value)` is equivalent to
calling `sqlite3_limit(db, SQLITE_LIMIT_XXX, value)`.

For example, to prohibit attaching extra databases on a given database
connection, you'd call `db.configure('limit', sqlite3.LIMIT_ATTACHED, 0)`.

Author: paulfitz

src/database.cc

@@ -369,6 +369,22 @@ Napi::Value Database::Configure(const Napi::CallbackInfo& info) {
         baton->status = info[1].As<Napi::Number>().Int32Value();
         db->Schedule(SetBusyTimeout, baton);
     }
+    else if (info[0].StrictEquals( Napi::String::New(env, "limit"))) {
+        REQUIRE_ARGUMENTS(3);
+        if (!info[1].IsNumber()) {
+            Napi::TypeError::New(env, "limit id must be an integer").ThrowAsJavaScriptException();
+            return env.Null();
+        }
+        if (!info[2].IsNumber()) {
+            Napi::TypeError::New(env, "limit value must be an integer").ThrowAsJavaScriptException();
+            return env.Null();
+        }
+        Napi::Function handle;
+        int id = info[1].As<Napi::Number>().Int32Value();
+        int value = info[2].As<Napi::Number>().Int32Value();
+        Baton* baton = new LimitBaton(db, handle, id, value);
+        db->Schedule(SetLimit, baton);
+    }
     else {
         Napi::TypeError::New(env, (StringConcat(
 #if V8_MAJOR_VERSION > 6
@@ -413,6 +429,15 @@ void Database::SetBusyTimeout(Baton* b) {
     sqlite3_busy_timeout(baton->db->_handle, baton->status);
 }
 
+void Database::SetLimit(Baton* b) {
+    std::unique_ptr<LimitBaton> baton(static_cast<LimitBaton*>(b));
+
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+
+    sqlite3_limit(baton->db->_handle, baton->id, baton->value);
+}
+
 void Database::RegisterTraceCallback(Baton* b) {
     std::unique_ptr<Baton> baton(b);
     assert(baton->db->open);

src/database.h

@@ -80,6 +80,13 @@ class Database : public Napi::ObjectWrap<Database> {
             Baton(db_, cb_), filename(filename_) {}
     };
 
+    struct LimitBaton : Baton {
+        int id;
+        int value;
+        LimitBaton(Database* db_, Napi::Function cb_, int id_, int value_) :
+            Baton(db_, cb_), id(id_), value(value_) {}
+    };
+
     typedef void (*Work_Callback)(Baton* baton);
 
     struct Call {
@@ -169,6 +176,7 @@ class Database : public Napi::ObjectWrap<Database> {
     Napi::Value Interrupt(const Napi::CallbackInfo& info);
 
     static void SetBusyTimeout(Baton* baton);
+    static void SetLimit(Baton* baton);
 
     static void RegisterTraceCallback(Baton* baton);
     static void TraceCallback(void* db, const char* sql);

src/node_sqlite3.cc

@@ -61,6 +61,19 @@ Napi::Object RegisterModule(Napi::Env env, Napi::Object exports) {
         DEFINE_CONSTANT_INTEGER(exports, SQLITE_FORMAT, FORMAT)
         DEFINE_CONSTANT_INTEGER(exports, SQLITE_RANGE, RANGE)
         DEFINE_CONSTANT_INTEGER(exports, SQLITE_NOTADB, NOTADB)
+
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_LENGTH, LIMIT_LENGTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_SQL_LENGTH, LIMIT_SQL_LENGTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_COLUMN, LIMIT_COLUMN)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_EXPR_DEPTH, LIMIT_EXPR_DEPTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_COMPOUND_SELECT, LIMIT_COMPOUND_SELECT)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_VDBE_OP, LIMIT_VDBE_OP)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_FUNCTION_ARG, LIMIT_FUNCTION_ARG)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_ATTACHED, LIMIT_ATTACHED)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_LIKE_PATTERN_LENGTH, LIMIT_LIKE_PATTERN_LENGTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_VARIABLE_NUMBER, LIMIT_VARIABLE_NUMBER)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_TRIGGER_DEPTH, LIMIT_TRIGGER_DEPTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_WORKER_THREADS, LIMIT_WORKER_THREADS)
     });
 
     return exports;

test/limit.test.js

@@ -0,0 +1,28 @@
+var sqlite3 = require('..');
+
+describe('limit', function() {
+    var db;
+
+    before(function(done) {
+        db = new sqlite3.Database(':memory:', done);
+    });
+
+    it('should support applying limits via configure', function(done) {
+        db.configure('limit', sqlite3.LIMIT_ATTACHED, 0);
+        db.exec("ATTACH 'test/support/prepare.db' AS zing", function(err) {
+            if (!err) {
+                throw new Error('ATTACH should not succeed');
+            }
+            if (err.errno === sqlite3.ERROR &&
+                err.message === 'SQLITE_ERROR: too many attached databases - max 0') {
+                db.configure('limit', sqlite3.LIMIT_ATTACHED, 1);
+                db.exec("ATTACH 'test/support/prepare.db' AS zing", function(err) {
+                    if (err) throw err;
+                    db.close(done);
+                });
+            } else {
+                throw err;
+            }
+        });
+    });
+});