Increase performance

On large operations, the whole DB was in memory. Like 0.5 GB of data sorted with LINQ. This commit makes the pagination happen on the DB. Yippe!

Author: Simyon264

Server/Api/ReplayController.cs

@@ -96,17 +96,16 @@ public async Task<ActionResult> SearchReplays(
             return BadRequest("The page number cannot be negative.");
         }
 
-        var found = ReplayParser.SearchReplays(searchMode, query, _context);
+        var found = ReplayParser.SearchReplays(searchMode, query, _context, page, Constants.ReplaysPerPage);
+        
         // Order found replays by date
         found = found.OrderByDescending(r => r.Date ?? DateTime.MinValue).Take(Constants.SearchLimit).ToList();
 
         var pageCount = Paginator.GetPageCount(found.Count, Constants.ReplaysPerPage);
-        var offset = Paginator.GetOffset(page, Constants.ReplaysPerPage);
-        var paginated = found.Skip(offset).Take(Constants.ReplaysPerPage).ToList();
 
         return Ok(new SearchResult()
         {
-            Replays = paginated,
+            Replays = found,
             PageCount = pageCount,
             CurrentPage = page,
             TotalReplays = found.Count

Server/ReplayParser.cs

@@ -294,46 +294,62 @@ public static HttpClient CreateHttpClient()
     /// <exception cref="NotImplementedException">
     /// Thrown when the search mode is not implemented.
     /// </exception>
-    public static List<Replay> SearchReplays(SearchMode mode, string query, ReplayDbContext context)
+public static List<Replay> SearchReplays(SearchMode mode, string query, ReplayDbContext context, int page, int pageSize)
+{
+    var queryable = context.Replays.AsQueryable();
+
+    IIncludableQueryable<Player, Replay?>? players;
+    IQueryable<int?>? replayIds;
+    switch (mode)
     {
-        var queryable = context.Replays.AsQueryable();
+        case SearchMode.Map:
+            queryable = queryable.Where(x => x.Map.ToLower().Contains(query.ToLower()));
+            break;
+        case SearchMode.Gamemode:
+            queryable = queryable.Where(x => x.Gamemode.ToLower().Contains(query.ToLower()));
+            break;
+        case SearchMode.ServerId:
+            queryable = queryable.Where(x => x.ServerId.ToLower().Contains(query.ToLower()));
+            break;
+        case SearchMode.Guid:
+            players = context.Players
+                .Where(p => p.PlayerGuid.ToString().ToLower().Contains(query.ToLower()))
+                .Include(p => p.Replay);
+            replayIds = players.Select(p => p.ReplayId).Distinct();
+            queryable = context.Replays.Where(r => replayIds.Contains(r.Id));
+            break;
+        case SearchMode.PlayerIcName:
+            players = context.Players
+                .Where(p => p.PlayerIcName.ToLower().Contains(query.ToLower()))
+                .Include(p => p.Replay);
+            replayIds = players.Select(p => p.ReplayId).Distinct();
+            queryable = context.Replays.Where(r => replayIds.Contains(r.Id));
+            break;
+        case SearchMode.PlayerOocName:
+            players = Context.Players
+                .Where(p => p.PlayerOocName.ToLower().Contains(query.ToLower()))
+                .Include(p => p.Replay);
+            replayIds = players.Select(p => p.ReplayId).Distinct();
+            queryable = Context.Replays.Where(r => replayIds.Contains(r.Id));
+            break;
+        case SearchMode.RoundEndText:
+            queryable = queryable.Where(x => x.RoundEndText != null && x.RoundEndText.ToLower().Contains(query.ToLower()));
+            break;
+        case SearchMode.ServerName:
+            queryable = queryable.Where(x => x.ServerName != null && x.ServerName.ToLower().Contains(query.ToLower()));
+            break;
+        case SearchMode.RoundId:
+            queryable = queryable.Where(x => x.RoundId != null && x.RoundId.ToString().Contains(query));
+            break;
+        default:
+            throw new NotImplementedException();
+    }
 
-        IIncludableQueryable<Player, Replay?>? players;
-        IQueryable<int?>? replayIds;
-        switch (mode)
-        {
-            case SearchMode.Map:
-                return queryable.Where(x => x.Map.ToLower().Contains(query.ToLower())).Include(r => r.RoundEndPlayers).ToList();
-            case SearchMode.Gamemode:
-                return queryable.Where(x => x.Gamemode.ToLower().Contains(query.ToLower())).Include(r => r.RoundEndPlayers).ToList();
-            case SearchMode.ServerId:
-                return queryable.Where(x => x.ServerId.ToLower().Contains(query.ToLower())).Include(r => r.RoundEndPlayers).ToList();
-            case SearchMode.Guid:
-                players = context.Players
-                    .Where(p => p.PlayerGuid.ToString().ToLower().Contains(query.ToLower()))
-                    .Include(p => p.Replay);
-                replayIds = players.Select(p => p.ReplayId).Distinct();
-                return context.Replays.Where(r => replayIds.Contains(r.Id)).Include(r => r.RoundEndPlayers).ToList();
-            case SearchMode.PlayerIcName:
-                players = context.Players
-                    .Where(p => p.PlayerIcName.ToLower().Contains(query.ToLower()))
-                    .Include(p => p.Replay);
-                replayIds = players.Select(p => p.ReplayId).Distinct();
-                return context.Replays.Where(r => replayIds.Contains(r.Id)).Include(r => r.RoundEndPlayers).ToList();
-            case SearchMode.PlayerOocName:
-                players = Context.Players
-                    .Where(p => p.PlayerOocName.ToLower().Contains(query.ToLower()))
-                    .Include(p => p.Replay);
-                replayIds = players.Select(p => p.ReplayId).Distinct();
-                return Context.Replays.Where(r => replayIds.Contains(r.Id)).Include(r => r.RoundEndPlayers).ToList();
-            case SearchMode.RoundEndText:
-                return queryable.Where(x => x.RoundEndText != null && x.RoundEndText.ToLower().Contains(query.ToLower())).Include(r => r.RoundEndPlayers).ToList();
-            case SearchMode.ServerName:
-                return queryable.Where(x => x.ServerName != null && x.ServerName.ToLower().Contains(query.ToLower())).Include(r => r.RoundEndPlayers).ToList();
-            case SearchMode.RoundId:
-                return queryable.Where(x => x.RoundId != null && x.RoundId.ToString().Contains(query)).Include(r => r.RoundEndPlayers).ToList();
-            default:
-                throw new NotImplementedException();
-        }
+    // Apply pagination on the database query
+    return queryable
+        .Skip(page * pageSize)
+        .Take(pageSize)
+        .Include(r => r.RoundEndPlayers)
+        .ToList();
     }
 }