sqlite: revert set methods

Author: araujogui

src/node_sqlite.cc

@@ -2687,6 +2687,73 @@ void StatementSync::ExpandedSQLGetter(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(result);
 }
 
+void StatementSync::SetAllowBareNamedParameters(
+    const FunctionCallbackInfo<Value>& args) {
+  StatementSync* stmt;
+  ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, stmt->IsFinalized(), "statement has been finalized");
+
+  if (!args[0]->IsBoolean()) {
+    THROW_ERR_INVALID_ARG_TYPE(
+        env->isolate(),
+        "The \"allowBareNamedParameters\" argument must be a boolean.");
+    return;
+  }
+
+  stmt->allow_bare_named_params_ = args[0]->IsTrue();
+}
+
+void StatementSync::SetAllowUnknownNamedParameters(
+    const FunctionCallbackInfo<Value>& args) {
+  StatementSync* stmt;
+  ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, stmt->IsFinalized(), "statement has been finalized");
+
+  if (!args[0]->IsBoolean()) {
+    THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
+                               "The \"enabled\" argument must be a boolean.");
+    return;
+  }
+
+  stmt->allow_unknown_named_params_ = args[0]->IsTrue();
+}
+
+void StatementSync::SetReadBigInts(const FunctionCallbackInfo<Value>& args) {
+  StatementSync* stmt;
+  ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, stmt->IsFinalized(), "statement has been finalized");
+
+  if (!args[0]->IsBoolean()) {
+    THROW_ERR_INVALID_ARG_TYPE(
+        env->isolate(), "The \"readBigInts\" argument must be a boolean.");
+    return;
+  }
+
+  stmt->use_big_ints_ = args[0]->IsTrue();
+}
+
+void StatementSync::SetReturnArrays(const FunctionCallbackInfo<Value>& args) {
+  StatementSync* stmt;
+  ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, stmt->IsFinalized(), "statement has been finalized");
+
+  if (!args[0]->IsBoolean()) {
+    THROW_ERR_INVALID_ARG_TYPE(
+        env->isolate(), "The \"returnArrays\" argument must be a boolean.");
+    return;
+  }
+
+  stmt->return_arrays_ = args[0]->IsTrue();
+}
+
 void IllegalConstructor(const FunctionCallbackInfo<Value>& args) {
   THROW_ERR_ILLEGAL_CONSTRUCTOR(Environment::GetCurrent(args));
 }

src/node_sqlite.h

@@ -220,6 +220,12 @@ class StatementSync : public BaseObject {
   static void SourceSQLGetter(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ExpandedSQLGetter(
       const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetAllowBareNamedParameters(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetAllowUnknownNamedParameters(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetReadBigInts(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetReturnArrays(const v8::FunctionCallbackInfo<v8::Value>& args);
   v8::MaybeLocal<v8::Value> ColumnToValue(const int column);
   v8::MaybeLocal<v8::Name> ColumnNameToName(const int column);
   void Finalize();

test/parallel/test-sqlite-named-parameters.js

@@ -79,33 +79,22 @@ suite('named parameters', () => {
   });
 });
 
-suite('allowUnknownNamedParameters', () => {
-  test('unknown named parameters can be allowed', (t) => {
+suite('StatementSync.prototype.setAllowUnknownNamedParameters()', () => {
+  test('unknown named parameter support can be toggled', (t) => {
     const db = new DatabaseSync(':memory:');
     t.after(() => { db.close(); });
     const setup = db.exec(
       'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
     );
     t.assert.strictEqual(setup, undefined);
-    const stmt = db.prepare('INSERT INTO data (key, val) VALUES ($k, $v)', {
-      allowUnknownNamedParameters: true,
-    });
+    const stmt = db.prepare('INSERT INTO data (key, val) VALUES ($k, $v)');
+    t.assert.strictEqual(stmt.setAllowUnknownNamedParameters(true), undefined);
     const params = { $a: 1, $b: 2, $k: 42, $y: 25, $v: 84, $z: 99 };
     t.assert.deepStrictEqual(
       stmt.run(params),
       { changes: 1, lastInsertRowid: 1 },
     );
-  });
-
-  test('unknown named parameters are rejected by default', (t) => {
-    const db = new DatabaseSync(':memory:');
-    t.after(() => { db.close(); });
-    const setup = db.exec(
-      'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
-    );
-    t.assert.strictEqual(setup, undefined);
-    const stmt = db.prepare('INSERT INTO data (key, val) VALUES ($k, $v)');
-    const params = { $a: 1, $b: 2, $k: 42, $y: 25, $v: 84, $z: 99 };
+    t.assert.strictEqual(stmt.setAllowUnknownNamedParameters(false), undefined);
     t.assert.throws(() => {
       stmt.run(params);
     }, {
@@ -121,13 +110,12 @@ suite('allowUnknownNamedParameters', () => {
       'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
     );
     t.assert.strictEqual(setup, undefined);
+    const stmt = db.prepare('INSERT INTO data (key, val) VALUES ($k, $v)');
     t.assert.throws(() => {
-      db.prepare('INSERT INTO data (key, val) VALUES ($k, $v)', {
-        allowUnknownNamedParameters: 'true',
-      });
+      stmt.setAllowUnknownNamedParameters();
     }, {
       code: 'ERR_INVALID_ARG_TYPE',
-      message: /The "options\.allowUnknownNamedParameters" argument must be a boolean/,
+      message: /The "enabled" argument must be a boolean/,
     });
   });
 });