Merge branch 'main' into efcore-dotnet-10

Author: olavloite

Google.Cloud.EntityFrameworkCore.Spanner.Tests/EntityFrameworkSessionLeakMockServerTests.cs

@@ -2201,21 +2201,43 @@ await Repeat(() =>
         }
 
         [Fact]
-        public async Task OnlyDisposingReadOnlyTransactionWithoutCommitting_LeaksSession()
+        public async Task OnlyDisposingReadOnlyTransactionWithoutCommitting_DoesNotLeakSession()
         {
             AddFindSingerResult($"SELECT `s`.`SingerId`, `s`.`BirthDate`, `s`.`FirstName`, `s`.`FullName`," +
                                 $" `s`.`LastName`, `s`.`Picture`{Environment.NewLine}FROM `Singers` AS `s`{Environment.NewLine}" +
                                 $"WHERE `s`.`SingerId` = @p{Environment.NewLine}LIMIT 1");
 
-            var exception = await Assert.ThrowsAsync<SpannerException>(() => Repeat(async () =>
+            await Repeat(async () =>
             {
                 using var db = CreateContext();
                 // NOTE: This transaction is being disposed, but it's not being committed or rolled back.
                 using var transaction = await db.Database.BeginReadOnlyTransactionAsync();
                 Assert.NotNull(await db.Singers.FindAsync(1L));
                 // Note: No Commit or Rollback
-            }));
-            Assert.Equal(ErrorCode.ResourceExhausted, exception.ErrorCode);
+            });
+        }
+
+        [Fact]
+        public async Task EmptyReadWriteTransactionWithTagDoesNotLeakSession()
+        {
+            await using var db = CreateContext();
+            await Repeat(async () =>
+            {
+                // Execute an empty read/write transaction with a tag.
+                await using var transaction = await db.Database.BeginTransactionAsync("some_tag");
+                await transaction.CommitAsync();
+            });
+        }
+
+        [Fact]
+        public async Task StartingTwoTransactionsOnSameConnectionFailsAndDoesNotLeakSession()
+        {
+            await using var db = CreateContext();
+            await Repeat(async () =>
+            {
+                await using var transaction1 = await db.Database.BeginTransactionAsync("some_tag1");
+                await Assert.ThrowsAsync<InvalidOperationException>(async () => await db.Database.BeginTransactionAsync("some_tag2"));
+            });
         }
 
         private void AddFindSingerResult(string sql)

Google.Cloud.EntityFrameworkCore.Spanner.Tests/MigrationTests/GenerateCreateScriptTest.cs

@@ -169,6 +169,11 @@ INTERLEAVE IN PARENT `Albums` ON DELETE NO ACTION
 
 CREATE INDEX `AlbumsByAlbumTitle2` ON `Albums` (`Title`) STORING (`MarketingBudget`, `ReleaseDate`)
 
+CREATE INDEX `AlbumsBySingerIdReleaseDateMarketingBudgetTitle` ON `Albums` (`SingerId`, `ReleaseDate` DESC, `MarketingBudget` DESC, `Title`)
+
+CREATE INDEX `idx_concerts_singerId_startTime` ON `Concerts` (`SingerId`, `StartTime`),
+ INTERLEAVE IN `Singers`
+
 CREATE INDEX `Idx_Singers_FullName` ON `Singers` (`FullName`)
 
 CREATE NULL_FILTERED INDEX `IDX_TableWithAllColumnTypes_ColDate_ColCommitTS` ON `TableWithAllColumnTypes` (`ColDate`, `ColCommitTS`)
@@ -279,6 +284,11 @@ INTERLEAVE IN PARENT `Albums` ON DELETE NO ACTION
 
 CREATE INDEX `AlbumsByAlbumTitle2` ON `Albums` (`Title`) STORING (`MarketingBudget`, `ReleaseDate`)
 
+CREATE INDEX `AlbumsBySingerIdReleaseDateMarketingBudgetTitle` ON `Albums` (`SingerId`, `ReleaseDate` DESC, `MarketingBudget` DESC, `Title`)
+
+CREATE INDEX `idx_concerts_singerId_startTime` ON `Concerts` (`SingerId`, `StartTime`),
+ INTERLEAVE IN `Singers`
+
 CREATE INDEX `Idx_Singers_FullName` ON `Singers` (`FullName`)
 
 CREATE NULL_FILTERED INDEX `IDX_TableWithAllColumnTypes_ColDate_ColCommitTS` ON `TableWithAllColumnTypes` (`ColDate`, `ColCommitTS`)
@@ -389,6 +399,11 @@ INTERLEAVE IN PARENT `Albums` ON DELETE NO ACTION
 
 CREATE INDEX `AlbumsByAlbumTitle2` ON `Albums` (`Title`) STORING (`MarketingBudget`, `ReleaseDate`)
 
+CREATE INDEX `AlbumsBySingerIdReleaseDateMarketingBudgetTitle` ON `Albums` (`SingerId`, `ReleaseDate` DESC, `MarketingBudget` DESC, `Title`)
+
+CREATE INDEX `idx_concerts_singerId_startTime` ON `Concerts` (`SingerId`, `StartTime`),
+ INTERLEAVE IN `Singers`
+
 CREATE INDEX `Idx_Singers_FullName` ON `Singers` (`FullName`)
 
 CREATE NULL_FILTERED INDEX `IDX_TableWithAllColumnTypes_ColDate_ColCommitTS` ON `TableWithAllColumnTypes` (`ColDate`, `ColCommitTS`)

Google.Cloud.EntityFrameworkCore.Spanner.Tests/MigrationTests/MigrationMockServerTests.cs

@@ -16,6 +16,11 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Migrations;
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Google.Cloud.EntityFrameworkCore.Spanner.Extensions;
+using Google.Cloud.Spanner.V1;
 using Xunit;
 
 namespace Google.Cloud.EntityFrameworkCore.Spanner.Tests.MigrationTests
@@ -33,6 +38,7 @@ public MigrationMockServerTests(SpannerMockServerFixture service)
         {
             _fixture = service;
             service.SpannerMock.Reset();
+            service.DatabaseAdminMock.Reset();
         }
 
         private string ConnectionString => $"Data Source=projects/p1/instances/i1/databases/d1;Host={_fixture.Host};Port={_fixture.Port}";
@@ -54,6 +60,14 @@ public void TestMigrateUsesDdlBatch()
             using var db = new MockMigrationSampleDbContext(ConnectionString);
             db.Database.Migrate();
 
+            var requests = _fixture.SpannerMock.Requests.ToList();
+            // There is one BatchDmlRequest per migration.
+            var batchDmlRequests = requests.OfType<ExecuteBatchDmlRequest>();
+            Assert.Equal(2, batchDmlRequests.Count());
+            // Each BatchDmlRequest is executed as a separate transaction.
+            var commitRequests = requests.OfType<CommitRequest>().ToList();
+            Assert.Equal(2, commitRequests.Count);
+            
             Assert.Collection(_fixture.DatabaseAdminMock.Requests,
                 // The initial request will create an empty database and then create the migrations history table.
                 request => Assert.IsType<CreateDatabaseRequest>(request),
@@ -101,5 +115,83 @@ public void TestMigrateUsesDdlBatch()
                 }
             );
         }
+
+        [Fact]
+        public async Task TestStartMigrateAsync()
+        {
+            var version = typeof(Migration).Assembly.GetName().Version ?? new Version();
+            var formattedVersion = $"{version.Major}.{version.Minor}.{version.Build}";
+            _fixture.SpannerMock.AddOrUpdateStatementResult("SELECT 1", StatementResult.CreateSelect1ResultSet());
+            _fixture.SpannerMock.AddOrUpdateStatementResult(
+                "SELECT EXISTS(SELECT 1 FROM information_schema.tables WHERE table_schema = ''     AND table_name = 'EFMigrationsHistory')",
+                StatementResult.CreateSelectTrueResultSet());
+            _fixture.SpannerMock.AddOrUpdateStatementResult($"SELECT `MigrationId`, `ProductVersion`{Environment.NewLine}" +
+                                                            $"FROM `EFMigrationsHistory`{Environment.NewLine}" +
+                                                            $"ORDER BY `MigrationId`",
+                StatementResult.CreateResultSet(new List<Tuple<Cloud.Spanner.V1.TypeCode, string>>
+                    {
+                        Tuple.Create(Cloud.Spanner.V1.TypeCode.String, "MigrationId"),
+                        Tuple.Create(Cloud.Spanner.V1.TypeCode.String, "ProductVersion"),
+                    },
+                    new List<object[]>
+                    {
+                        new object[] { "20210309110233_Initial", formattedVersion },
+                    }));
+            _fixture.SpannerMock.AddOrUpdateStatementResult(
+                $"INSERT INTO `EFMigrationsHistory` (`MigrationId`, `ProductVersion`)\nVALUES ('''20210830_V2''', '''{formattedVersion}''')",
+                StatementResult.CreateUpdateCount(1)
+            );
+            await using var db = new MockMigrationSampleDbContext(ConnectionString);
+            // This starts an asynchronous database migration, but does not wait for the DDL operation to finish.
+            await db.Database.StartMigrateAsync();
+            
+            Assert.Collection(_fixture.DatabaseAdminMock.Requests,
+                // Each migration will be executed as a separate DDL batch.
+                request =>
+                {
+                    var update = request as UpdateDatabaseDdlRequest;
+                    Assert.NotNull(update);
+                    Assert.Collection(update.Statements,
+                        // Entity Framework 10 executes this regardless whether database provider has already told it
+                        // that the table exists or not.
+                        sql => Assert.StartsWith("CREATE TABLE IF NOT EXISTS `EFMigrationsHistory`", sql)
+                    );
+                }, request =>
+                {
+                    var update = request as UpdateDatabaseDdlRequest;
+                    Assert.NotNull(update);
+                    Assert.Collection(update.Statements,
+                        sql => Assert.StartsWith(" DROP INDEX `IDX_TableWithAllColumnTypes_ColDate_ColCommitTS`", sql),
+                        sql => Assert.StartsWith("DROP TABLE `TableWithAllColumnTypes`", sql),
+                        sql => Assert.StartsWith("CREATE TABLE `OtherSequenceKind` (\n    `Id` INT64 NOT NULL GENERATED BY DEFAULT AS IDENTITY (NON_EXISTING_KIND),\n", sql),
+                        sql => Assert.StartsWith("CREATE TABLE `NoSequenceKind` (\n    `Id` INT64 NOT NULL GENERATED BY DEFAULT AS IDENTITY,\n", sql),
+                        sql => Assert.StartsWith("CREATE TABLE `GenerationStrategyAlways` (\n    `Id` INT64 NOT NULL GENERATED ALWAYS AS IDENTITY (BIT_REVERSED_POSITIVE),\n", sql),
+                        sql => Assert.StartsWith("CREATE TABLE `AutoIncrement` (\n    `Id` INT64 NOT NULL AUTO_INCREMENT,\n", sql)
+                    );
+                }
+            );
+        }
+
+        [Fact]
+        public async Task TestStartDdlAsync()
+        {
+            await using var db = new MockMigrationSampleDbContext(ConnectionString);
+            await db.Database.StartDdlAsync([
+                "create table my_table (id int64 primary key, value string(max))",
+                "create index my_index on my_table (value)",
+            ]);
+            
+            Assert.Collection(_fixture.DatabaseAdminMock.Requests,
+                request =>
+                {
+                    var update = request as UpdateDatabaseDdlRequest;
+                    Assert.NotNull(update);
+                    Assert.Collection(update.Statements,
+                        sql => Assert.Equal("create table my_table (id int64 primary key, value string(max))", sql),
+                        sql => Assert.Equal("create index my_index on my_table (value)", sql)
+                    );
+                }
+            );
+        }
     }
 }

Google.Cloud.EntityFrameworkCore.Spanner.Tests/MigrationTests/Models/SpannerMigrationSampleDbContext.cs

@@ -54,6 +54,9 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                 entity.HasIndex(e => e.Title)
                     .HasDatabaseName("AlbumsByAlbumTitle2")
                     .Storing(a => new { a.MarketingBudget, a.ReleaseDate });
+                entity.HasIndex(e => new { e.SingerId, e.ReleaseDate, e.MarketingBudget, e.Title })
+                    .IsDescending(false, true, true, false)
+                    .HasDatabaseName("AlbumsBySingerIdReleaseDateMarketingBudgetTitle");
 
                 entity.HasOne(d => d.Singer)
                     .WithMany(p => p.Albums)
@@ -76,6 +79,9 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                     .HasForeignKey(d => d.SingerId)
                     .OnDelete(DeleteBehavior.Cascade)
                     .HasConstraintName("FK_Concerts_Singers");
+                entity.HasIndex(concert => new { concert.SingerId, concert.StartTime })
+                    .HasDatabaseName("idx_concerts_singerId_startTime")
+                    .InterleaveIn(typeof(Singers));
 
                 entity.HasOne(d => d.VenueCodeNavigation)
                     .WithMany(p => p.Concerts)

Google.Cloud.EntityFrameworkCore.Spanner.Tests/MockSpannerServer.cs

@@ -68,6 +68,11 @@ internal static StatementResult CreateSelect1ResultSet()
             return CreateSingleColumnResultSet(new V1.Type { Code = V1.TypeCode.Int64 }, "COL1", 1);
         }
 
+        internal static StatementResult CreateSelectTrueResultSet()
+        {
+            return CreateSingleColumnResultSet(new V1.Type { Code = V1.TypeCode.Bool }, "C", true);
+        }
+
         internal static StatementResult CreateSingleColumnResultSet(V1.Type type, string col, params object[] values)
             => CreateSingleColumnResultSet(null, type, col, values);
 
@@ -721,6 +726,8 @@ public class MockDatabaseAdminService : DatabaseAdmin.DatabaseAdminBase
         private readonly ConcurrentQueue<IMessage> _requests = new ConcurrentQueue<IMessage>();
 
         public IEnumerable<IMessage> Requests => new List<IMessage>(_requests).AsReadOnly();
+        
+        public void Reset() => _requests.Clear();
 
         public override Task<Operation> CreateDatabase(CreateDatabaseRequest request, ServerCallContext context)
         {

Google.Cloud.EntityFrameworkCore.Spanner/Extensions/InterleaveInParentExtension.cs

@@ -38,5 +38,19 @@ public static EntityTypeBuilder<TEntity> InterleaveInParent<TEntity>(
             builder.Metadata.AddAnnotation(SpannerAnnotationNames.InterleaveInParentOnDelete, onDelete);
             return builder;
         }
+
+        /// <summary>
+        /// Indicates that an index should be interleaved in a table.
+        /// </summary>
+        /// <param name="builder">The index builder to modify</param>
+        /// <param name="interleaveInEntity">The entity (table) that the index should be interleaved in</param>
+        /// <typeparam name="TEntity">The entity type that owns the index</typeparam>
+        /// <returns> The same builder instance so that multiple configuration calls can be chained.</returns>
+        public static IndexBuilder<TEntity> InterleaveIn<TEntity>(
+            this IndexBuilder<TEntity> builder, System.Type interleaveInEntity) where TEntity : class
+        {
+            builder.Metadata.AddAnnotation(SpannerAnnotationNames.InterleaveIn, interleaveInEntity.FullName);
+            return builder;
+        }
     }
 }