From b5e071232910a8f1577d96e23e9ef3b0892d3745 Mon Sep 17 00:00:00 2001
From: mike-git374 <217764531+mike-git374@users.noreply.github.com>
Date: Sat, 21 Feb 2026 13:43:24 -0700
Subject: [PATCH] sqlite: remove statement.set* functions

---
 doc/api/sqlite.md                             |  67 -----
 src/node_sqlite.cc                            |  79 ------
 src/node_sqlite.h                             |   6 -
 test/parallel/test-sqlite-named-parameters.js |  66 -----
 test/parallel/test-sqlite-statement-sync.js   | 239 +-----------------
 5 files changed, 9 insertions(+), 448 deletions(-)

diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index 5cafacdc7623e9..b1080d3acc9f41 100644
--- a/doc/api/sqlite.md
+++ b/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
diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index fb229e19fd6aef..f8d99de608a67e 100644
--- a/src/node_sqlite.cc
+++ b/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;
diff --git a/src/node_sqlite.h b/src/node_sqlite.h
index bd61fcd6ebcd4d..d27f9b3524d2f0 100644
--- a/src/node_sqlite.h
+++ b/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();
diff --git a/test/parallel/test-sqlite-named-parameters.js b/test/parallel/test-sqlite-named-parameters.js
index db8f46e6b6ce5a..9c961bac3a4023 100644
--- a/test/parallel/test-sqlite-named-parameters.js
+++ b/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'/,
-    });
-  });
 });
diff --git a/test/parallel/test-sqlite-statement-sync.js b/test/parallel/test-sqlite-statement-sync.js
index 62e95363f1c46a..67398e18a18aa6 100644
--- a/test/parallel/test-sqlite-statement-sync.js
+++ b/test/parallel/test-sqlite-statement-sync.js
@@ -305,95 +305,8 @@ suite('StatementSync.prototype.expandedSQL', () => {
   });
 });
 
-suite('StatementSync.prototype.setReadBigInts()', () => {
-  test('BigInts support can be toggled', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
-    const setup = db.exec(`
-      CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
-      INSERT INTO data (key, val) VALUES (1, 42);
-    `);
-    t.assert.strictEqual(setup, undefined);
-
-    const query = db.prepare('SELECT val FROM data');
-    t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42 });
-    t.assert.strictEqual(query.setReadBigInts(true), undefined);
-    t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42n });
-    t.assert.strictEqual(query.setReadBigInts(false), undefined);
-    t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42 });
-
-    const insert = db.prepare('INSERT INTO data (key) VALUES (?)');
-    t.assert.deepStrictEqual(
-      insert.run(10),
-      { changes: 1, lastInsertRowid: 10 },
-    );
-    t.assert.strictEqual(insert.setReadBigInts(true), undefined);
-    t.assert.deepStrictEqual(
-      insert.run(20),
-      { changes: 1n, lastInsertRowid: 20n },
-    );
-    t.assert.strictEqual(insert.setReadBigInts(false), undefined);
-    t.assert.deepStrictEqual(
-      insert.run(30),
-      { changes: 1, lastInsertRowid: 30 },
-    );
-  });
-
-  test('throws when input is not a boolean', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
-    const setup = db.exec(
-      'CREATE TABLE types(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
-    );
-    t.assert.strictEqual(setup, undefined);
-    const stmt = db.prepare('INSERT INTO types (key, val) VALUES ($k, $v)');
-    t.assert.throws(() => {
-      stmt.setReadBigInts();
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: /The "readBigInts" argument must be a boolean/,
-    });
-  });
-
-  test('BigInt is required for reading large integers', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
-    const bad = db.prepare(`SELECT ${Number.MAX_SAFE_INTEGER} + 1`);
-    t.assert.throws(() => {
-      bad.get();
-    }, {
-      code: 'ERR_OUT_OF_RANGE',
-      message: /^Value is too large to be represented as a JavaScript number: 9007199254740992$/,
-    });
-    const good = db.prepare(`SELECT ${Number.MAX_SAFE_INTEGER} + 1`);
-    good.setReadBigInts(true);
-    t.assert.deepStrictEqual(good.get(), {
-      __proto__: null,
-      [`${Number.MAX_SAFE_INTEGER} + 1`]: 2n ** 53n,
-    });
-  });
-});
-
-suite('StatementSync.prototype.setReturnArrays()', () => {
-  test('throws when input is not a boolean', (t) => {
-    const db = new DatabaseSync(nextDb());
-    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('SELECT key, val FROM data');
-    t.assert.throws(() => {
-      stmt.setReturnArrays();
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: /The "returnArrays" argument must be a boolean/,
-    });
-  });
-});
-
 suite('StatementSync.prototype.get() with array output', () => {
-  test('returns array row when setReturnArrays is true', (t) => {
+  test('returns array row when returnArrays is true', (t) => {
     const db = new DatabaseSync(nextDb());
     t.after(() => { db.close(); });
     const setup = db.exec(`
@@ -402,14 +315,8 @@ suite('StatementSync.prototype.get() with array output', () => {
     `);
     t.assert.strictEqual(setup, undefined);
 
-    const query = db.prepare('SELECT key, val FROM data WHERE key = 1');
-    t.assert.deepStrictEqual(query.get(), { __proto__: null, key: 1, val: 'one' });
-
-    query.setReturnArrays(true);
+    const query = db.prepare('SELECT key, val FROM data WHERE key = 1', { returnArrays: true });
     t.assert.deepStrictEqual(query.get(), [1, 'one']);
-
-    query.setReturnArrays(false);
-    t.assert.deepStrictEqual(query.get(), { __proto__: null, key: 1, val: 'one' });
   });
 
   test('returns array rows with BigInts when both flags are set', (t) => {
@@ -422,9 +329,7 @@ suite('StatementSync.prototype.get() with array output', () => {
     `);
     t.assert.strictEqual(setup, undefined);
 
-    const query = db.prepare('SELECT id, big_num FROM big_data');
-    query.setReturnArrays(true);
-    query.setReadBigInts(true);
+    const query = db.prepare('SELECT id, big_num FROM big_data', { returnArrays: true, readBigInts: true });
 
     const row = query.get();
     t.assert.deepStrictEqual(row, expected);
@@ -432,7 +337,7 @@ suite('StatementSync.prototype.get() with array output', () => {
 });
 
 suite('StatementSync.prototype.all() with array output', () => {
-  test('returns array rows when setReturnArrays is true', (t) => {
+  test('returns array rows when returnArrays is true', (t) => {
     const db = new DatabaseSync(nextDb());
     t.after(() => { db.close(); });
     const setup = db.exec(`
@@ -442,23 +347,12 @@ suite('StatementSync.prototype.all() with array output', () => {
     `);
     t.assert.strictEqual(setup, undefined);
 
-    const query = db.prepare('SELECT key, val FROM data ORDER BY key');
-    t.assert.deepStrictEqual(query.all(), [
-      { __proto__: null, key: 1, val: 'one' },
-      { __proto__: null, key: 2, val: 'two' },
-    ]);
+    const query = db.prepare('SELECT key, val FROM data ORDER BY key', { returnArrays: true });
 
-    query.setReturnArrays(true);
     t.assert.deepStrictEqual(query.all(), [
       [1, 'one'],
       [2, 'two'],
     ]);
-
-    query.setReturnArrays(false);
-    t.assert.deepStrictEqual(query.all(), [
-      { __proto__: null, key: 1, val: 'one' },
-      { __proto__: null, key: 2, val: 'two' },
-    ]);
   });
 
   test('handles array rows with many columns', (t) => {
@@ -488,8 +382,7 @@ suite('StatementSync.prototype.all() with array output', () => {
     `);
     t.assert.strictEqual(setup, undefined);
 
-    const query = db.prepare('SELECT * FROM wide_table');
-    query.setReturnArrays(true);
+    const query = db.prepare('SELECT * FROM wide_table', { returnArrays: true });
 
     const results = query.all();
     t.assert.strictEqual(results.length, 1);
@@ -498,7 +391,7 @@ suite('StatementSync.prototype.all() with array output', () => {
 });
 
 suite('StatementSync.prototype.iterate() with array output', () => {
-  test('iterates array rows when setReturnArrays is true', (t) => {
+  test('iterates array rows when returnArrays is true', (t) => {
     const db = new DatabaseSync(nextDb());
     t.after(() => { db.close(); });
     const setup = db.exec(`
@@ -508,20 +401,8 @@ suite('StatementSync.prototype.iterate() with array output', () => {
     `);
     t.assert.strictEqual(setup, undefined);
 
-    const query = db.prepare('SELECT key, val FROM data ORDER BY key');
+    const query = db.prepare('SELECT key, val FROM data ORDER BY key', { returnArrays: true });
 
-    // Test with objects first
-    const objectRows = [];
-    for (const row of query.iterate()) {
-      objectRows.push(row);
-    }
-    t.assert.deepStrictEqual(objectRows, [
-      { __proto__: null, key: 1, val: 'one' },
-      { __proto__: null, key: 2, val: 'two' },
-    ]);
-
-    // Test with arrays
-    query.setReturnArrays(true);
     const arrayRows = [];
     for (const row of query.iterate()) {
       arrayRows.push(row);
@@ -545,8 +426,7 @@ suite('StatementSync.prototype.iterate() with array output', () => {
       INSERT INTO test (key, val) VALUES ('key1', 'val1');
       INSERT INTO test (key, val) VALUES ('key2', 'val2');
     `);
-    const stmt = db.prepare('SELECT key, val FROM test');
-    stmt.setReturnArrays(true);
+    const stmt = db.prepare('SELECT key, val FROM test', { returnArrays: true });
 
     const iterator = stmt.iterate();
     const results = [];
@@ -566,50 +446,6 @@ suite('StatementSync.prototype.iterate() with array output', () => {
   });
 });
 
-suite('StatementSync.prototype.setAllowBareNamedParameters()', () => {
-  test('bare named parameter support can be toggled', (t) => {
-    const db = new DatabaseSync(nextDb());
-    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.deepStrictEqual(
-      stmt.run({ k: 1, v: 2 }),
-      { changes: 1, lastInsertRowid: 1 },
-    );
-    t.assert.strictEqual(stmt.setAllowBareNamedParameters(false), undefined);
-    t.assert.throws(() => {
-      stmt.run({ k: 2, v: 4 });
-    }, {
-      code: 'ERR_INVALID_STATE',
-      message: /Unknown named parameter 'k'/,
-    });
-    t.assert.strictEqual(stmt.setAllowBareNamedParameters(true), undefined);
-    t.assert.deepStrictEqual(
-      stmt.run({ k: 3, v: 6 }),
-      { changes: 1, lastInsertRowid: 3 },
-    );
-  });
-
-  test('throws when input is not a boolean', (t) => {
-    const db = new DatabaseSync(nextDb());
-    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.setAllowBareNamedParameters();
-    }, {
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: /The "allowBareNamedParameters" argument must be a boolean/,
-    });
-  });
-});
-
 suite('options.readBigInts', () => {
   test('BigInts are returned when input is true', (t) => {
     const db = new DatabaseSync(nextDb());
@@ -651,21 +487,6 @@ suite('options.readBigInts', () => {
       message: /The "options\.readBigInts" argument must be a boolean/,
     });
   });
-
-  test('setReadBigInts can override prepare option', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
-    const setup = db.exec(`
-      CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
-      INSERT INTO data (key, val) VALUES (1, 42);
-    `);
-    t.assert.strictEqual(setup, undefined);
-
-    const query = db.prepare('SELECT val FROM data', { readBigInts: true });
-    t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42n });
-    t.assert.strictEqual(query.setReadBigInts(false), undefined);
-    t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42 });
-  });
 });
 
 suite('options.returnArrays', () => {
@@ -716,24 +537,6 @@ suite('options.returnArrays', () => {
     });
   });
 
-  test('setReturnArrays can override prepare option', (t) => {
-    const db = new DatabaseSync(nextDb());
-    t.after(() => { db.close(); });
-    const setup = db.exec(`
-      CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
-      INSERT INTO data (key, val) VALUES (1, 'one');
-    `);
-    t.assert.strictEqual(setup, undefined);
-
-    const query = db.prepare(
-      'SELECT key, val FROM data WHERE key = 1',
-      { returnArrays: true }
-    );
-    t.assert.deepStrictEqual(query.get(), [1, 'one']);
-    t.assert.strictEqual(query.setReturnArrays(false), undefined);
-    t.assert.deepStrictEqual(query.get(), { __proto__: null, key: 1, val: 'one' });
-  });
-
   test('all() returns arrays when input is true', (t) => {
     const db = new DatabaseSync(nextDb());
     t.after(() => { db.close(); });
@@ -829,28 +632,4 @@ suite('options.allowBareNamedParameters', () => {
       message: /The "options\.allowBareNamedParameters" argument must be a boolean/,
     });
   });
-
-  test('setAllowBareNamedParameters can override prepare option', (t) => {
-    const db = new DatabaseSync(nextDb());
-    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)',
-      { allowBareNamedParameters: false }
-    );
-    t.assert.throws(() => {
-      stmt.run({ k: 1, v: 2 });
-    }, {
-      code: 'ERR_INVALID_STATE',
-      message: /Unknown named parameter 'k'/,
-    });
-    t.assert.strictEqual(stmt.setAllowBareNamedParameters(true), undefined);
-    t.assert.deepStrictEqual(
-      stmt.run({ k: 2, v: 4 }),
-      { changes: 1, lastInsertRowid: 2 },
-    );
-  });
 });