Add new EF 11 features

.claude/settings.json

@@ -0,0 +1,42 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(dotnet test *)",
+      "Bash(dotnet build *)",
+      "Bash(dotnet restore *)",
+      "Bash(dotnet nuget list source)",
+      "Bash(dotnet --info)",
+      "Bash(dotnet --version)",
+      "Bash(dotnet --list-sdks)",
+      "Bash(dotnet --list-runtimes)",
+      "PowerShell(dotnet test *)",
+      "PowerShell(dotnet build *)",
+      "PowerShell(dotnet restore *)",
+      "Bash(git status*)",
+      "Bash(git diff*)",
+      "Bash(git log*)",
+      "Bash(git show*)",
+      "Bash(git branch*)",
+      "Bash(git commit*)",
+      "Bash(git push*)",
+      "PowerShell"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash|PowerShell",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "grep -qE '(^|[;&|(\")])[[:space:]]*(python[0-9.]*|pythonw|py)([[:space:]]|\")|sed[[:space:]]+-[a-zA-Z]*i|sed[[:space:]]+--in-place|>[[:space:]]*[^[:space:];&|]*\\.(cs|md|csproj|props|targets|sln|json|ps1|g4)|tee[[:space:]][^;&|]*\\.(cs|md|csproj|props|targets|sln|json|ps1|g4)' && echo '{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"permissionDecision\":\"deny\",\"permissionDecisionReason\":\"Shell edits to source files (and Python) are disallowed: they bypass file checkpointing, so /rewind cannot undo them. Use Edit or Write instead. Writing logs to the scratchpad is fine.\"}}' || true"
+          },
+          {
+            "type": "command",
+            "command": "in=$(cat); if printf '%s' \"$in\" | grep -qE '(^|[;&(\")]|\\\\n)[[:space:]]*(grep|egrep|fgrep|rg|cat|head|tail|ls|dir|find|fd|fdfind|Get-Content|gc|Get-ChildItem|gci|Select-String|sls)([[:space:]]|\")' && ! printf '%s' \"$in\" | grep -qE '(scratchpad|\\.log|\\$log|/tmp/)'; then echo '{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"permissionDecision\":\"deny\",\"permissionDecisionReason\":\"Reading files through the shell costs a permission prompt and bypasses the dedicated tools. Use Grep for content, Glob for filenames, Read for file contents. Shell text tools stay allowed on scratchpad logs (paths containing scratchpad, .log or $log).\"}}'; fi; true"
+          }
+        ]
+      }
+    ]
+  }
+}

.github/workflows/pull_request.yml

@@ -104,6 +104,7 @@ jobs:
               - 'test/LibRed.Core.Tests/**'
               - 'test/LibRed.EFCore.Tests/**'
               - 'test/LibRed.Engine.Tests/**'
+              - 'test/LibRed.Engine.AccessTests/**'
               - 'test/EFCore.LibRed.FunctionalTests/**'
               # LibRed.Ado references EFCore.Jet.Data and LibRed.EFCore references EFCore.Jet, so a
               # change on the Jet side has to re-run LibRed. The reverse is not true: nothing under
@@ -678,6 +679,12 @@ jobs:
         if: env.skipTests != 'true'
         shell: pwsh
         run: dotnet test .\test\LibRed.Core.Tests --configuration '${{ env.buildConfiguration }}' -p:FixedTestOrder=${{ env.deterministicTests }} --blame-hang-timeout 5m
+      # The engine tests that cross-check against ACE. They belong here rather than in the cross-platform
+      # LibRed job above, which runs on five platforms precisely to prove LibRed needs no ACE at all.
+      - name: 'Run Tests: LibRed.Engine.AccessTests'
+        if: always() && env.skipTests != 'true'
+        shell: pwsh
+        run: dotnet test .\test\LibRed.Engine.AccessTests --configuration '${{ env.buildConfiguration }}' -p:FixedTestOrder=${{ env.deterministicTests }} --blame-hang-timeout 5m
       - name: 'Run Tests: LibRed.Ado.Tests'
         if: always() && env.skipTests != 'true'
         shell: pwsh

.github/workflows/push.yml

@@ -686,6 +686,12 @@ jobs:
         if: env.skipTests != 'true'
         shell: pwsh
         run: dotnet test .\test\LibRed.Core.Tests --configuration '${{ env.buildConfiguration }}' -p:FixedTestOrder=${{ env.deterministicTests }} --blame-hang-timeout 5m
+      # The engine tests that cross-check against ACE. They belong here rather than in the cross-platform
+      # LibRed job above, which runs on five platforms precisely to prove LibRed needs no ACE at all.
+      - name: 'Run Tests: LibRed.Engine.AccessTests'
+        if: always() && env.skipTests != 'true'
+        shell: pwsh
+        run: dotnet test .\test\LibRed.Engine.AccessTests --configuration '${{ env.buildConfiguration }}' -p:FixedTestOrder=${{ env.deterministicTests }} --blame-hang-timeout 5m
       - name: 'Run Tests: LibRed.Ado.Tests'
         if: always() && env.skipTests != 'true'
         shell: pwsh

EFCore.Jet.sln

@@ -1,7 +1,7 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 18
-VisualStudioVersion = 18.9.12009.208 insiders
+VisualStudioVersion = 18.9.12009.208
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{F68095EE-6CD1-43A2-B498-6CA72CE2A0CB}"
 	ProjectSection(SolutionItems) = preProject
@@ -82,6 +82,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EFCore.LibRed.FunctionalTes
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LibRed.Benchmarks", "test\LibRed.Benchmarks\LibRed.Benchmarks.csproj", "{6F69127C-9481-48B2-A974-F9A7F38BB9EC}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LibRed.Engine.AccessTests", "test\LibRed.Engine.AccessTests\LibRed.Engine.AccessTests.csproj", "{5287C755-947C-448E-BBE4-48D47051D35F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -332,6 +334,18 @@ Global
 		{6F69127C-9481-48B2-A974-F9A7F38BB9EC}.Release|x64.Build.0 = Release|Any CPU
 		{6F69127C-9481-48B2-A974-F9A7F38BB9EC}.Release|x86.ActiveCfg = Release|Any CPU
 		{6F69127C-9481-48B2-A974-F9A7F38BB9EC}.Release|x86.Build.0 = Release|Any CPU
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Debug|x64.ActiveCfg = Debug|x64
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Debug|x64.Build.0 = Debug|x64
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Debug|x86.ActiveCfg = Debug|x86
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Debug|x86.Build.0 = Debug|x86
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Release|x64.ActiveCfg = Release|x64
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Release|x64.Build.0 = Release|x64
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Release|x86.ActiveCfg = Release|x86
+		{5287C755-947C-448E-BBE4-48D47051D35F}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -358,6 +372,7 @@ Global
 		{CADF8601-1CF1-421B-AACF-EE2C16AC610B} = {6A8DE399-1804-4113-A408-F23B7F5C9CAC}
 		{0F741500-BC61-44FA-9642-3B3326F7C90E} = {6A8DE399-1804-4113-A408-F23B7F5C9CAC}
 		{6F69127C-9481-48B2-A974-F9A7F38BB9EC} = {6A8DE399-1804-4113-A408-F23B7F5C9CAC}
+		{5287C755-947C-448E-BBE4-48D47051D35F} = {6A8DE399-1804-4113-A408-F23B7F5C9CAC}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {9359773D-6399-447E-9814-6CB41C2FB664}

src/EFCore.Jet/Migrations/Internal/JetHistoryRepository.cs

@@ -29,7 +29,29 @@ namespace EntityFrameworkCore.Jet.Migrations.Internal
     /// </remarks>
     public class JetHistoryRepository(HistoryRepositoryDependencies dependencies) : HistoryRepository(dependencies)
     {
-        private static readonly TimeSpan _retryDelay = TimeSpan.FromSeconds(1);
+        // Migration-lock retry policy. The lock guards a migration and is released explicitly the moment that
+        // migration finishes, so contention resolves in milliseconds — these delays are sized for a local file,
+        // not for a round trip to a remote server.
+        //
+        // The previous policy started at one second and doubled while under a minute, which had three separate
+        // faults that compounded: the delay was never reset, so a thread that lost a single race retried only
+        // once every 64 seconds for the rest of the run; there was no jitter, so every contender woke in the
+        // same millisecond, collided, and all but one backed off together; and the cap was 60 seconds, four
+        // orders of magnitude above the hold time. With N contenders in lockstep exactly one wins per round,
+        // making a run take N x 64s — about sixteen minutes for fifteen threads, which is indistinguishable
+        // from a deadlock and is why the parallel migration tests read as "hung" rather than "slow".
+        private static readonly TimeSpan _retryDelay = TimeSpan.FromMilliseconds(50);
+        private static readonly TimeSpan _maxRetryDelay = TimeSpan.FromSeconds(1);
+
+        /// <summary>How long to keep trying for the migration lock before giving up.</summary>
+        /// <remarks>
+        ///     Without a deadline the retry loop cannot fail, only wait, so a lock that is never released blocks
+        ///     the caller forever with nothing logged — the failure mode is a silent hang rather than an error
+        ///     anyone can act on. Giving up turns it into a reportable fault, as SQL Server's
+        ///     <c>sp_getapplock</c> timeout does.
+        /// </remarks>
+        private static readonly TimeSpan _lockTimeout = TimeSpan.FromMinutes(1);
+
         public override LockReleaseBehavior LockReleaseBehavior => LockReleaseBehavior.Explicit;
 
         /// <summary>
@@ -146,9 +168,9 @@ public override IMigrationsDatabaseLock AcquireDatabaseLock()
             }
 
             var retryDelay = _retryDelay;
+            var deadline = DateTime.UtcNow + _lockTimeout;
             while (true)
             {
-                var dbLock = CreateMigrationDatabaseLock();
                 int? insertCount = 0;
                 //No CREATE TABLE IF EXISTS in Jet. We try a normal CREATE TABLE and catch the exception if it already exists
                 try
@@ -162,14 +184,18 @@ public override IMigrationsDatabaseLock AcquireDatabaseLock()
                 }
                 if ((int)insertCount! == 1)
                 {
-                    return dbLock;
+                    // Built only once the lock is actually ours; the old loop constructed one per attempt and
+                    // dropped it on every miss.
+                    return CreateMigrationDatabaseLock();
                 }
 
-                Thread.Sleep(retryDelay);
-                if (retryDelay < TimeSpan.FromMinutes(1))
+                if (DateTime.UtcNow >= deadline)
                 {
-                    retryDelay = retryDelay.Add(retryDelay);
+                    throw new TimeoutException(LockTimeoutMessage());
                 }
+
+                Thread.Sleep(JitteredDelay(retryDelay));
+                retryDelay = EscalateDelay(retryDelay);
             }
         }
 
@@ -182,30 +208,72 @@ public override async Task<IMigrationsDatabaseLock> AcquireDatabaseLockAsync(
                     await Dependencies.RawSqlCommandBuilder.Build(CreateExistsSql(LockTableName))
                         .ExecuteScalarAsync(CreateRelationalCommandParameters(), cancellationToken).ConfigureAwait(false)))
             {
-                await CreateLockTableCommand().ExecuteNonQueryAsync(CreateRelationalCommandParameters(), cancellationToken)
-                    .ConfigureAwait(false);
+                // Same guard as the synchronous overload, which this had been missing: the exists check above
+                // is not atomic, so concurrent migrators can all decide the table is absent and all issue the
+                // CREATE. Losing that race is the normal path, not a failure.
+                try
+                {
+                    await CreateLockTableCommand()
+                        .ExecuteNonQueryAsync(CreateRelationalCommandParameters(), cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                catch (DbException e)
+                {
+                    if (!e.Message.Contains("already exists")) throw;
+                }
             }
 
             var retryDelay = _retryDelay;
+            var deadline = DateTime.UtcNow + _lockTimeout;
             while (true)
             {
-                var dbLock = CreateMigrationDatabaseLock();
-                var insertCount = await CreateInsertLockCommand(DateTimeOffset.UtcNow)
-                    .ExecuteScalarAsync(CreateRelationalCommandParameters(), cancellationToken)
-                    .ConfigureAwait(false);
+                int? insertCount = 0;
+                try
+                {
+                    insertCount = (int?)await CreateInsertLockCommand(DateTimeOffset.UtcNow)
+                        .ExecuteScalarAsync(CreateRelationalCommandParameters(), cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                catch (DbException e)
+                {
+                    // Likewise mirrored from the synchronous overload: the WHERE NOT EXISTS guard on the
+                    // insert is not atomic either, so a duplicate key here means someone else took the lock.
+                    if (!e.Message.Contains("duplicate")) throw;
+                }
                 if ((int)insertCount! == 1)
                 {
-                    return dbLock;
+                    return CreateMigrationDatabaseLock();
                 }
 
-                await Task.Delay(retryDelay, cancellationToken).ConfigureAwait(false);
-                if (retryDelay < TimeSpan.FromMinutes(1))
+                if (DateTime.UtcNow >= deadline)
                 {
-                    retryDelay = retryDelay.Add(retryDelay);
+                    throw new TimeoutException(LockTimeoutMessage());
                 }
+
+                await Task.Delay(JitteredDelay(retryDelay), cancellationToken).ConfigureAwait(false);
+                retryDelay = EscalateDelay(retryDelay);
             }
         }
 
+        /// <summary>
+        ///     Spreads the wait by +/-25% so contenders stop waking together. This matters as much as the cap:
+        ///     with a fixed delay every loser retries in the same millisecond as every other loser, so the herd
+        ///     stays synchronised and each round yields exactly one winner no matter how short the delay is.
+        /// </summary>
+        private static TimeSpan JitteredDelay(TimeSpan delay)
+            => TimeSpan.FromTicks((long)(delay.Ticks * (0.75 + (Random.Shared.NextDouble() / 2.0))));
+
+        /// <summary>Doubles the backoff up to <see cref="_maxRetryDelay" /> and holds there.</summary>
+        private static TimeSpan EscalateDelay(TimeSpan delay)
+            => delay >= _maxRetryDelay
+                ? _maxRetryDelay
+                : TimeSpan.FromTicks(Math.Min(delay.Ticks * 2, _maxRetryDelay.Ticks));
+
+        private string LockTimeoutMessage()
+            => $"Timed out after {_lockTimeout.TotalSeconds:N0}s waiting for the migrations lock. Another "
+                + $"migration may still be running, or a previous one may have left a row in "
+                + $"'{LockTableName}' without releasing it; delete that row to clear the lock.";
+
         private IRelationalCommand CreateLockTableCommand()
             => Dependencies.RawSqlCommandBuilder.Build($"""
 CREATE TABLE `{LockTableName}` (