Allow to run migrations inside of a user transaction

src/EFCore.Relational/Migrations/Internal/MigrationCommandExecutor.cs

@@ -1,10 +1,13 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Transactions;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.EntityFrameworkCore.Utilities;
 using Microsoft.Extensions.DependencyInjection;
@@ -39,6 +42,12 @@ public virtual void ExecuteNonQuery(
             Check.NotNull(migrationCommands, nameof(migrationCommands));
             Check.NotNull(connection, nameof(connection));
 
+            var userTransaction = connection.CurrentTransaction;
+            if (userTransaction is not null && migrationCommands.Any(x => x.TransactionSuppressed))
+            {
+                throw new NotSupportedException(RelationalStrings.TransactionSuppressedMigrationInUserTransaction);
+            }
+
             using (new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
             {
                 connection.Open();
@@ -52,7 +61,8 @@ public virtual void ExecuteNonQuery(
                         foreach (var command in migrationCommands)
                         {
                             if (transaction == null
-                                && !command.TransactionSuppressed)
+                                && !command.TransactionSuppressed
+                                && userTransaction is null)
                             {
                                 transaction = connection.BeginTransaction();
                             }
@@ -96,6 +106,12 @@ public virtual async Task ExecuteNonQueryAsync(
             Check.NotNull(migrationCommands, nameof(migrationCommands));
             Check.NotNull(connection, nameof(connection));
 
+            var userTransaction = connection.CurrentTransaction;
+            if (userTransaction is not null && migrationCommands.Any(x => x.TransactionSuppressed))
+            {
+                throw new NotSupportedException(RelationalStrings.TransactionSuppressedMigrationInUserTransaction);
+            }
+
             var transactionScope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled);
             try
             {
@@ -110,7 +126,8 @@ public virtual async Task ExecuteNonQueryAsync(
                         foreach (var command in migrationCommands)
                         {
                             if (transaction == null
-                                && !command.TransactionSuppressed)
+                                && !command.TransactionSuppressed
+                                && userTransaction is null)
                             {
                                 transaction = await connection.BeginTransactionAsync(cancellationToken)
                                     .ConfigureAwait(false);

src/EFCore.Relational/Properties/RelationalStrings.resx

@@ -745,6 +745,9 @@
   <data name="TransactionAssociatedWithDifferentConnection" xml:space="preserve">
     <value>The specified transaction is not associated with the current connection. Only transactions associated with the current connection may be used.</value>
   </data>
+  <data name="TransactionSuppressedMigrationInUserTransaction" xml:space="preserve">
+    <value>User transaction is not supported with a TransactionSuppressed migrations.</value>
+  </data>
   <data name="UnableToBindMemberToEntityProjection" xml:space="preserve">
     <value>Unable to bind '{memberType}.{member}' to an entity projection of '{entityType}'.</value>
   </data>

test/EFCore.Relational.Tests/Migrations/MigrationCommandExecutorTest.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Diagnostics.Internal;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations.Internal;
@@ -58,6 +59,108 @@ public async Task Executes_migration_commands_in_same_transaction(bool async)
                 fakeConnection.DbConnections[0].DbCommands[1].Transaction);
         }
 
+        [ConditionalTheory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public async Task Executes_migration_commands_in_user_transaction(bool async)
+        {
+            var fakeConnection = CreateConnection();
+            var logger = new FakeRelationalCommandDiagnosticsLogger();
+
+            var commandList = new List<MigrationCommand>
+            {
+                new(CreateRelationalCommand(), null, logger),
+                new(CreateRelationalCommand(), null, logger)
+            };
+
+            var migrationCommandExecutor = new MigrationCommandExecutor();
+
+            IDbContextTransaction tx;
+            using (tx = fakeConnection.BeginTransaction())
+            {
+                if (async)
+                {
+                    await migrationCommandExecutor.ExecuteNonQueryAsync(commandList, fakeConnection);
+                }
+                else
+                {
+                    migrationCommandExecutor.ExecuteNonQuery(commandList, fakeConnection);
+                }
+
+                tx.Commit();
+            }
+
+            Assert.Equal(1, fakeConnection.DbConnections.Count);
+            Assert.Equal(1, fakeConnection.DbConnections[0].OpenCount);
+            Assert.Equal(1, fakeConnection.DbConnections[0].CloseCount);
+
+            Assert.Equal(1, fakeConnection.DbConnections[0].DbTransactions.Count);
+            Assert.Equal(1, fakeConnection.DbConnections[0].DbTransactions[0].CommitCount);
+            Assert.Equal(0, fakeConnection.DbConnections[0].DbTransactions[0].RollbackCount);
+
+            Assert.Equal(2, fakeConnection.DbConnections[0].DbCommands.Count);
+            Assert.Same(
+                fakeConnection.DbConnections[0].DbTransactions[0],
+                fakeConnection.DbConnections[0].DbCommands[0].Transaction);
+            Assert.Same(
+                fakeConnection.DbConnections[0].DbTransactions[0],
+                fakeConnection.DbConnections[0].DbCommands[1].Transaction);
+            Assert.Same(
+                tx.GetDbTransaction(),
+                fakeConnection.DbConnections[0].DbTransactions[0]);
+        }
+
+        [ConditionalTheory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public async Task Executes_transaction_suppressed_migration_commands_in_user_transaction(bool async)
+        {
+            var fakeConnection = CreateConnection();
+            var logger = new FakeRelationalCommandDiagnosticsLogger();
+
+            var commandList = new List<MigrationCommand>
+            {
+                new(CreateRelationalCommand(), null, logger),
+                new(CreateRelationalCommand(), null, logger, transactionSuppressed: true)
+            };
+
+            var migrationCommandExecutor = new MigrationCommandExecutor();
+
+            IDbContextTransaction tx;
+            using (tx = fakeConnection.BeginTransaction())
+            {
+                if (async)
+                {
+                    Assert.Equal(RelationalStrings.TransactionSuppressedMigrationInUserTransaction,
+                        (await Assert.ThrowsAsync<NotSupportedException>(
+                        async ()
+                            => await migrationCommandExecutor.ExecuteNonQueryAsync(commandList, fakeConnection))).Message);
+                }
+                else
+                {
+                    Assert.Equal(RelationalStrings.TransactionSuppressedMigrationInUserTransaction,
+                        Assert.Throws<NotSupportedException>(
+                            ()
+                                => migrationCommandExecutor.ExecuteNonQuery(commandList, fakeConnection)).Message);
+                }
+
+                tx.Rollback();
+            }
+
+            Assert.Equal(1, fakeConnection.DbConnections.Count);
+            Assert.Equal(1, fakeConnection.DbConnections[0].OpenCount);
+            Assert.Equal(1, fakeConnection.DbConnections[0].CloseCount);
+
+            Assert.Equal(1, fakeConnection.DbConnections[0].DbTransactions.Count);
+            Assert.Equal(0, fakeConnection.DbConnections[0].DbTransactions[0].CommitCount);
+            Assert.Equal(1, fakeConnection.DbConnections[0].DbTransactions[0].RollbackCount);
+
+            Assert.Equal(0, fakeConnection.DbConnections[0].DbCommands.Count);
+            Assert.Same(
+                tx.GetDbTransaction(),
+                fakeConnection.DbConnections[0].DbTransactions[0]);
+        }
+
         [ConditionalTheory]
         [InlineData(false)]
         [InlineData(true)]