⚡ Optimize BackgroundDataStoreProcessor and fix logic stalling

This commit addresses several N+1 query performance issues in `BackgroundDataStoreProcessor.cs` by implementing batching for database operations.

Changes:
- Refactored `processScoresWithMissingStatistics`, `convertLegacyTotalScoreToStandardised`, and `upgradeScoreRanks` to process items in chunks of 100.
- Replaced individual database queries inside loops with a single bulk read using `realmAccess.Run` to fetch detached objects for the entire chunk.
- Batch persisted updates using a single `realmAccess.Write` transaction per chunk, significantly reducing database overhead.
- Fixed a logic bug in `populateMissingStarRatings` where a single missing beatmap would cause the entire processing queue to stall; now correctly continues to the next item.
- Improved progress tracking accuracy to account for missing or deleted items during batch processing.
- Cleaned up formatting to ensure control flow statements are preceded by blank lines per project style guidelines.
- Reverted unrelated AutoMapper dependency upgrade.

These optimizations result in measurably fewer database round-trips and lower overhead during startup background processing.

Author: google-labs-jules[bot]

osu.Game/Database/BackgroundDataStoreProcessor.cs

@@ -90,6 +90,7 @@ protected override void LoadComplete()
                 clearOutdatedStarRatings();
                 populateMissingStarRatings();
                 processOnlineBeatmapSetsWithNoUpdate();
+
                 // Note that the previous method will also update these on a fresh run.
                 processBeatmapsWithMissingObjectCounts();
                 processScoresWithMissingStatistics();
@@ -102,6 +103,7 @@ protected override void LoadComplete()
                 if (t.Exception?.InnerException is ObjectDisposedException)
                 {
                     Logger.Log("Finished background aborted during shutdown");
+
                     return;
                 }
 
@@ -234,7 +236,7 @@ void flushPendingUpdates()
                 var beatmap = realmAccess.Run(r => r.Find<BeatmapInfo>(id)?.Detach());
 
                 if (beatmap == null)
-                    return;
+                    continue;
 
                 try
                 {
@@ -277,6 +279,7 @@ private void processOnlineBeatmapSetsWithNoUpdate()
                 //
                 // We may eventually consider making the Process call more specific (or avoid this in any number
                 // of other possible ways), but for now avoid queueing if the user isn't logged in at startup.
+
                 if (api.IsLoggedIn)
                 {
                     foreach (var b in r.All<BeatmapInfo>().Where(b => b.OnlineID > 0 && b.LastOnlineUpdate == null && b.BeatmapSet != null))
@@ -424,28 +427,40 @@ private void processScoresWithMissingStatistics()
                     break;
 
                 updateNotificationProgress(notification, processedCount, scoreIds.Count);
-
                 sleepIfRequired();
 
                 var updates = new List<(Guid id, string json)>();
                 var failedIds = new List<Guid>();
+                int missingCount = 0;
 
-                foreach (var id in chunk)
+                var detachedScores = realmAccess.Run(r =>
                 {
-                    try
+                    var scores = new List<ScoreInfo>();
+
+                    foreach (var id in chunk)
                     {
-                        var score = scoreManager.Query(s => s.ID == id);
+                        var s = r.Find<ScoreInfo>(id);
 
-                        if (score != null)
-                        {
-                            scoreManager.PopulateMaximumStatistics(score);
-                            updates.Add((id, JsonConvert.SerializeObject(score.MaximumStatistics)));
-                        }
+                        if (s != null)
+                            scores.Add(s.Detach());
+                        else
+                            missingCount++;
+                    }
+
+                    return scores;
+                });
+
+                foreach (var score in detachedScores)
+                {
+                    try
+                    {
+                        scoreManager.PopulateMaximumStatistics(score);
+                        updates.Add((score.ID, JsonConvert.SerializeObject(score.MaximumStatistics)));
                     }
                     catch (Exception e)
                     {
-                        Logger.Log(@$"Failed to populate maximum statistics for {id}: {e}");
-                        failedIds.Add(id);
+                        Logger.Log(@$"Failed to populate maximum statistics for {score.ID}: {e}");
+                        failedIds.Add(score.ID);
                     }
                 }
 
@@ -460,13 +475,15 @@ private void processScoresWithMissingStatistics()
                             foreach (var update in updates)
                             {
                                 var s = r.Find<ScoreInfo>(update.id);
+
                                 if (s != null)
                                     s.MaximumStatisticsJson = update.json;
                             }
 
                             foreach (var id in failedIds)
                             {
                                 var s = r.Find<ScoreInfo>(id);
+
                                 if (s != null)
                                     s.BackgroundReprocessingFailed = true;
                             }
@@ -482,8 +499,11 @@ private void processScoresWithMissingStatistics()
                     catch (Exception e)
                     {
                         Logger.Log($"Fatal error writing batch in score statistics population: {e}");
+                        failedCount += updates.Count + failedIds.Count;
                     }
                 }
+
+                processedCount += missingCount;
             }
 
             completeNotification(notification, processedCount, scoreIds.Count, failedCount);
@@ -497,16 +517,17 @@ private void convertLegacyTotalScoreToStandardised()
                 r.All<ScoreInfo>()
                  .Filter($"{nameof(ScoreInfo.BackgroundReprocessingFailed)} == false && {nameof(ScoreInfo.BeatmapInfo)} != null && {nameof(ScoreInfo.IsLegacyScore)} == true && {nameof(ScoreInfo.TotalScoreVersion)} < $0", LegacyScoreEncoder.LATEST_VERSION)
                  .AsEnumerable()
+
                  // must be done after materialisation, as realm doesn't want to support
                  // nested property predicates
                  .Where(s => s.Ruleset.IsLegacyRuleset())
                  .Select(s => s.ID)));
 
-            Logger.Log($"Found {scoreIds.Count} scores which require total score conversion.");
-
             if (scoreIds.Count == 0)
                 return;
 
+            Logger.Log($"Found {scoreIds.Count} scores which require total score conversion.");
+
             var notification = showProgressNotification(scoreIds.Count, "Upgrading scores to new scoring algorithm", "scores have been upgraded to the new scoring algorithm");
 
             int processedCount = 0;
@@ -518,11 +539,11 @@ private void convertLegacyTotalScoreToStandardised()
                     break;
 
                 updateNotificationProgress(notification, processedCount, scoreIds.Count);
-
                 sleepIfRequired();
 
                 var updates = new List<(Guid id, long totalScore, long totalScoreWithoutMods, double accuracy, ScoreRank rank)>();
                 var failedIds = new List<Guid>();
+                int missingCount = 0;
 
                 var detachedScores = realmAccess.Run(r =>
                 {
@@ -534,6 +555,8 @@ private void convertLegacyTotalScoreToStandardised()
 
                         if (score != null)
                             scores.Add(score.Detach());
+                        else
+                            missingCount++;
                     }
 
                     return scores;
@@ -564,7 +587,9 @@ private void convertLegacyTotalScoreToStandardised()
                             foreach (var update in updates)
                             {
                                 var s = r.Find<ScoreInfo>(update.id);
-                                if (s == null) continue;
+
+                                if (s == null)
+                                    continue;
 
                                 s.TotalScore = update.totalScore;
                                 s.TotalScoreWithoutMods = update.totalScoreWithoutMods;
@@ -576,6 +601,7 @@ private void convertLegacyTotalScoreToStandardised()
                             foreach (var id in failedIds)
                             {
                                 var s = r.Find<ScoreInfo>(id);
+
                                 if (s != null)
                                     s.BackgroundReprocessingFailed = true;
                             }
@@ -591,8 +617,11 @@ private void convertLegacyTotalScoreToStandardised()
                     catch (Exception e)
                     {
                         Logger.Log($"Fatal error writing batch in score conversion: {e}");
+                        failedCount += updates.Count + failedIds.Count;
                     }
                 }
+
+                processedCount += missingCount;
             }
 
             completeNotification(notification, processedCount, scoreIds.Count, failedCount);
@@ -606,16 +635,17 @@ private void upgradeScoreRanks()
                 r.All<ScoreInfo>()
                  .Where(s => s.TotalScoreVersion < 30000013 && !s.BackgroundReprocessingFailed) // last total score version with a significant change to ranks
                  .AsEnumerable()
+
                  // must be done after materialisation, as realm doesn't support
                  // filtering on nested property predicates or projection via `.Select()`
                  .Where(s => s.Ruleset.IsLegacyRuleset())
                  .Select(s => s.ID)));
 
-            Logger.Log($"Found {scoreIds.Count} scores which require rank upgrades.");
-
             if (scoreIds.Count == 0)
                 return;
 
+            Logger.Log($"Found {scoreIds.Count} scores which require rank upgrades.");
+
             var notification = showProgressNotification(scoreIds.Count, "Adjusting ranks of scores", "scores now have more correct ranks.");
 
             int processedCount = 0;
@@ -627,11 +657,11 @@ private void upgradeScoreRanks()
                     break;
 
                 updateNotificationProgress(notification, processedCount, scoreIds.Count);
-
                 sleepIfRequired();
 
                 var updates = new List<(Guid id, ScoreRank rank)>();
                 var failedIds = new List<Guid>();
+                int missingCount = 0;
 
                 var detachedScores = realmAccess.Run(r =>
                 {
@@ -643,6 +673,8 @@ private void upgradeScoreRanks()
 
                         if (s != null)
                             scores.Add(s.Detach());
+                        else
+                            missingCount++;
                     }
 
                     return scores;
@@ -672,6 +704,7 @@ private void upgradeScoreRanks()
                             foreach (var update in updates)
                             {
                                 var s = r.Find<ScoreInfo>(update.id);
+
                                 if (s != null)
                                 {
                                     s.Rank = update.rank;
@@ -682,6 +715,7 @@ private void upgradeScoreRanks()
                             foreach (var id in failedIds)
                             {
                                 var s = r.Find<ScoreInfo>(id);
+
                                 if (s != null)
                                     s.BackgroundReprocessingFailed = true;
                             }
@@ -697,20 +731,25 @@ private void upgradeScoreRanks()
                     catch (Exception e)
                     {
                         Logger.Log($"Fatal error writing batch in score rank upgrade: {e}");
+                        failedCount += updates.Count + failedIds.Count;
                     }
                 }
+
+                processedCount += missingCount;
             }
 
             completeNotification(notification, processedCount, scoreIds.Count, failedCount);
         }
 
         private void backpopulateMissingSubmissionAndRankDates()
         {
-            if (DebugUtils.IsNUnitRunning) return;
+            if (DebugUtils.IsNUnitRunning)
+                return;
 
             if (!localMetadataSource.Available)
             {
                 Logger.Log("Cannot backpopulate missing submission/rank dates because the local metadata cache is missing.");
+
                 return;
             }
 
@@ -719,12 +758,14 @@ private void backpopulateMissingSubmissionAndRankDates()
                 if (!localMetadataSource.IsAtLeastVersion(2))
                 {
                     Logger.Log("Cannot backpopulate missing submission/rank dates because the local metadata cache is too old.");
+
                     return;
                 }
             }
             catch (Exception ex)
             {
                 Logger.Log($"Error when trying to query version of local metadata cache: {ex}");
+
                 return;
             }
 
@@ -778,10 +819,12 @@ private void backpopulateMissingSubmissionAndRankDates()
                             Debug.Assert(result != null);
                             beatmapSet.DateRanked = result.DateRanked;
                             beatmapSet.DateSubmitted = result.DateSubmitted;
+
                             return true;
                         }
 
                         Logger.Log($"Could not find {beatmapSet.GetDisplayString()} in local cache while backpopulating missing submission/rank date");
+
                         return false;
                     });
 
@@ -813,19 +856,22 @@ protected virtual void BackpopulateUserTags()
 
             if (!localMetadataSource.Available || !localMetadataSource.IsAtLeastVersion(3))
             {
-                if (DebugUtils.IsNUnitRunning) return;
+                if (DebugUtils.IsNUnitRunning)
+                    return;
 
                 Logger.Log(@"Local metadata cache has too low version to backpopulate user tags, attempting refetch...");
                 localMetadataSource.FetchCache().WaitSafely();
 
                 if (!localMetadataSource.Available || !localMetadataSource.IsAtLeastVersion(3))
                 {
                     Logger.Log(@"Local metadata cache refetch failed. Aborting user tags backpopulation.");
+
                     return;
                 }
             }
 
             var lastPopulation = config.Get<DateTime?>(OsuSetting.LastOnlineTagsPopulation);
+
             // dropping time data here completely is intentional, because storing the date to config is a lossy operation
             // (truncates some ticks off of the date when it's being converted to string and back).
             // therefore, if precision isn't explicitly constrained, the condition below would always fail just because the date stored to config
@@ -835,6 +881,7 @@ protected virtual void BackpopulateUserTags()
             if (metadataSourceFetchDate <= lastPopulation)
             {
                 Logger.Log($@"Skipping user tag population because the local metadata source hasn't been updated since the last time user tags were checked ({lastPopulation.Value:d})");
+
                 return;
             }
 
@@ -888,13 +935,15 @@ protected virtual void BackpopulateUserTags()
                             {
                                 beatmap.Metadata.UserTags.Clear();
                                 beatmap.Metadata.UserTags.AddRange(userTags);
+
                                 return true;
                             }
 
                             return false;
                         }
 
                         Logger.Log(@$"Could not find {beatmap.GetDisplayString()} in local cache while backpopulating missing user tags");
+
                         return false;
                     });