@@ -683,6 +683,24 @@ public bool IncludeErrorDetail
     }
     bool _includeErrorDetail;
 
+    /// <summary>
+    /// When enabled, failed statements are included on <see cref="NpgsqlException.BatchCommand" />.
+    /// </summary>
+    [Category("Security")]
+    [Description("When enabled, failed batched commands are included on NpgsqlException.BatchCommand.")]
+    [DisplayName("Include Failed Batched Command")]
+    [NpgsqlConnectionStringProperty]
+    public bool IncludeFailedBatchedCommand
+    {
+        get => _includeFailedBatchedCommand;
+        set
+        {
+            _includeFailedBatchedCommand = value;
+            SetValue(nameof(IncludeFailedBatchedCommand), value);
+        }
+    }
+    bool _includeFailedBatchedCommand;
+
     /// <summary>
     /// Controls whether channel binding is required, disabled or preferred, depending on server support.
     /// </summary>
 
@@ -516,7 +516,8 @@ async Task<bool> NextResult(bool async, bool isConsuming = false, CancellationTo
                 var statement = _statements[StatementIndex];
 
                 // Reference the triggering statement from the exception
-                postgresException.BatchCommand = statement;
+                if (Connector.Settings.IncludeFailedBatchedCommand)
+                    postgresException.BatchCommand = statement;
 
                 // Prevent the command or batch from being recycled (by the connection) when it's disposed. This is important since
                 // the exception is very likely to escape the using statement of the command, and by that time some other user may
@@ -754,7 +755,9 @@ async Task<bool> NextResultSchemaOnly(bool async, bool isConsuming = false, Canc
             // Reference the triggering statement from the exception
             if (e is PostgresException postgresException && StatementIndex >= 0 && StatementIndex < _statements.Count)
             {
-                postgresException.BatchCommand = _statements[StatementIndex];
+                // Reference the triggering statement from the exception
+                if (Connector.Settings.IncludeFailedBatchedCommand)
+                    postgresException.BatchCommand = _statements[StatementIndex];
 
                 // Prevent the command or batch from being recycled (by the connection) when it's disposed. This is important since
                 // the exception is very likely to escape the using statement of the command, and by that time some other user may
 
@@ -46,6 +46,7 @@ public override bool IsTransient
         => InnerException is IOException or SocketException or TimeoutException or NpgsqlException { IsTransient: true };
 
     /// <inheritdoc cref="DbException.BatchCommand"/>
+    /// <remarks>This property is <c>null</c> unless <see cref="NpgsqlConnectionStringBuilder.IncludeFailedBatchedCommand"/> in connection string is set to <c>true</c>.</remarks>
     public new NpgsqlBatchCommand? BatchCommand { get; set; }
 
     /// <inheritdoc/>
 
@@ -9,6 +9,8 @@ Npgsql.NpgsqlConnection.SslClientAuthenticationOptionsCallback.get -> System.Act
 Npgsql.NpgsqlConnection.SslClientAuthenticationOptionsCallback.set -> void
 Npgsql.NpgsqlConnectionStringBuilder.GssEncryptionMode.get -> Npgsql.GssEncryptionMode
 Npgsql.NpgsqlConnectionStringBuilder.GssEncryptionMode.set -> void
+Npgsql.NpgsqlConnectionStringBuilder.IncludeFailedBatchedCommand.get -> bool
+Npgsql.NpgsqlConnectionStringBuilder.IncludeFailedBatchedCommand.set -> void
 Npgsql.NpgsqlConnectionStringBuilder.RequireAuth.get -> string?
 Npgsql.NpgsqlConnectionStringBuilder.RequireAuth.set -> void
 Npgsql.NpgsqlConnectionStringBuilder.SslNegotiation.get -> Npgsql.SslNegotiation
 
@@ -12,7 +12,7 @@ namespace Npgsql.Tests;
 [TestFixture(MultiplexingMode.Multiplexing, CommandBehavior.Default)]
 [TestFixture(MultiplexingMode.NonMultiplexing, CommandBehavior.SequentialAccess)]
 [TestFixture(MultiplexingMode.Multiplexing, CommandBehavior.SequentialAccess)]
-public class BatchTests : MultiplexingTestBase
+public class BatchTests : MultiplexingTestBase, IDisposable
 {
     #region Parameters
 
@@ -477,7 +477,7 @@ public async Task Batch_with_multiple_errors([Values] bool withErrorBarriers)
     public async Task Batch_close_dispose_reader_with_multiple_errors([Values] bool withErrorBarriers, [Values] bool dispose)
     {
         // Create a temp pool since we dispose the reader (and check the state afterwards) and it can be reused by another connection
-        await using var dataSource = CreateDataSource();
+        await using var dataSource = CreateDataSource(x => x.IncludeFailedBatchedCommand = true);
         await using var conn = await dataSource.OpenConnectionAsync();
         var table = await CreateTempTable(conn, "id INT");
 
@@ -804,11 +804,16 @@ public async Task Batch_dispose_reuse()
     readonly CommandBehavior Behavior;
     // ReSharper restore InconsistentNaming
 
+    NpgsqlDataSource? _dataSource;
+    protected override NpgsqlDataSource DataSource => _dataSource ??= CreateDataSource(csb => csb.IncludeFailedBatchedCommand = true);
+
     public BatchTests(MultiplexingMode multiplexingMode, CommandBehavior behavior) : base(multiplexingMode)
     {
         Behavior = behavior;
         IsSequential = (Behavior & CommandBehavior.SequentialAccess) != 0;
     }
 
+    public void Dispose() => DataSource.Dispose();
+
     #endregion
 }
@@ -623,9 +623,10 @@ await conn.ExecuteNonQueryAsync($@"
     }
 
     [Test, IssueLink("https://github.com/npgsql/npgsql/issues/967")]
-    public async Task NpgsqlException_references_BatchCommand_with_single_command()
+    public async Task NpgsqlException_references_BatchCommand_with_single_command([Values] bool includeFailedBatchedCommand)
     {
-        await using var conn = await OpenConnectionAsync();
+        await using var dataSource = CreateDataSource(x => x.IncludeFailedBatchedCommand = includeFailedBatchedCommand);
+        await using var conn = await dataSource.OpenConnectionAsync();
         var function = await GetTempFunctionName(conn);
 
         await conn.ExecuteNonQueryAsync($@"
@@ -638,7 +639,10 @@ await conn.ExecuteNonQueryAsync($@"
         cmd.CommandText = $"SELECT {function}()";
 
         var exception = Assert.ThrowsAsync<PostgresException>(() => cmd.ExecuteReaderAsync(Behavior))!;
-        Assert.That(exception.BatchCommand, Is.SameAs(cmd.InternalBatchCommands[0]));
+        if (includeFailedBatchedCommand)
+            Assert.That(exception.BatchCommand, Is.SameAs(cmd.InternalBatchCommands[0]));
+        else
+            Assert.That(exception.BatchCommand, Is.Null);
 
         // Make sure the command isn't recycled by the connection when it's disposed - this is important since internal command
         // resources are referenced by the exception above, which is very likely to escape the using statement of the command.
@@ -648,9 +652,10 @@ await conn.ExecuteNonQueryAsync($@"
     }
 
     [Test, IssueLink("https://github.com/npgsql/npgsql/issues/967")]
-    public async Task NpgsqlException_references_BatchCommand_with_multiple_commands()
+    public async Task NpgsqlException_references_BatchCommand_with_multiple_commands([Values] bool includeFailedBatchedCommand)
     {
-        await using var conn = await OpenConnectionAsync();
+        await using var dataSource = CreateDataSource(x => x.IncludeFailedBatchedCommand = includeFailedBatchedCommand);
+        await using var conn = await dataSource.OpenConnectionAsync();
         var function = await GetTempFunctionName(conn);
 
         await conn.ExecuteNonQueryAsync($@"
@@ -665,7 +670,10 @@ await conn.ExecuteNonQueryAsync($@"
         await using (var reader = await cmd.ExecuteReaderAsync(Behavior))
         {
             var exception = Assert.ThrowsAsync<PostgresException>(() => reader.NextResultAsync())!;
-            Assert.That(exception.BatchCommand, Is.SameAs(cmd.InternalBatchCommands[1]));
+            if (includeFailedBatchedCommand)
+                Assert.That(exception.BatchCommand, Is.SameAs(cmd.InternalBatchCommands[1]));
+            else
+                Assert.That(exception.BatchCommand, Is.Null);
         }
 
         // Make sure the command isn't recycled by the connection when it's disposed - this is important since internal command
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace Npgsql.Tests;`
`12`	`12`	`[TestFixture(MultiplexingMode.Multiplexing, CommandBehavior.Default)]`
`13`	`13`	`[TestFixture(MultiplexingMode.NonMultiplexing, CommandBehavior.SequentialAccess)]`
`14`	`14`	`[TestFixture(MultiplexingMode.Multiplexing, CommandBehavior.SequentialAccess)]`
`15`		`-public class BatchTests : MultiplexingTestBase`
	`15`	`+public class BatchTests : MultiplexingTestBase, IDisposable`
`16`	`16`	`{`
`17`	`17`	`#region Parameters`
`18`	`18`
`@@ -477,7 +477,7 @@ public async Task Batch_with_multiple_errors([Values] bool withErrorBarriers)`
`477`	`477`	`public async Task Batch_close_dispose_reader_with_multiple_errors([Values] bool withErrorBarriers, [Values] bool dispose)`
`478`	`478`	`{`
`479`	`479`	`// Create a temp pool since we dispose the reader (and check the state afterwards) and it can be reused by another connection`
`480`		`- await using var dataSource = CreateDataSource();`
	`480`	`+ await using var dataSource = CreateDataSource(x => x.IncludeFailedBatchedCommand = true);`
`481`	`481`	`await using var conn = await dataSource.OpenConnectionAsync();`
`482`	`482`	`var table = await CreateTempTable(conn, "id INT");`
`483`	`483`
`@@ -804,11 +804,16 @@ public async Task Batch_dispose_reuse()`
`804`	`804`	`readonly CommandBehavior Behavior;`
`805`	`805`	`// ReSharper restore InconsistentNaming`
`806`	`806`
	`807`	`+ NpgsqlDataSource? _dataSource;`
	`808`	`+ protected override NpgsqlDataSource DataSource => _dataSource ??= CreateDataSource(csb => csb.IncludeFailedBatchedCommand = true);`
	`809`	`+`
`807`	`810`	`public BatchTests(MultiplexingMode multiplexingMode, CommandBehavior behavior) : base(multiplexingMode)`
`808`	`811`	`{`
`809`	`812`	`Behavior = behavior;`
`810`	`813`	`IsSequential = (Behavior & CommandBehavior.SequentialAccess) != 0;`
`811`	`814`	`}`
`812`	`815`
	`816`	`+ public void Dispose() => DataSource.Dispose();`
	`817`	`+`
`813`	`818`	`#endregion`
`814`	`819`	`}`