sqlite: add readOnly option

Allow opening existing SQLite databases with SQLITE_OPEN_READONLY set.

PR-URL: nodejs#55567
Reviewed-By: Colin Ihrig <[email protected]>
Reviewed-By: Rafael Gonzaga <[email protected]>

Author: tniessen

doc/api/sqlite.md

@@ -107,6 +107,8 @@ added: v22.5.0
   * `open` {boolean} If `true`, the database is opened by the constructor. When
     this value is `false`, the database must be opened via the `open()` method.
     **Default:** `true`.
+  * `readOnly` {boolean} If `true`, the database is opened in read-only mode.
+    If the database does not exist, opening it will fail. **Default:** `false`.
   * `enableForeignKeyConstraints` {boolean} If `true`, foreign key constraints
     are enabled. This is recommended but can be disabled for compatibility with
     legacy database schemas. The enforcement of foreign key constraints can be

src/node_sqlite.cc

@@ -138,7 +138,9 @@ bool DatabaseSync::Open() {
   }
 
   // TODO(cjihrig): Support additional flags.
-  int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
+  int flags = open_config_.get_read_only()
+                  ? SQLITE_OPEN_READONLY
+                  : SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
   int r = sqlite3_open_v2(
       open_config_.location().c_str(), &connection_, flags, nullptr);
   CHECK_ERROR_OR_THROW(env()->isolate(), connection_, r, SQLITE_OK, false);
@@ -231,6 +233,22 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
       open = open_v.As<Boolean>()->Value();
     }
 
+    Local<String> read_only_string =
+        FIXED_ONE_BYTE_STRING(env->isolate(), "readOnly");
+    Local<Value> read_only_v;
+    if (!options->Get(env->context(), read_only_string).ToLocal(&read_only_v)) {
+      return;
+    }
+    if (!read_only_v->IsUndefined()) {
+      if (!read_only_v->IsBoolean()) {
+        node::THROW_ERR_INVALID_ARG_TYPE(
+            env->isolate(),
+            "The \"options.readOnly\" argument must be a boolean.");
+        return;
+      }
+      open_config.set_read_only(read_only_v.As<Boolean>()->Value());
+    }
+
     Local<String> enable_foreign_keys_string =
         FIXED_ONE_BYTE_STRING(env->isolate(), "enableForeignKeyConstraints");
     Local<Value> enable_foreign_keys_v;

src/node_sqlite.h

@@ -23,6 +23,10 @@ class DatabaseOpenConfiguration {
 
   inline const std::string& location() const { return location_; }
 
+  inline bool get_read_only() const { return read_only_; }
+
+  inline void set_read_only(bool flag) { read_only_ = flag; }
+
   inline bool get_enable_foreign_keys() const { return enable_foreign_keys_; }
 
   inline void set_enable_foreign_keys(bool flag) {
@@ -35,6 +39,7 @@ class DatabaseOpenConfiguration {
 
  private:
   std::string location_;
+  bool read_only_ = false;
   bool enable_foreign_keys_ = true;
   bool enable_dqs_ = false;
 };

test/parallel/test-sqlite-database-sync.js

@@ -51,6 +51,39 @@ suite('DatabaseSync() constructor', () => {
     });
   });
 
+  test('throws if options.readOnly is provided but is not a boolean', (t) => {
+    t.assert.throws(() => {
+      new DatabaseSync('foo', { readOnly: 5 });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /The "options\.readOnly" argument must be a boolean/,
+    });
+  });
+
+  test('is not read-only by default', (t) => {
+    const dbPath = nextDb();
+    const db = new DatabaseSync(dbPath);
+    db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
+  });
+
+  test('is read-only if readOnly is set', (t) => {
+    const dbPath = nextDb();
+    {
+      const db = new DatabaseSync(dbPath);
+      db.exec('CREATE TABLE foo (id INTEGER PRIMARY KEY)');
+      db.close();
+    }
+    {
+      const db = new DatabaseSync(dbPath, { readOnly: true });
+      t.assert.throws(() => {
+        db.exec('CREATE TABLE bar (id INTEGER PRIMARY KEY)');
+      }, {
+        code: 'ERR_SQLITE_ERROR',
+        message: /attempt to write a readonly database/,
+      });
+    }
+  });
+
   test('throws if options.enableForeignKeyConstraints is provided but is not a boolean', (t) => {
     t.assert.throws(() => {
       new DatabaseSync('foo', { enableForeignKeyConstraints: 5 });