Which F# query constructs ensure server-side pagination in EF Core?

Question

Bounding Large Datasets with Query Expressions
When working with large datasets in F# using Entity Framework Core (version 6.0+), the standard approach to pagination involves utilizing Skip and Take clauses within query expressions to bound the result set.
While these constructs typically map to SQL OFFSET and FETCH clauses, there is uncertainty regarding how different LINQ providers handle these calls when the underlying data source has specific constraints or when using older provider versions. If a provider fails to translate these methods, the query may default to client-side evaluation, loading the entire dataset into memory before slicing.
What is the most reliable way to verify that Skip and Take are being translated to server-side SQL rather than executing in-memory? Does F# provide a mechanism to force server-side evaluation for pagination to prevent potential out-of-memory errors?

Tasadduq Burney · Answer

Answer
The F# query constructs that guarantee server‑side pagination in EF Core are the skip and take keywords inside a query expression, or the equivalent .Skip(n) and .Take(m) extension methods on an IQueryable. As long as these calls appear before any operation that forces client‑side evaluation (e.g., AsEnumerable, ToList, or a non‑translatable F# function), EF Core translates them to SQL OFFSET … FETCH clauses.
Confirmed facts

EF Core 6+ maps Skip/Take to OFFSET/FETCH for providers that support it (SQL Server, PostgreSQL, SQLite, etc.).
In F# query expressions, skip and take are compiled to the same LINQ extension methods.
Server‑side translation can be verified by inspecting the generated SQL (logging or ToQueryString()) for the presence of OFFSET and FETCH.

Verification steps

Enable EF Core logging (e.g., LoggerFactory.Create(logger => logger.AddConsole())) and execute the query; the console output will show the SQL containing OFFSET and FETCH if translation succeeded.
Alternatively, call query.ToQueryString() (EF Core 6+) and check the returned string for OFFSET and FETCH.
Run the query against a known large table and monitor memory usage; constant memory regardless of page size indicates server‑side pagination.

When the recommendation may change
If you place a non‑translatable expression inside the skip or take arguments (for example, a custom F# function that EF Core cannot map to SQL), the query will be evaluated client‑side before pagination, loading the whole table into memory. In that case, replace the custom function with a simple constant or a computable expression that EF Core can translate.
Please confirm whether any custom F# functions are used in the skip/take arguments; if not, the above constructs are reliable for server‑side pagination.

Which F# query constructs ensure server-side pagination in EF Core?

Bounding Large Datasets with Query Expressions

1 answer

Answer

Confirmed facts

Verification steps

When the recommendation may change

Your perspective belongs here.

0 question comments