sqlite: remove statement.set* functions

doc/api/sqlite.md

@@ -933,73 +933,6 @@ This method executes a prepared statement and returns an object summarizing the
 resulting changes. The prepared statement [parameters are bound][] using the
 values in `namedParameters` and `anonymousParameters`.
 
-### `statement.setAllowBareNamedParameters(enabled)`
-
-<!-- YAML
-added: v22.5.0
--->
-
-* `enabled` {boolean} Enables or disables support for binding named parameters
-  without the prefix character.
-
-The names of SQLite parameters begin with a prefix character. By default,
-`node:sqlite` requires that this prefix character is present when binding
-parameters. However, with the exception of dollar sign character, these
-prefix characters also require extra quoting when used in object keys.
-
-To improve ergonomics, this method can be used to also allow bare named
-parameters, which do not require the prefix character in JavaScript code. There
-are several caveats to be aware of when enabling bare named parameters:
-
-* The prefix character is still required in SQL.
-* The prefix character is still allowed in JavaScript. In fact, prefixed names
-  will have slightly better binding performance.
-* Using ambiguous named parameters, such as `$k` and `@k`, in the same prepared
-  statement will result in an exception as it cannot be determined how to bind
-  a bare name.
-
-### `statement.setAllowUnknownNamedParameters(enabled)`
-
-<!-- YAML
-added:
-  - v23.11.0
-  - v22.15.0
--->
-
-* `enabled` {boolean} Enables or disables support for unknown named parameters.
-
-By default, if an unknown name is encountered while binding parameters, an
-exception is thrown. This method allows unknown named parameters to be ignored.
-
-### `statement.setReturnArrays(enabled)`
-
-<!-- YAML
-added:
-  - v24.0.0
-  - v22.16.0
--->
-
-* `enabled` {boolean} Enables or disables the return of query results as arrays.
-
-When enabled, query results returned by the `all()`, `get()`, and `iterate()` methods will be returned as arrays instead
-of objects.
-
-### `statement.setReadBigInts(enabled)`
-
-<!-- YAML
-added: v22.5.0
--->
-
-* `enabled` {boolean} Enables or disables the use of `BigInt`s when reading
-  `INTEGER` fields from the database.
-
-When reading from the database, SQLite `INTEGER`s are mapped to JavaScript
-numbers by default. However, SQLite `INTEGER`s can store values larger than
-JavaScript numbers are capable of representing. In such cases, this method can
-be used to read `INTEGER` data using JavaScript `BigInt`s. This method has no
-impact on database write operations where numbers and `BigInt`s are both
-supported at all times.
-
 ### `statement.sourceSQL`
 
 <!-- YAML

src/node_sqlite.cc

@@ -2711,73 +2711,6 @@ 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));
 }
@@ -3126,18 +3059,6 @@ Local<FunctionTemplate> StatementSync::GetConstructorTemplate(
                             tmpl,
                             FIXED_ONE_BYTE_STRING(isolate, "expandedSQL"),
                             StatementSync::ExpandedSQLGetter);
-    SetProtoMethod(isolate,
-                   tmpl,
-                   "setAllowBareNamedParameters",
-                   StatementSync::SetAllowBareNamedParameters);
-    SetProtoMethod(isolate,
-                   tmpl,
-                   "setAllowUnknownNamedParameters",
-                   StatementSync::SetAllowUnknownNamedParameters);
-    SetProtoMethod(
-        isolate, tmpl, "setReadBigInts", StatementSync::SetReadBigInts);
-    SetProtoMethod(
-        isolate, tmpl, "setReturnArrays", StatementSync::SetReturnArrays);
     env->set_sqlite_statement_sync_constructor_template(tmpl);
   }
   return tmpl;

src/node_sqlite.h

@@ -220,12 +220,6 @@ 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,47 +79,6 @@ suite('named parameters', () => {
   });
 });
 
-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)');
-    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 },
-    );
-    t.assert.strictEqual(stmt.setAllowUnknownNamedParameters(false), undefined);
-    t.assert.throws(() => {
-      stmt.run(params);
-    }, {
-      code: 'ERR_INVALID_STATE',
-      message: /Unknown named parameter '\$a'/,
-    });
-  });
-
-  test('throws when input is not a boolean', (t) => {
-    const db = new DatabaseSync(':memory:');
-    t.after(() => { db.close(); });
-    const setup = db.exec(
-      '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(() => {
-      stmt.setAllowUnknownNamedParameters();
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: /The "enabled" argument must be a boolean/,
-    });
-  });
-});
-
 suite('options.allowUnknownNamedParameters', () => {
   test('unknown named parameters are allowed when input is true', (t) => {
     const db = new DatabaseSync(':memory:');
@@ -193,29 +152,4 @@ suite('options.allowUnknownNamedParameters', () => {
       message: /The "options\.allowUnknownNamedParameters" argument must be a boolean/,
     });
   });
-
-  test('setAllowUnknownNamedParameters can override prepare option', (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 params = { $a: 1, $b: 2, $k: 42, $y: 25, $v: 84, $z: 99 };
-    t.assert.deepStrictEqual(
-      stmt.run(params),
-      { changes: 1, lastInsertRowid: 1 },
-    );
-    t.assert.strictEqual(stmt.setAllowUnknownNamedParameters(false), undefined);
-    t.assert.throws(() => {
-      stmt.run(params);
-    }, {
-      code: 'ERR_INVALID_STATE',
-      message: /Unknown named parameter '\$a'/,
-    });
-  });
 });