0

Tối ưu EF Core: những query nhìn vô hại mà kéo cả bảng về

Endpoint danh sách đơn hàng hồi mới làm trả về trong vài chục mili giây. Một năm sau, data nhiều lên, nó mất hơn 2 giây, rồi 4 giây. Code không ai đụng vào. Bật log SQL lên xem thử thì giật mình: một request của trang đó bắn ra hơn 200 câu query xuống SQL Server.

EF Core làm việc với database dễ tới mức mình quên mất bên dưới vẫn là SQL. Bài này gom mấy kiểu viết LINQ nhìn vô hại mà mình từng thấy kéo cả bảng về, hoặc bắn query như súng liên thanh, kèm cách nhận ra và cách viết lại. Ví dụ dùng SQL Server.

Trước hết: nhìn xem EF sinh ra SQL gì

Không nhìn SQL thì mọi chuyện tối ưu EF Core đều là đoán. Cách nhanh nhất là bật log ở môi trường dev qua appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Microsoft.EntityFrameworkCore.Database.Command": "Information"
    }
  }
}

Từ giờ mỗi câu query EF gửi xuống đều hiện trong console, kèm thời gian chạy. Hoặc gắn thẳng vào DbContext khi cấu hình:

builder.Services.AddDbContext<AppDbContext>(options =>
{
    options.UseSqlServer(connectionString);
    if (builder.Environment.IsDevelopment())
    {
        options.LogTo(Console.WriteLine, LogLevel.Information);
        // Hiện cả giá trị tham số: chỉ bật ở dev, vì log có thể chứa data thật
        options.EnableSensitiveDataLogging();
    }
});

Thói quen của mình: viết xong một query EF quan trọng thì mở log ra đọc câu SQL ít nhất một lần. Câu nào trông lạ thì copy sang SSMS, bật "Include Actual Execution Plan" (Ctrl+M) rồi chạy. Cách đọc execution plan mình đã viết kỹ ở bài về query chậm bên series SQL, ví dụ bên đó dùng PostgreSQL nhưng cách nghĩ thì y hệt.

Hơn 200 query cho một trang: N+1

Thủ phạm của endpoint đầu bài:

var orders = await _db.Orders
    .Where(o => o.CreatedAt >= from)
    .ToListAsync(ct);

var result = orders.Select(o => new OrderDto
{
    Id = o.Id,
    // Lazy loading: mỗi lần chạm vào o.Customer là một query mới xuống DB
    CustomerName = o.Customer.Name,
    Total = o.Total
}).ToList();

Project bật lazy loading (UseLazyLoadingProxies() cùng navigation property virtual). Một query lấy 200 đơn, rồi mỗi đơn chạm vào Customer là thêm một query. 201 query, mỗi câu chỉ vài mili giây nên slow query log không bắt được câu nào. Đúng y bài N+1 bên series SQL, chỉ khác là ORM giấu nó kỹ hơn.

Không bật lazy loading cũng không thoát: gọi DB trong vòng foreach là cùng một chuyện.

Sửa bằng cách nói cho EF biết mình cần gì ngay từ đầu, để nó sinh ra một câu JOIN:

var result = await _db.Orders
    .Where(o => o.CreatedAt >= from)
    .Select(o => new OrderDto
    {
        Id = o.Id,
        CustomerName = o.Customer.Name, // nằm trong Select nên EF dịch thành JOIN
        Total = o.Total
    })
    .ToListAsync(ct);

Từ 201 query xuống còn 1. Cá nhân mình không bật lazy loading trong project web: nó tiện lúc viết, nhưng biến mọi dòng chạm vào navigation thành một query tiềm ẩn mà review không ai thấy.

ToList() đặt sai chỗ

// Kéo hết bảng Orders về RAM rồi mới lọc
var bigOrders = _db.Orders.ToList().Where(o => o.Total > 1_000_000);

Dòng này nhìn sai rõ ràng, ít ai viết thẳng như vậy. Biến thể khó thấy hơn nằm ở repository:

// Kiểu trả về là IEnumerable chứ không phải IQueryable
public IEnumerable<Order> GetAll() => _db.Orders;

// Ở chỗ gọi: Where này chạy trong RAM, sau khi đã kéo hết bảng về
var bigOrders = _repo.GetAll().Where(o => o.Total > 1_000_000).ToList();

Chỉ vì kiểu trả về là IEnumerable<Order>, mọi Where, OrderBy, Take phía sau đều thành LINQ to Objects. SQL gửi xuống là SELECT ... FROM [Orders] không có WHERE. Bảng 10 nghìn dòng thì chẳng ai thấy gì, bảng 10 triệu dòng thì server hết RAM.

Quy tắc của mình: lọc, sắp xếp, phân trang phải xảy ra trước ToListAsync(), và method nào trả dữ liệu để người khác lọc tiếp thì trả IQueryable. Còn method đã lọc xong thì trả List hay IReadOnlyList cho rõ ràng.

Chỉ đọc thì đừng track

Mặc định EF Core track mọi entity nó load lên, để lúc SaveChanges biết cái gì đã đổi. Với endpoint chỉ đọc, đó là công sức thừa: tốn bộ nhớ cho snapshot và tốn CPU để dựng change tracker.

var orders = await _db.Orders
    .AsNoTracking()
    .Where(o => o.CustomerId == customerId)
    .ToListAsync(ct);

Nếu phần lớn query trong app là đọc, có thể đặt mặc định cho cả DbContext bằng UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking), chỗ nào cần sửa thì gọi AsTracking(). Còn nếu đã Select ra DTO như ví dụ N+1 ở trên thì không cần nghĩ: EF không track những object không phải entity.

Lấy đúng cột cần dùng

Load nguyên entity Order khi màn hình chỉ cần 3 cột nghĩa là kéo về cả cột Note kiểu nvarchar(max), cột JSON địa chỉ, và mọi thứ khác. Select ra DTO thì câu SQL chỉ có đúng mấy cột đó, và nếu có index chứa đủ các cột cần lấy, SQL Server có thể trả kết quả chỉ từ index mà không cần đọc bảng. Đây cũng là lý do bài SQL sạch khuyên không SELECT *; load entity không cần thiết chính là SELECT * đội lốt LINQ.

Include nhiều collection: số dòng nổ tung

var order = await _db.Orders
    .Include(o => o.Items)     // 50 dòng sản phẩm
    .Include(o => o.Payments)  // 4 lần thanh toán
    .Include(o => o.Histories) // 30 dòng lịch sử
    .FirstAsync(o => o.Id == id, ct);

EF dịch thành một câu với các LEFT JOIN nối tiếp. Ba collection 50, 4 và 30 dòng nối với nhau thành 50 × 4 × 30 = 6.000 dòng gửi về, để rồi EF lọc trùng lại còn đúng 84 entity con. Người ta gọi là cartesian explosion, và EF Core có log hẳn một warning về chuyện này khi một query include nhiều hơn một collection.

Cách sửa là tách query:

var order = await _db.Orders
    .Include(o => o.Items)
    .Include(o => o.Payments)
    .Include(o => o.Histories)
    .AsSplitQuery() // mỗi collection một câu SQL riêng
    .FirstAsync(o => o.Id == id, ct);

AsSplitQuery() có từ EF Core 5. Đổi lại là nhiều lượt gọi DB hơn, và các câu chạy ở những thời điểm khác nhau nên nếu data đổi giữa chừng, kết quả có thể không khớp hoàn toàn. Với màn hình chi tiết đơn thì mình chấp nhận được. Còn câu hỏi đáng hỏi trước: màn hình đó có cần cả ba collection cùng lúc không, hay lịch sử để một tab riêng, bấm vào mới load?

Hai lỗi nhỏ hay gặp khi đếm

// Kéo hết đơn về rồi đếm trong RAM
var count = (await _db.Orders.Where(o => o.CustomerId == id).ToListAsync(ct)).Count;

// Chỉ cần biết có hay không mà lại đếm hết
var hasOrders = await _db.Orders.CountAsync(o => o.CustomerId == id, ct) > 0;

Cái đầu thì gọi CountAsync() trực tiếp trên query. Cái thứ hai thì dùng AnyAsync(), EF dịch thành EXISTS, SQL Server dừng ngay khi tìm thấy dòng đầu tiên thay vì đếm hết.


Thử ngay thì đơn giản: bật log Microsoft.EntityFrameworkCore.Database.Command ở dev, mở trang chậm nhất của app, đếm số câu SQL hiện ra cho một lần tải trang. Nếu con số lớn hơn số ngón tay của bạn, gần như chắc có N+1 trong đó.

Bài sau trong series là phân trang con trỏ trong ASP.NET Core: vì sao Skip/Take chậm dần khi user cuộn sâu, và cách viết cursor pagination bằng EF Core. Còn trước đó là bài về DI lifetime, có phần về DbContext bị dùng song song nếu bạn chưa đọc.

Bạn có kiểu query EF nào từng làm prod chậm mà không nằm trong danh sách này không? Comment cho mình biết với.

P.S. Hồi lần ra vụ 201 query kia, mình mất khá lâu vì cứ nhìn slow query log, mà log thì sạch trơn. Giờ gặp trang chậm mà DB không có câu nào chậm, mình hay chạy skill debug trong PrimeKit, bộ skill mình tự làm. Trong phần chẩn đoán hiệu năng của skill có đúng một dòng cho kiểu triệu chứng này: rất nhiều lượt gọi DB nhỏ trong một request, hướng xử lý là eager loading và gom query. Cài bằng npx @lovehlmmm/primekit init, rồi gõ /pk:debug kèm log SQL của một request. Skill giúp bạn đi đúng hướng nhanh hơn, còn sửa query thế nào cho hợp với data của bạn thì vẫn phải đo lại bằng execution plan.


All Rights Reserved

Viblo
Let's register a Viblo Account to get more interesting posts.