diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md
index bc834483c057a6..6d4250f886b062 100644
--- a/doc/api/sqlite.md
+++ b/doc/api/sqlite.md
@@ -997,6 +997,21 @@ 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.setReadNullAsUndefined(enabled)`
+
+<!-- YAML
+added:
+-->
+
+* `enabled` {boolean} Enables or disables returning SQL `NULL` values as
+  JavaScript `undefined` when reading from the database.
+
+When reading from the database, SQLite `NULL` values are mapped to JavaScript
+`null` by default. This method can be used to instead return `undefined` for
+`NULL` values when materialising result rows. This setting only affects how
+result rows are returned and does not impact values passed to user-defined
+functions or aggregate functions.
+
 ### `statement.sourceSQL`
 
 <!-- YAML
diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc
index 4fad22c618900d..ee7617f0752c79 100644
--- a/src/node_sqlite.cc
+++ b/src/node_sqlite.cc
@@ -72,7 +72,8 @@ using v8::Value;
     }                                                                          \
   } while (0)
 
-#define SQLITE_VALUE_TO_JS(from, isolate, use_big_int_args, result, ...)       \
+#define SQLITE_VALUE_TO_JS(from, isolate, use_big_int_args,                    \
+                           read_null_as_undef, result, ...)                    \
   do {                                                                         \
     switch (sqlite3_##from##_type(__VA_ARGS__)) {                              \
       case SQLITE_INTEGER: {                                                   \
@@ -101,7 +102,9 @@ using v8::Value;
         break;                                                                 \
       }                                                                        \
       case SQLITE_NULL: {                                                      \
-        (result) = Null((isolate));                                            \
+        (result) = (read_null_as_undef)                                        \
+          ? Undefined((isolate))                                               \
+          : Null((isolate));                                                   \
         break;                                                                 \
       }                                                                        \
       case SQLITE_BLOB: {                                                      \
@@ -327,7 +330,7 @@ class CustomAggregate {
     for (int i = 0; i < argc; ++i) {
       sqlite3_value* value = argv[i];
       MaybeLocal<Value> js_val;
-      SQLITE_VALUE_TO_JS(value, isolate, self->use_bigint_args_, js_val, value);
+      SQLITE_VALUE_TO_JS(value, isolate, self->use_bigint_args_, false, js_val, value);
       if (js_val.IsEmpty()) {
         // Ignore the SQLite error because a JavaScript exception is pending.
         self->db_->SetIgnoreNextSQLiteError(true);
@@ -629,7 +632,7 @@ void UserDefinedFunction::xFunc(sqlite3_context* ctx,
   for (int i = 0; i < argc; ++i) {
     sqlite3_value* value = argv[i];
     MaybeLocal<Value> js_val = MaybeLocal<Value>();
-    SQLITE_VALUE_TO_JS(value, isolate, self->use_bigint_args_, js_val, value);
+    SQLITE_VALUE_TO_JS(value, isolate, self->use_bigint_args_, false, js_val, value);
     if (js_val.IsEmpty()) {
       // Ignore the SQLite error because a JavaScript exception is pending.
       self->db_->SetIgnoreNextSQLiteError(true);
@@ -2296,7 +2299,7 @@ bool StatementSync::BindValue(const Local<Value>& value, const int index) {
 
 MaybeLocal<Value> StatementSync::ColumnToValue(const int column) {
   return StatementExecutionHelper::ColumnToValue(
-      env(), statement_, column, use_big_ints_);
+      env(), statement_, column, use_big_ints_, read_null_as_undefined_);
 }
 
 MaybeLocal<Name> StatementSync::ColumnNameToName(const int column) {
@@ -2312,10 +2315,12 @@ MaybeLocal<Name> StatementSync::ColumnNameToName(const int column) {
 MaybeLocal<Value> StatementExecutionHelper::ColumnToValue(Environment* env,
                                                           sqlite3_stmt* stmt,
                                                           const int column,
-                                                          bool use_big_ints) {
+                                                          bool use_big_ints,
+                                                          bool read_null_as_undefined) {
   Isolate* isolate = env->isolate();
   MaybeLocal<Value> js_val = MaybeLocal<Value>();
-  SQLITE_VALUE_TO_JS(column, isolate, use_big_ints, js_val, stmt, column);
+  SQLITE_VALUE_TO_JS(
+      column, isolate, use_big_ints, read_null_as_undefined, js_val, stmt, column);
   return js_val;
 }
 
@@ -2337,12 +2342,13 @@ Maybe<void> ExtractRowValues(Environment* env,
                              sqlite3_stmt* stmt,
                              int num_cols,
                              bool use_big_ints,
+                             bool read_null_as_undefined,
                              LocalVector<Value>* row_values) {
   row_values->clear();
   row_values->reserve(num_cols);
   for (int i = 0; i < num_cols; ++i) {
     Local<Value> val;
-    if (!StatementExecutionHelper::ColumnToValue(env, stmt, i, use_big_ints)
+    if (!StatementExecutionHelper::ColumnToValue(env, stmt, i, use_big_ints, read_null_as_undefined)
              .ToLocal(&val)) {
       return Nothing<void>();
     }
@@ -2355,7 +2361,8 @@ MaybeLocal<Value> StatementExecutionHelper::All(Environment* env,
                                                 DatabaseSync* db,
                                                 sqlite3_stmt* stmt,
                                                 bool return_arrays,
-                                                bool use_big_ints) {
+                                                bool use_big_ints,
+                                                bool read_null_as_undefined) {
   Isolate* isolate = env->isolate();
   EscapableHandleScope scope(isolate);
   int r;
@@ -2365,7 +2372,7 @@ MaybeLocal<Value> StatementExecutionHelper::All(Environment* env,
   LocalVector<Name> row_keys(isolate);
 
   while ((r = sqlite3_step(stmt)) == SQLITE_ROW) {
-    if (ExtractRowValues(env, stmt, num_cols, use_big_ints, &row_values)
+    if (ExtractRowValues(env, stmt, num_cols, use_big_ints, read_null_as_undefined, &row_values)
             .IsNothing()) {
       return MaybeLocal<Value>();
     }
@@ -2470,7 +2477,8 @@ MaybeLocal<Value> StatementExecutionHelper::Get(Environment* env,
                                                 DatabaseSync* db,
                                                 sqlite3_stmt* stmt,
                                                 bool return_arrays,
-                                                bool use_big_ints) {
+                                                bool use_big_ints,
+                                                bool read_null_as_undefined) {
   Isolate* isolate = env->isolate();
   EscapableHandleScope scope(isolate);
   auto reset = OnScopeLeave([&]() { sqlite3_reset(stmt); });
@@ -2488,7 +2496,7 @@ MaybeLocal<Value> StatementExecutionHelper::Get(Environment* env,
   }
 
   LocalVector<Value> row_values(isolate);
-  if (ExtractRowValues(env, stmt, num_cols, use_big_ints, &row_values)
+  if (ExtractRowValues(env, stmt, num_cols, use_big_ints, read_null_as_undefined, &row_values)
           .IsNothing()) {
     return MaybeLocal<Value>();
   }
@@ -2534,7 +2542,8 @@ void StatementSync::All(const FunctionCallbackInfo<Value>& args) {
                                     stmt->db_.get(),
                                     stmt->statement_,
                                     stmt->return_arrays_,
-                                    stmt->use_big_ints_)
+                                    stmt->use_big_ints_,
+                                    stmt->read_null_as_undefined_)
           .ToLocal(&result)) {
     args.GetReturnValue().Set(result);
   }
@@ -2581,7 +2590,8 @@ void StatementSync::Get(const FunctionCallbackInfo<Value>& args) {
                                     stmt->db_.get(),
                                     stmt->statement_,
                                     stmt->return_arrays_,
-                                    stmt->use_big_ints_)
+                                    stmt->use_big_ints_,
+                                    stmt->read_null_as_undefined_)
           .ToLocal(&result)) {
     args.GetReturnValue().Set(result);
   }
@@ -2738,6 +2748,22 @@ void StatementSync::SetReadBigInts(const FunctionCallbackInfo<Value>& args) {
   stmt->use_big_ints_ = args[0]->IsTrue();
 }
 
+void StatementSync::SetReadNullAsUndefined(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 \"readNullAsUndefined\" argument must be a boolean.");
+    return;
+  }
+
+  stmt->read_null_as_undefined_ = args[0]->IsTrue();
+}
+
 void StatementSync::SetReturnArrays(const FunctionCallbackInfo<Value>& args) {
   StatementSync* stmt;
   ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
@@ -2940,7 +2966,8 @@ void SQLTagStore::Get(const FunctionCallbackInfo<Value>& args) {
                                     stmt->db_.get(),
                                     stmt->statement_,
                                     stmt->return_arrays_,
-                                    stmt->use_big_ints_)
+                                    stmt->use_big_ints_,
+                                    stmt->read_null_as_undefined_)
           .ToLocal(&result)) {
     args.GetReturnValue().Set(result);
   }
@@ -2980,7 +3007,8 @@ void SQLTagStore::All(const FunctionCallbackInfo<Value>& args) {
                                     stmt->db_.get(),
                                     stmt->statement_,
                                     stmt->return_arrays_,
-                                    stmt->use_big_ints_)
+                                    stmt->use_big_ints_,
+                                    stmt->read_null_as_undefined_)
           .ToLocal(&result)) {
     args.GetReturnValue().Set(result);
   }
@@ -3114,6 +3142,8 @@ Local<FunctionTemplate> StatementSync::GetConstructorTemplate(
         isolate, tmpl, "setReadBigInts", StatementSync::SetReadBigInts);
     SetProtoMethod(
         isolate, tmpl, "setReturnArrays", StatementSync::SetReturnArrays);
+    SetProtoMethod(
+        isolate, tmpl, "setReadNullAsUndefined", StatementSync::SetReadNullAsUndefined);
     env->set_sqlite_statement_sync_constructor_template(tmpl);
   }
   return tmpl;
@@ -3219,6 +3249,7 @@ void StatementSyncIterator::Next(const FunctionCallbackInfo<Value>& args) {
                        iter->stmt_->statement_,
                        num_cols,
                        iter->stmt_->use_big_ints_,
+                       iter->stmt_->read_null_as_undefined_,
                        &row_values)
           .IsNothing()) {
     return;
diff --git a/src/node_sqlite.h b/src/node_sqlite.h
index 515660bf98999b..83642c058b72b6 100644
--- a/src/node_sqlite.h
+++ b/src/node_sqlite.h
@@ -65,6 +65,14 @@ class DatabaseOpenConfiguration {
     return allow_unknown_named_params_;
   }
 
+  inline void set_read_null_as_undefined(bool flag) {
+    read_null_as_undefined_ = flag;
+  }
+
+  inline bool get_read_null_as_undefined() const {
+    return read_null_as_undefined_;
+  }
+
   inline void set_enable_defensive(bool flag) { defensive_ = flag; }
 
   inline bool get_enable_defensive() const { return defensive_; }
@@ -79,6 +87,7 @@ class DatabaseOpenConfiguration {
   bool return_arrays_ = false;
   bool allow_bare_named_params_ = true;
   bool allow_unknown_named_params_ = false;
+  bool read_null_as_undefined_ = false;
   bool defensive_ = true;
 };
 
@@ -93,7 +102,8 @@ class StatementExecutionHelper {
                                        DatabaseSync* db,
                                        sqlite3_stmt* stmt,
                                        bool return_arrays,
-                                       bool use_big_ints);
+                                       bool use_big_ints,
+                                       bool read_null_as_undefined);
   static v8::MaybeLocal<v8::Object> Run(Environment* env,
                                         DatabaseSync* db,
                                         sqlite3_stmt* stmt,
@@ -103,7 +113,8 @@ class StatementExecutionHelper {
   static v8::MaybeLocal<v8::Value> ColumnToValue(Environment* env,
                                                  sqlite3_stmt* stmt,
                                                  const int column,
-                                                 bool use_big_ints);
+                                                 bool use_big_ints,
+                                                 bool read_null_as_undefined);
   static v8::MaybeLocal<v8::Name> ColumnNameToName(Environment* env,
                                                    sqlite3_stmt* stmt,
                                                    const int column);
@@ -111,7 +122,8 @@ class StatementExecutionHelper {
                                        DatabaseSync* db,
                                        sqlite3_stmt* stmt,
                                        bool return_arrays,
-                                       bool use_big_ints);
+                                       bool use_big_ints,
+                                       bool read_null_as_undefined);
 };
 
 class DatabaseSync : public BaseObject {
@@ -168,6 +180,9 @@ class DatabaseSync : public BaseObject {
   bool allow_unknown_named_params() const {
     return open_config_.get_allow_unknown_named_params();
   }
+  bool read_null_as_undefined() const {
+    return open_config_.get_read_null_as_undefined();
+  }
   sqlite3* Connection();
 
   // In some situations, such as when using custom functions, it is possible
@@ -226,6 +241,8 @@ class StatementSync : public BaseObject {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetReadBigInts(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetReturnArrays(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetReadNullAsUndefined(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   v8::MaybeLocal<v8::Value> ColumnToValue(const int column);
   v8::MaybeLocal<v8::Name> ColumnNameToName(const int column);
   void Finalize();
@@ -242,6 +259,7 @@ class StatementSync : public BaseObject {
   bool use_big_ints_;
   bool allow_bare_named_params_;
   bool allow_unknown_named_params_;
+  bool read_null_as_undefined_;
   std::optional<std::map<std::string, std::string>> bare_named_params_;
   bool BindParams(const v8::FunctionCallbackInfo<v8::Value>& args);
   bool BindValue(const v8::Local<v8::Value>& value, const int index);
diff --git a/test/parallel/test-sqlite-statement-sync.js b/test/parallel/test-sqlite-statement-sync.js
index 62e95363f1c46a..fe88e2d6248cc3 100644
--- a/test/parallel/test-sqlite-statement-sync.js
+++ b/test/parallel/test-sqlite-statement-sync.js
@@ -854,3 +854,108 @@ suite('options.allowBareNamedParameters', () => {
     );
   });
 });
+
+suite('StatementSync.prototype.setReadNullAsUndefined()', () => {
+  test('NULL conversion can be toggled', (t) => {
+    const db = new DatabaseSync(nextDb());
+    t.after(() => { db.close(); });
+
+    db.exec(`
+      CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
+      INSERT INTO data (key, val) VALUES (1, NULL);
+    `);
+
+    const query = db.prepare('SELECT val FROM data WHERE key = 1');
+    t.assert.deepStrictEqual(query.get(), { __proto__: null, val: null });
+
+    t.assert.strictEqual(query.setReadNullAsUndefined(true), undefined);
+    t.assert.deepStrictEqual(query.get(), { __proto__: null, val: undefined });
+
+    t.assert.strictEqual(query.setReadNullAsUndefined(false), undefined);
+    t.assert.deepStrictEqual(query.get(), { __proto__: null, val: null });
+  });
+
+  test('throws when input is not a boolean', (t) => {
+    const db = new DatabaseSync(nextDb());
+    t.after(() => { db.close(); });
+
+    db.exec('CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;');
+
+    const stmt = db.prepare('SELECT val FROM data');
+    t.assert.throws(() => {
+      stmt.setReadNullAsUndefined();
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: /The "readNullAsUndefined" argument must be a boolean/,
+    });
+  });
+
+  test('returns array rows with undefined when both flags are set', (t) => {
+    const db = new DatabaseSync(nextDb());
+    t.after(() => { db.close(); });
+
+    db.exec(`
+      CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
+      INSERT INTO data (key, val) VALUES (1, NULL);
+    `);
+
+    const query = db.prepare('SELECT key, val FROM data WHERE key = 1');
+    query.setReturnArrays(true);
+    query.setReadNullAsUndefined(true);
+
+    t.assert.deepStrictEqual(query.get(), [1, undefined]);
+  });
+
+  test('applies to all()', (t) => {
+    const db = new DatabaseSync(nextDb());
+    t.after(() => { db.close(); });
+
+    db.exec(`
+      CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
+      INSERT INTO data (key, val) VALUES (1, NULL), (2, 'two');
+    `);
+
+    const query = db.prepare('SELECT key, val FROM data ORDER BY key');
+    query.setReadNullAsUndefined(true);
+
+    t.assert.deepStrictEqual(query.all(), [
+      { __proto__: null, key: 1, val: undefined },
+      { __proto__: null, key: 2, val: 'two' },
+    ]);
+  });
+
+  test('applies to iterate()', (t) => {
+    const db = new DatabaseSync(nextDb());
+    t.after(() => { db.close(); });
+
+    db.exec(`
+      CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
+      INSERT INTO data (key, val) VALUES (1, NULL), (2, NULL);
+    `);
+
+    const query = db.prepare('SELECT key, val FROM data ORDER BY key');
+    query.setReadNullAsUndefined(true);
+
+    const iter = query.iterate();
+    t.assert.deepStrictEqual(iter.next().value, { __proto__: null, key: 1, val: undefined });
+    t.assert.deepStrictEqual(iter.next().value, { __proto__: null, key: 2, val: undefined });
+    t.assert.strictEqual(iter.next().done, true);
+  });
+
+  test('does not change NULL passed to user-defined functions', (t) => {
+    const db = new DatabaseSync(nextDb());
+    t.after(() => { db.close(); });
+
+    db.exec('CREATE TABLE data(val TEXT) STRICT; INSERT INTO data VALUES (NULL);');
+
+    let seen;
+    db.function('echo', (x) => { seen = x; return x; });
+
+    const query = db.prepare('SELECT echo(val) AS out FROM data');
+    query.setReadNullAsUndefined(true);
+
+    t.assert.deepStrictEqual(query.get(), { __proto__: null, out: undefined });
+    t.assert.strictEqual(seen, null);
+  });
+});
+