@@ -10,7 +10,7 @@ on:
   pull_request:
 
 env:
-  dotnet_sdk_version: '6.0.100-preview.4.21255.9'
+  dotnet_sdk_version: '6.0.100-preview.7.21379.14'
   postgis_version: 3
   DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
 
 
@@ -9,7 +9,7 @@ on:
       - '*'
 
 env:
-  dotnet_sdk_version: '6.0.100-preview.4.21255.9'
+  dotnet_sdk_version: '6.0.100-preview.7.21379.14'
   DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
 
 jobs:
 
@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "6.0.100-preview.5.21302.13",
+    "version": "6.0.100-preview.7.21379.14",
     "rollForward": "latestMajor",
     "allowPrerelease": "true"
   }
 
@@ -146,7 +146,7 @@ internal async Task WriteParse(string sql, string statementName, List<NpgsqlPara
         }
 
         internal async Task WriteBind(
-            List<NpgsqlParameter> inputParameters,
+            List<NpgsqlParameter> parameters,
             string portal,
             string statement,
             bool allResultTypesAreUnknown,
@@ -172,20 +172,20 @@ internal async Task WriteBind(
 
             var formatCodesSum = 0;
             var paramsLength = 0;
-            for (var paramIndex = 0; paramIndex < inputParameters.Count; paramIndex++)
+            for (var paramIndex = 0; paramIndex < parameters.Count; paramIndex++)
             {
-                var param = inputParameters[paramIndex];
+                var param = parameters[paramIndex];
                 formatCodesSum += (int)param.FormatCode;
                 param.LengthCache?.Rewind();
                 paramsLength += param.ValidateAndGetLength();
             }
 
-            var formatCodeListLength = formatCodesSum == 0 ? 0 : formatCodesSum == inputParameters.Count ? 1 : inputParameters.Count;
+            var formatCodeListLength = formatCodesSum == 0 ? 0 : formatCodesSum == parameters.Count ? 1 : parameters.Count;
 
             var messageLength = headerLength         +
                 sizeof(short) * formatCodeListLength +                  // List of format codes
                 sizeof(short)                        +                  // Number of parameters
-                sizeof(int) * inputParameters.Count  +                  // Parameter lengths
+                sizeof(int) * parameters.Count  +                       // Parameter lengths
                 paramsLength                         +                  // Parameter values
                 sizeof(short)                        +                  // Number of result format codes
                 sizeof(short) * (unknownResultTypeList?.Length ?? 1);   // Result format codes
@@ -207,22 +207,22 @@ internal async Task WriteBind(
             }
             else if (formatCodeListLength > 1)
             {
-                for (var paramIndex = 0; paramIndex < inputParameters.Count; paramIndex++)
+                for (var paramIndex = 0; paramIndex < parameters.Count; paramIndex++)
                 {
                     if (WriteBuffer.WriteSpaceLeft < 2)
                         await Flush(async, cancellationToken);
-                    WriteBuffer.WriteInt16((short)inputParameters[paramIndex].FormatCode);
+                    WriteBuffer.WriteInt16((short)parameters[paramIndex].FormatCode);
                 }
             }
 
             if (WriteBuffer.WriteSpaceLeft < 2)
                 await Flush(async, cancellationToken);
 
-            WriteBuffer.WriteUInt16((ushort)inputParameters.Count);
+            WriteBuffer.WriteUInt16((ushort)parameters.Count);
 
-            for (var paramIndex = 0; paramIndex < inputParameters.Count; paramIndex++)
+            for (var paramIndex = 0; paramIndex < parameters.Count; paramIndex++)
             {
-                var param = inputParameters[paramIndex];
+                var param = parameters[paramIndex];
                 param.LengthCache?.Rewind();
                 await param.WriteWithLength(WriteBuffer, async, cancellationToken);
             }
 
@@ -22,7 +22,6 @@ namespace Npgsql.Internal.TypeHandlers
     /// should be considered somewhat unstable, and may change in breaking ways, including in non-major releases.
     /// Use it at your own risk.
     /// </remarks>
-
     public class TextHandlerFactory : NpgsqlTypeHandlerFactory<string>
     {
         /// <inheritdoc />
 
@@ -261,24 +261,11 @@ bool WriteCommand(NpgsqlConnector connector, NpgsqlCommand command, ref Multiple
                 // but the main thread continues to handle other commands on other connectors.
                 if (_autoPrepare)
                 {
+                    // TODO: Need to log based on numPrepared like in non-multiplexing mode...
                     var numPrepared = 0;
-                    for (var statementIndex = 0; statementIndex < command._statements.Count; statementIndex++)
-                    {
-                        var statement = command._statements[statementIndex];
-                        // If this statement isn't prepared, see if it gets implicitly prepared.
-                        // Note that this may return null (not enough usages for automatic preparation).
-                        if (!statement.IsPrepared)
-                            statement.PreparedStatement = connector.PreparedStatementManager.TryGetAutoPrepared(statement);
-                        if (statement.PreparedStatement is PreparedStatement pStatement)
-                        {
+                    for (var i = 0; i < command.InternalBatchCommands.Count; i++)
+                        if (command.InternalBatchCommands[i].TryAutoPrepare(connector))
                             numPrepared++;
-                            if (pStatement?.State == PreparedState.NotPrepared)
-                            {
-                                pStatement.State = PreparedState.BeingPrepared;
-                                statement.IsPreparing = true;
-                            }
-                        }
-                    }
                 }
 
                 var written = connector.CommandsInFlightWriter!.TryWrite(command);
 
@@ -0,0 +1,125 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Npgsql
+{
+    /// <inheritdoc />
+    public class NpgsqlBatch : DbBatch
+    {
+        readonly NpgsqlCommand _command;
+
+        /// <inheritdoc />
+        protected override DbBatchCommandCollection DbBatchCommands => BatchCommands;
+
+        /// <inheritdoc cref="DbBatch.BatchCommands"/>
+        public new NpgsqlBatchCommandCollection BatchCommands { get; }
+
+        /// <inheritdoc />
+        public override int Timeout
+        {
+            get => _command.CommandTimeout;
+            set => _command.CommandTimeout = value;
+        }
+
+        /// <inheritdoc cref="DbBatch.Connection"/>
+        public new NpgsqlConnection? Connection
+        {
+            get => _command.Connection;
+            set => _command.Connection = value;
+        }
+
+        /// <inheritdoc />
+        protected override DbConnection? DbConnection
+        {
+            get => Connection;
+            set => Connection = (NpgsqlConnection?)value;
+        }
+
+        /// <inheritdoc cref="DbBatch.Transaction"/>
+        public new NpgsqlTransaction? Transaction
+        {
+            get => _command.Transaction;
+            set => _command.Transaction = value;
+        }
+
+        /// <inheritdoc />
+        protected override DbTransaction? DbTransaction
+        {
+            get => Transaction;
+            set => Transaction = (NpgsqlTransaction?)value;
+        }
+
+        /// <summary>
+        /// Initializes a new <see cref="NpgsqlBatch"/>.
+        /// </summary>
+        /// <param name="connection">A <see cref="NpgsqlConnection"/> that represents the connection to a PostgreSQL server.</param>
+        /// <param name="transaction">The <see cref="NpgsqlTransaction"/> in which the <see cref="NpgsqlCommand"/> executes.</param>
+        public NpgsqlBatch(NpgsqlConnection? connection = null, NpgsqlTransaction? transaction = null)
+        {
+            var batchCommands = new List<NpgsqlBatchCommand>(5);
+            _command = new(batchCommands);
+            BatchCommands = new NpgsqlBatchCommandCollection(batchCommands);
+
+            Connection = connection;
+            Transaction = transaction;
+        }
+
+        /// <inheritdoc />
+        protected override DbBatchCommand CreateDbBatchCommand()
+            => new NpgsqlBatchCommand();
+
+        /// <inheritdoc />
+        protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
+            => ExecuteReader(behavior);
+
+        /// <inheritdoc cref="DbBatch.ExecuteReader"/>
+        public new NpgsqlDataReader ExecuteReader(CommandBehavior behavior = CommandBehavior.Default)
+            => _command.ExecuteReader();
+
+        /// <inheritdoc />
+        protected override async Task<DbDataReader> ExecuteDbDataReaderAsync(
+            CommandBehavior behavior,
+            CancellationToken cancellationToken)
+            => await ExecuteReaderAsync(cancellationToken);
+
+        /// <inheritdoc cref="DbBatch.ExecuteReaderAsync(CancellationToken)"/>
+        public new Task<NpgsqlDataReader> ExecuteReaderAsync(CancellationToken cancellationToken = default)
+            => _command.ExecuteReaderAsync(cancellationToken);
+
+        /// <inheritdoc cref="DbBatch.ExecuteReaderAsync(CommandBehavior,CancellationToken)"/>
+        public new Task<NpgsqlDataReader> ExecuteReaderAsync(
+            CommandBehavior behavior,
+            CancellationToken cancellationToken = default)
+            => _command.ExecuteReaderAsync(behavior, cancellationToken);
+
+        /// <inheritdoc />
+        public override int ExecuteNonQuery()
+            => _command.ExecuteNonQuery();
+
+        /// <inheritdoc />
+        public override Task<int> ExecuteNonQueryAsync(CancellationToken cancellationToken = default)
+            => _command.ExecuteNonQueryAsync(cancellationToken);
+
+        /// <inheritdoc />
+        public override object? ExecuteScalar()
+            => _command.ExecuteScalar();
+
+        /// <inheritdoc />
+        public override Task<object?> ExecuteScalarAsync(CancellationToken cancellationToken = default)
+            => _command.ExecuteScalarAsync(cancellationToken);
+
+        /// <inheritdoc />
+        public override void Prepare()
+            => _command.Prepare();
+
+        /// <inheritdoc />
+        public override Task PrepareAsync(CancellationToken cancellationToken = default)
+            => _command.PrepareAsync(cancellationToken);
+
+        /// <inheritdoc />
+        public override void Cancel() => _command.Cancel();
+    }
+}
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"sdk": {`
`3`		`- "version": "6.0.100-preview.5.21302.13",`
	`3`	`+ "version": "6.0.100-preview.7.21379.14",`
`4`	`4`	`"rollForward": "latestMajor",`
`5`	`5`	`"allowPrerelease": "true"`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ internal async Task WriteParse(string sql, string statementName, List<NpgsqlPara`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`internal async Task WriteBind(`
`149`		`- List<NpgsqlParameter> inputParameters,`
	`149`	`+ List<NpgsqlParameter> parameters,`
`150`	`150`	`string portal,`
`151`	`151`	`string statement,`
`152`	`152`	`bool allResultTypesAreUnknown,`
`@@ -172,20 +172,20 @@ internal async Task WriteBind(`
`172`	`172`
`173`	`173`	`var formatCodesSum = 0;`
`174`	`174`	`var paramsLength = 0;`
`175`		`- for (var paramIndex = 0; paramIndex < inputParameters.Count; paramIndex++)`
	`175`	`+ for (var paramIndex = 0; paramIndex < parameters.Count; paramIndex++)`
`176`	`176`	`{`
`177`		`- var param = inputParameters[paramIndex];`
	`177`	`+ var param = parameters[paramIndex];`
`178`	`178`	`formatCodesSum += (int)param.FormatCode;`
`179`	`179`	`param.LengthCache?.Rewind();`
`180`	`180`	`paramsLength += param.ValidateAndGetLength();`
`181`	`181`	`}`
`182`	`182`
`183`		`- var formatCodeListLength = formatCodesSum == 0 ? 0 : formatCodesSum == inputParameters.Count ? 1 : inputParameters.Count;`
	`183`	`+ var formatCodeListLength = formatCodesSum == 0 ? 0 : formatCodesSum == parameters.Count ? 1 : parameters.Count;`
`184`	`184`
`185`	`185`	`var messageLength = headerLength +`
`186`	`186`	`sizeof(short) * formatCodeListLength + // List of format codes`
`187`	`187`	`sizeof(short) + // Number of parameters`
`188`		`- sizeof(int) * inputParameters.Count + // Parameter lengths`
	`188`	`+ sizeof(int) * parameters.Count + // Parameter lengths`
`189`	`189`	`paramsLength + // Parameter values`
`190`	`190`	`sizeof(short) + // Number of result format codes`
`191`	`191`	`sizeof(short) * (unknownResultTypeList?.Length ?? 1); // Result format codes`
`@@ -207,22 +207,22 @@ internal async Task WriteBind(`
`207`	`207`	`}`
`208`	`208`	`else if (formatCodeListLength > 1)`
`209`	`209`	`{`
`210`		`- for (var paramIndex = 0; paramIndex < inputParameters.Count; paramIndex++)`
	`210`	`+ for (var paramIndex = 0; paramIndex < parameters.Count; paramIndex++)`
`211`	`211`	`{`
`212`	`212`	`if (WriteBuffer.WriteSpaceLeft < 2)`
`213`	`213`	`await Flush(async, cancellationToken);`
`214`		`- WriteBuffer.WriteInt16((short)inputParameters[paramIndex].FormatCode);`
	`214`	`+ WriteBuffer.WriteInt16((short)parameters[paramIndex].FormatCode);`
`215`	`215`	`}`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`if (WriteBuffer.WriteSpaceLeft < 2)`
`219`	`219`	`await Flush(async, cancellationToken);`
`220`	`220`
`221`		`- WriteBuffer.WriteUInt16((ushort)inputParameters.Count);`
	`221`	`+ WriteBuffer.WriteUInt16((ushort)parameters.Count);`
`222`	`222`
`223`		`- for (var paramIndex = 0; paramIndex < inputParameters.Count; paramIndex++)`
	`223`	`+ for (var paramIndex = 0; paramIndex < parameters.Count; paramIndex++)`
`224`	`224`	`{`
`225`		`- var param = inputParameters[paramIndex];`
	`225`	`+ var param = parameters[paramIndex];`
`226`	`226`	`param.LengthCache?.Rewind();`
`227`	`227`	`await param.WriteWithLength(WriteBuffer, async, cancellationToken);`
`228`	`228`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ namespace Npgsql.Internal.TypeHandlers`
`22`	`22`	`/// should be considered somewhat unstable, and may change in breaking ways, including in non-major releases.`
`23`	`23`	`/// Use it at your own risk.`
`24`	`24`	`/// </remarks>`
`25`		`-`
`26`	`25`	`public class TextHandlerFactory : NpgsqlTypeHandlerFactory<string>`
`27`	`26`	`{`
`28`	`27`	`/// <inheritdoc />`