With Eloquent, how do nested, constrained and column-limited with() calls work, and when do you need withWhereHas() instead?

## Three ways to shape an eager load Plain `with('author')` loads a whole relation for every parent. Real pages need more control: a second level, a filter on the children, or fewer columns. Eloquent covers each with a variation of the same `with()` call on the query builder. The scenario below is an authors page on a blog: each author with their published posts and the comments on them. ## Nested eager loading **Dot syntax** walks a chain of relations. `Author::with('posts.comments')->get()` runs: 1. the authors query; 2. one `posts` query for all loaded authors; 3. one `comments` query for all loaded posts. Every level adds exactly one query. Eloquent registers each prefix of the path on its own, so `posts` is loaded even though you only wrote `posts.comments`. The **nested array** form expresses several branches under one parent: ```php Author::with([ 'posts' => ['comments', 'tags'], ])->get(); ``` ## Constrained eager loading A closure keyed by the relation name adds conditions to the **related** query: ```php $authors = Author::with(['posts' => fn ($query) => $query ->where('published', true) ->latest() ->limit(3), ])->get(); ``` Key facts about the closure: - It **filters children, not parents.** Every author is still returned; authors with no published posts get an empty collection. - For a nested path such as `'posts.comments' => fn ($q) => ...`, the closure applies to the **last** segment (comments). The `posts` level is loaded unconstrained. - In Laravel 13, a `limit()` inside an eager-load closure on a `hasMany` is applied **per parent** through a group limit, so each author gets up to three posts rather than three posts in total. - Ordering and extra `where` clauses behave like any query-builder chain. ## Column-limited eager loading `with('posts:id,author_id,title')` selects only the listed columns of the related table. The rule that trips people up: **keep every key Eloquent matches on**, meaning the related model's primary key and the foreign key that points back. For a `belongsTo` such as `with('author:id,name')`, the author's `id` must be in the list; drop it and no author can be matched to its post, so every post's `author` comes back `null`. Under `Model::shouldBeStrict()`, reading an attribute you did not select throws `MissingAttributeException` instead of quietly returning `null`. ## When the parents must be filtered too: `withWhereHas` Suppose the page should list **only** authors who have a featured post, and show only those featured posts. Two separate calls work, but the condition is written twice: ```php Author::whereHas('posts', fn ($q) => $q->where('featured', true)) ->with(['posts' => fn ($q) => $q->where('featured', true)]) ->get(); ``` If someone later edits one closure and not the other, the page lists authors whose loaded posts do not match the filter, or hides authors it should show. `withWhereHas()` removes the duplication: ```php Author::withWhereHas('posts', fn ($q) => $q->where('featured', true))->get(); ``` Internally it calls `whereHas()` with the relation name (anything after a `:` column list is ignored for the existence check) and `with()` with the same closure. It accepts the same `relation:columns` syntax as `with()`. ## Choosing between them | Need | Call | Parents returned | Children loaded | |---|---|---|---| | All authors, all posts | `with('posts')` | all | all | | All authors, only published posts | `with(['posts' => fn ...])` | all | matching only | | Only authors with a featured post, no posts loaded | `whereHas('posts', fn ...)` | matching only | none | | Only authors with a featured post, only those posts | `withWhereHas('posts', fn ...)` | matching only | matching only | ## Typical mistakes - Expecting a constrained `with()` to hide authors without matching posts. - Writing `with('author:name')` and wondering why every author is `null`. - Putting a `where` on the parent query that was meant for the children, or the reverse. - Duplicating the same closure in `whereHas` and `with` and letting them drift. - Adding `with('posts.comments')` after a constrained `posts` load: the dot path re-registers `posts` with an empty constraint and replaces the filtered one. Nest the second level inside the closure instead.