Tweaking Eloquent relations – how to get N related models per parent ?

2014/08/17 / Jarek / 35 Comments

Previously I showed you how to get single related model per each parent, while eager loading the hasMany relation. That was pretty easy and we just made the most of the Eloquent.

However, most likely the time will come, when you need several related models per parent.

It won’t be as easy, but it’s far from impossible, so let’s do it!

Imagine classic example:

Post hasMany Comments

First, let me show you how to achieve this in MySQL

We need to group the results by foreign key. For this let’s use MySQL variables:


mysql> set @group = 0;
Query OK, 0 rows affected (0.00 sec)

mysql> select id, created_at, post_id, @group := post_id as grp from comments order by post_id limit 10;
+-----+---------------------+---------+-----+
| id  | created_at          | post_id | grp |
+-----+---------------------+---------+-----+
| 344 | 2014-08-17 21:25:46 |       1 |   1 |
| 320 | 2014-08-17 21:25:45 |       1 |   1 |
|   4 | 2014-08-17 21:25:26 |       1 |   1 |
|  72 | 2014-08-17 21:25:29 |       1 |   1 |
| 158 | 2014-08-17 21:25:37 |       2 |   2 |
| 423 | 2014-08-17 21:25:50 |       2 |   2 |
|  59 | 2014-08-17 21:25:29 |       2 |   2 |
| 227 | 2014-08-17 21:25:40 |       2 |   2 |
| 308 | 2014-08-17 21:25:45 |       3 |   3 |
|  34 | 2014-08-17 21:25:28 |       3 |   3 |
+-----+---------------------+---------+-----+
10 rows in set (0.00 sec)

mysql> set @group = 0;

Query OK, 0 rows affected (0.00 sec)

mysql> select id, created_at, post_id, @group := post_id as grp from comments order by post_id limit 10;

+-----+---------------------+---------+-----+

| id | created_at | post_id | grp |

+-----+---------------------+---------+-----+

| 344 | 2014-08-17 21:25:46 | 1 | 1 |

| 320 | 2014-08-17 21:25:45 | 1 | 1 |

| 4 | 2014-08-17 21:25:26 | 1 | 1 |

| 72 | 2014-08-17 21:25:29 | 1 | 1 |

| 158 | 2014-08-17 21:25:37 | 2 | 2 |

| 423 | 2014-08-17 21:25:50 | 2 | 2 |

| 59 | 2014-08-17 21:25:29 | 2 | 2 |

| 227 | 2014-08-17 21:25:40 | 2 | 2 |

| 308 | 2014-08-17 21:25:45 | 3 | 3 |

| 34 | 2014-08-17 21:25:28 | 3 | 3 |

+-----+---------------------+---------+-----+

10 rows in set (0.00 sec)

Note: you can’t use group as an alias, for it’s reserved word of course.

Next add simple rank column:


mysql> set @rank = 0;
Query OK, 0 rows affected (0.00 sec)

mysql> select id, created_at, post_id, @rank := @rank+1 as rank, @group := post_id as grp from comments order by post_id limit 10;
+-----+---------------------+---------+------+-----+
| id  | created_at          | post_id | rank | grp |
+-----+---------------------+---------+------+-----+
| 344 | 2014-08-17 21:25:46 |       1 |    1 |   1 |
| 320 | 2014-08-17 21:25:45 |       1 |    2 |   1 |
|   4 | 2014-08-17 21:25:26 |       1 |    3 |   1 |
|  72 | 2014-08-17 21:25:29 |       1 |    4 |   1 |
| 158 | 2014-08-17 21:25:37 |       2 |    5 |   2 |
| 423 | 2014-08-17 21:25:50 |       2 |    6 |   2 |
|  59 | 2014-08-17 21:25:29 |       2 |    7 |   2 |
| 227 | 2014-08-17 21:25:40 |       2 |    8 |   2 |
| 308 | 2014-08-17 21:25:45 |       3 |    9 |   3 |
|  34 | 2014-08-17 21:25:28 |       3 |   10 |   3 |
+-----+---------------------+---------+------+-----+
10 rows in set (0.00 sec)

mysql> set @rank = 0;

Query OK, 0 rows affected (0.00 sec)

mysql> select id, created_at, post_id, @rank := @rank+1 as rank, @group := post_id as grp from comments order by post_id limit 10;

+-----+---------------------+---------+------+-----+

+-----+---------------------+---------+------+-----+

| 344 | 2014-08-17 21:25:46 | 1 | 1 | 1 |

| 320 | 2014-08-17 21:25:45 | 1 | 2 | 1 |

| 4 | 2014-08-17 21:25:26 | 1 | 3 | 1 |

| 72 | 2014-08-17 21:25:29 | 1 | 4 | 1 |

| 158 | 2014-08-17 21:25:37 | 2 | 5 | 2 |

| 423 | 2014-08-17 21:25:50 | 2 | 6 | 2 |

| 59 | 2014-08-17 21:25:29 | 2 | 7 | 2 |

| 227 | 2014-08-17 21:25:40 | 2 | 8 | 2 |

| 308 | 2014-08-17 21:25:45 | 3 | 9 | 3 |

| 34 | 2014-08-17 21:25:28 | 3 | 10 | 3 |

+-----+---------------------+---------+------+-----+

10 rows in set (0.00 sec)

Then adjust @rank so it applies to each group:


mysql> set @rank = 0, @group = 0;
Query OK, 0 rows affected (0.00 sec)

mysql> select id, created_at, post_id, @rank := IF(@group=post_id, @rank+1, 1) as rank, @group := post_id as grp from comments order by post_id limit 10;
+-----+---------------------+---------+------+-----+
| id  | created_at          | post_id | rank | grp |
+-----+---------------------+---------+------+-----+
| 344 | 2014-08-17 21:25:46 |       1 |    1 |   1 |
| 320 | 2014-08-17 21:25:45 |       1 |    2 |   1 |
|   4 | 2014-08-17 21:25:26 |       1 |    3 |   1 |
|  72 | 2014-08-17 21:25:29 |       1 |    4 |   1 |
| 158 | 2014-08-17 21:25:37 |       2 |    1 |   2 |
| 423 | 2014-08-17 21:25:50 |       2 |    2 |   2 |
|  59 | 2014-08-17 21:25:29 |       2 |    3 |   2 |
| 227 | 2014-08-17 21:25:40 |       2 |    4 |   2 |
| 308 | 2014-08-17 21:25:45 |       3 |    1 |   3 |
|  34 | 2014-08-17 21:25:28 |       3 |    2 |   3 |
+-----+---------------------+---------+------+-----+
10 rows in set (0.00 sec)

mysql> set @rank = 0, @group = 0;

Query OK, 0 rows affected (0.00 sec)

mysql> select id, created_at, post_id, @rank := IF(@group=post_id, @rank+1, 1) as rank, @group := post_id as grp from comments order by post_id limit 10;

+-----+---------------------+---------+------+-----+

+-----+---------------------+---------+------+-----+

| 344 | 2014-08-17 21:25:46 | 1 | 1 | 1 |

| 320 | 2014-08-17 21:25:45 | 1 | 2 | 1 |

| 4 | 2014-08-17 21:25:26 | 1 | 3 | 1 |

| 72 | 2014-08-17 21:25:29 | 1 | 4 | 1 |

| 158 | 2014-08-17 21:25:37 | 2 | 1 | 2 |

| 423 | 2014-08-17 21:25:50 | 2 | 2 | 2 |

| 59 | 2014-08-17 21:25:29 | 2 | 3 | 2 |

| 227 | 2014-08-17 21:25:40 | 2 | 4 | 2 |

| 308 | 2014-08-17 21:25:45 | 3 | 1 | 3 |

| 34 | 2014-08-17 21:25:28 | 3 | 2 | 3 |

+-----+---------------------+---------+------+-----+

10 rows in set (0.00 sec)

This way we can work with rank and use it to limit the result to N per group, which is exactly what we need.

You have surely noticed that each query is preceeded by a SET statement. That’s basic method to set a variable in MySQL, however it’s rather tedious, and it will require another DB::statement call in our code. Instead I will use handy inline variables setting:

SELECT @group := 0, @rank := 0

So, let’s look at the final query that we will execute to fetch 2 latest comments per post:


mysql> select * from (
    ->   select id, created_at, post_id, @rank := IF(@group=post_id, @rank+1, 1) as rank, @group := post_id as grp
    ->     from comments, (select @rank := 0, @group := 0) as vars
    ->     order by post_id asc, created_at desc
    ->   ) as comments where rank <= 2 limit 10;
+-----+---------------------+---------+------+-----+
| id  | created_at          | post_id | rank | grp |
+-----+---------------------+---------+------+-----+
| 344 | 2014-08-17 21:25:46 |       1 |    1 |   1 |
| 320 | 2014-08-17 21:25:45 |       1 |    2 |   1 |
| 423 | 2014-08-17 21:25:50 |       2 |    1 |   2 |
| 227 | 2014-08-17 21:25:40 |       2 |    2 |   2 |
| 308 | 2014-08-17 21:25:45 |       3 |    1 |   3 |
|  83 | 2014-08-17 21:25:30 |       3 |    2 |   3 |
| 428 | 2014-08-17 21:25:51 |       4 |    1 |   4 |
| 351 | 2014-08-17 21:25:47 |       5 |    1 |   5 |
| 276 | 2014-08-17 21:25:43 |       5 |    2 |   5 |
| 444 | 2014-08-17 21:25:51 |       6 |    1 |   6 |
+-----+---------------------+---------+------+-----+
10 rows in set (0.01 sec)

mysql> select * from (

-> select id, created_at, post_id, @rank := IF(@group=post_id, @rank+1, 1) as rank, @group := post_id as grp

-> from comments, (select @rank := 0, @group := 0) as vars

-> order by post_id asc, created_at desc

-> ) as comments where rank <= 2 limit 10;

+-----+---------------------+---------+------+-----+

+-----+---------------------+---------+------+-----+

| 344 | 2014-08-17 21:25:46 | 1 | 1 | 1 |

| 320 | 2014-08-17 21:25:45 | 1 | 2 | 1 |

| 423 | 2014-08-17 21:25:50 | 2 | 1 | 2 |

| 227 | 2014-08-17 21:25:40 | 2 | 2 | 2 |

| 308 | 2014-08-17 21:25:45 | 3 | 1 | 3 |

| 83 | 2014-08-17 21:25:30 | 3 | 2 | 3 |

| 428 | 2014-08-17 21:25:51 | 4 | 1 | 4 |

| 351 | 2014-08-17 21:25:47 | 5 | 1 | 5 |

| 276 | 2014-08-17 21:25:43 | 5 | 2 | 5 |

| 444 | 2014-08-17 21:25:51 | 6 | 1 | 6 |

+-----+---------------------+---------+------+-----+

10 rows in set (0.01 sec)

Finally translate it to Eloquent, for example as a BaseModel scope:

Here’s all the code in single method, nothing extracted for presentation purpose


<?php

class BaseModel extends \Eloquent {

	/**
	 * query scope nPerGroup
	 * 
	 * @return void
	 */
	public function scopeNPerGroup($query, $group, $n = 10)
	{
		// queried table
		$table = ($this->getTable());

		// initialize MySQL variables inline
		$query->from( DB::raw("(SELECT @rank:=0, @group:=0) as vars, {$table}") );

		// if no columns already selected, let's select *
		if ( ! $query->getQuery()->columns) 
		{ 
			$query->select("{$table}.*"); 
		}

		// make sure column aliases are unique
		$groupAlias = 'group_'.md5(time());
		$rankAlias  = 'rank_'.md5(time());

		// apply mysql variables
		$query->addSelect(DB::raw(
			"@rank := IF(@group = {$group}, @rank+1, 1) as {$rankAlias}, @group := {$group} as {$groupAlias}"
		));

		// make sure first order clause is the group order
		$query->getQuery()->orders = (array) $query->getQuery()->orders;
		array_unshift($query->getQuery()->orders, ['column' => $group, 'direction' => 'asc']);

		// prepare subquery
		$subQuery = $query->toSql();

		// prepare new main base Query\Builder
		$newBase = $this->newQuery()
			->from(DB::raw("({$subQuery}) as {$table}"))
			->mergeBindings($query->getQuery())
			->where($rankAlias, '<=', $n)
			->getQuery();

		// replace underlying builder to get rid of previous clauses
		$query->setQuery($newBase);
	}

}

<?php

class BaseModel extends \Eloquent {

/**

* query scope nPerGroup

* @return void

public function scopeNPerGroup($query, $group, $n = 10)

{

// queried table

$table = ($this->getTable());

// initialize MySQL variables inline

$query->from( DB::raw("(SELECT @rank:=0, @group:=0) as vars, {$table}") );

// if no columns already selected, let's select *

if ( ! $query->getQuery()->columns)

{

$query->select("{$table}.*");

}

// make sure column aliases are unique

$groupAlias = 'group_'.md5(time());

$rankAlias = 'rank_'.md5(time());

// apply mysql variables

$query->addSelect(DB::raw(

"@rank := IF(@group = {$group}, @rank+1, 1) as {$rankAlias}, @group := {$group} as {$groupAlias}"

));

// make sure first order clause is the group order

$query->getQuery()->orders = (array) $query->getQuery()->orders;

array_unshift($query->getQuery()->orders, ['column' => $group, 'direction' => 'asc']);

// prepare subquery

$subQuery = $query->toSql();

// prepare new main base Query\Builder

$newBase = $this->newQuery()

->from(DB::raw("({$subQuery}) as {$table}"))

->mergeBindings($query->getQuery())

->where($rankAlias, '<=', $n)

->getQuery();

// replace underlying builder to get rid of previous clauses

$query->setQuery($newBase);

}

And extending it Post model:


<?php

class Post extends BaseModel {

	/**
	 * Get latest 5 comments from hasMany relation.
	 *
	 * @return Illuminate\Database\Eloquent\Relations\HasMany
	 */
	public function latestComments()
	{
		return $this->comments()->latest()->nPerGroup('post_id', 5);
	}

	/**
	 * Post has many Comments
	 *
	 * @return Illuminate\Database\Eloquent\Relations\HasMany
	 */
	public function comments()
	{
		return $this->hasMany('Comment');
	}

}

<?php

class Post extends BaseModel {

/**

* Get latest 5 comments from hasMany relation.

* @return Illuminate\Database\Eloquent\Relations\HasMany

public function latestComments()

{

return $this->comments()->latest()->nPerGroup('post_id', 5);

}

/**

* Post has many Comments

* @return Illuminate\Database\Eloquent\Relations\HasMany

public function comments()

{

return $this->hasMany('Comment');

}

Now we can fetch 5 comments per post with eager loading as easily as this:


[1] > $posts = Post::with('latestComments')->get();
// object(Illuminate\Database\Eloquent\Collection)(
// 
// )
[2] > DB::getQueryLog();
// array(
//   0 => array(
//     'query' => 'select * from `posts`',
//     'bindings' => array(
// 
//     ),
//     'time' => 1.46
//   ),
//   1 => array(
//     'query' => 'select * from (select `comments`.*, @rank := IF(@group = post_id, @rank+1, 1) as rank_643b92db067a46e286c8e914151584a1, @group := post_id as group_643b92db067a46e286c8e914151584a1 from (SELECT @rank:=0, @group:=0) as vars, comments order by `post_id` asc, `created_at` desc) as comments where `rank_643b92db067a46e286c8e914151584a1` <= ? and `comments`.`post_id` in (?, ?,  ...   ?, ?)',
//     'bindings' => array(
//       0 => 5,
//       1 => '1',
//       2 => '2',
         ...
//       150 => '150'
//     ),
//     'time' => 12.6
//   )
// )

// Let's check if actually there are no more comments for any post:

[3] > $posts->reduce(function($result, $post) { return max($result, $post->latestComments->count()); });
// 5

[1] > $posts = Post::with('latestComments')->get();

// object(Illuminate\Database\Eloquent\Collection)(

// )

[2] > DB::getQueryLog();

// array(

// 0 => array(

// 'query' => 'select * from `posts`',

// 'bindings' => array(

// ),

// 'time' => 1.46

// ),

// 1 => array(

// 'query' => 'select * from (select `comments`.*, @rank := IF(@group = post_id, @rank+1, 1) as rank_643b92db067a46e286c8e914151584a1, @group := post_id as group_643b92db067a46e286c8e914151584a1 from (SELECT @rank:=0, @group:=0) as vars, comments order by `post_id` asc, `created_at` desc) as comments where `rank_643b92db067a46e286c8e914151584a1` <= ? and `comments`.`post_id` in (?, ?, ... ?, ?)',

// 'bindings' => array(

// 0 => 5,

// 1 => '1',

// 2 => '2',

...

// 150 => '150'

// ),

// 'time' => 12.6

// )

// Let's check if actually there are no more comments for any post:

[3] > $posts->reduce(function($result, $post) { return max($result, $post->latestComments->count()); });

// 5

DONE!

Now you have a handy method for getting N per parent for hasMany relation like above.

Share your thoughts about it in the comments.

It's only fair to share...

Laravel – querying any level far relations w... Eloquent provides one Relation type for far related tables - hasManyThrough. However it works only with with cascade of hasOne/hasMany relations a...

Tweaking Eloquent relations – how to get lat... Have you ever needed to show only single related model from the hasMany relationship on a set of parents? Being it latest, highest or just rand...

Querying relations with Eloquent in Laravel 4 Laravel ORM Eloquent is brilliant! That being said, let's try to tackle very common questions that appear when you try to get related models lo...

Querying relations in Laravel: get Models where la... Another part of Querying relations in Laravel will cover such problem: I want to get SomeModels that have latest RelatedModel (hasMany) matchin...

Categories: Uncategorized

Tags: eager loading, Eloquent, laravel, ORM, relations

http://buzzknow.com Buzzknow

Great Jarek 😀

Thanks for tuts
Dobromir

Saved me allot of time
- Jarek
  
  Happy to read that!
diana

Thankkk youuuuuuu
http://www.indrashishghosh.com Indrashish Ghosh

This is exactly what I have been looking for! Thanks a lot!

Unfortunately i’m not being able to get this to work in Laravel 5.1 – It keeps throwing a IlluminateDatabaseQueryBuilder::nPerGroup() exception. Any idea what i might be doing wrong?
- Jarek
  
  Show the code you are calling, that’s causing the exception. I suppose it is *method no found*, right?
  - http://www.indrashishghosh.com Indrashish Ghosh
    
    Yes its a call to undefined method. It throws a BadMethodCallException in `IlluminateDatabaseQueryBuilder` on line 1992
    
    Here is the code I’m using – http://laravel.io/bin/QNo9m
    
    Thanks for replying and your time. Much appreciated.
    - Mitch Facer
      
      Did you ever get this resolved? I am having the same issue.
    - Jarek
      
      Like above: Works fine on 5.1.7 and .19 (and pre 5.1 as well), so double check what you got there.
    - Mitch Facer
      
      Figured out where I went wrong with this same error message. You also need to extend your pin class to BaseModel. Also, on your line 99, you are still using ‘latestComments’ instead of ‘recentPins’.
Abdulaziz Tayyar

@jarektkaczyk:disqus … It is Not working in Laravel 5.1

The same as @IndrashishGhosh:disqus

Any suggestions ?

BadMethodCallException
Call to undefined method IlluminateDatabaseQueryBuilder::nPerGroup()
- Jarek
  
  Hey mate, I just tried that on a fresh L5.1.19 install and it’s good. So either there was something in between the versions 5.1.7 and .19 (tested on both) that made it not work, or you missed something from the article.
  - Abdulaziz Tayyar
    
    It’s working.
    
    What a fantastic tweak.
    
    My problem was that I haven’t extended my “Comments” model to “BaseModel”, I extended only the “Post” model.
    
    Now , I converted it to a Trait and it’s working like a charm .
    - David Noreña
      
      can you share your Trait Implementation ?
http://arie.malam.or.id Arie W. Subagja
Jarek Thanks for the article! saved me a lot!

But can I add additional condition? for example, I want to retrieved latest comments but with approved status:
```
$posts = Post::with(['latestComments' => function($q){
    $q->where('status', 'approved');
}])->get();
```
Thanks!
- https://jsph.pl jsphpl
  
  Here’s an extended Trait providing `nByGroupWithScopes`: https://gist.github.com/jsphpl/25f2a295938a8497c6cdcf1160ef7507
jsphpl

Has anybody got this working with ManyToMany relations?
- David Noreña
  
  Yep, It was hard but not imposible, this is an enhaced version in a Trait I hope it help you and someone else.
  
  https://gist.github.com/juavidn/80a8b5cc755330120b690a82469fbfe2
  - cnweibo
    
    thanks very much @david_nore_a:disqus
  - cnweibo
    
    Hi, As my case, User model hasMany Uservoice via:
    public function myvoices()
    {
    return $this->hasMany(‘AppModelsUservoiceUservoice’);
    }
    public function mylatestvoices()
    {
    return $this->myvoices()->latest()->nPerGroup(‘uservoices’,’user_id’, 5);
    },
    i have not worked out using your trait. For hasMany relation, always failure with:
    Column already exists: 1060 Duplicate column name ‘user_id’ (SQL: select * from (select `uservoices`.*, @num := if(@group = uservoices.user_id, @num+1, 1) as uservoices_rn, @group := uservoices.user_id as uservoices_grp, `uservoices`.`user_id` from (select @num:=0, @group:=0) as vars, uservoices order by `uservoices`.`user_id` asc, `created_at` desc) as uservoices where `uservoices`.`user_id` = 59 and `uservoices`.`user_id` is not null and uservoices.user_id = uservoices.user_id and `uservoices_rn` <= 5 order by `created_at` desc)
- Raphael Almeida Araújo
  
  I created a `view` in database to simulate `hasMany` relationship. Likes:
  
  “`php
  CREATE VIEW banana_supplier_supplies_vw AS
  SELECT banana_supplies.*,
  banana_events_supplies.supplier_id,
  COUNT(DISTINCT banana_events_supplies.event_id) AS events_count
  FROM banana_supplies
  JOIN banana_events_supplies ON banana_events_supplies.supply_id = banana_supplies.id
  GROUP BY banana_supplies.id, banana_events_supplies.supplier_id;
  “`
daverdalas

To make this work on Laravel 5.2 replace all DB class calls with DB
richatchhay

Do you ever use this with Posgrest?
I use this with postgrest, but I got error like this: ERROR: syntax error at or near “:=”↵LINE 1: …
- Jarek
  
  I believe the only way in pg is a function.
  - richatchhay
    
    So, no way with Eloquent?
    - https://jsph.pl jsphpl
      
      Check this one: https://gist.github.com/tureki/7ea51872a9d9f734cc56
malhal

https://softonsofa.com/querying-relations-in-laravel-get-models-where-latest-related-is/
casc-or

This is soooo close to what I’m trying to achieve (thanks @jarektkaczyk:disqus) but I’m stumped on one more step.

I have Club, Membership and Member models. A Member has a lastname and a firstname and can have many Memberships. Each Membership has an expiry_date. Relations are

Club hasMany / Membership belongsTo
Member hasMany / Membership belongsTo

So I used the trait (thanks @david_nore_a:disqus) and then this method on the Member model returns the expected most recent Memberships in each Club the Member is a member of

return $this->hasMany(‘AppMembership’)->orderBy(‘date_expiry’, ‘desc’)->nPerGroup(‘club_id’, 1);

Now I need a collection / array of the most recent Membership for each unique Member of a given Club. This works in that it returns the most recent Membership in the Club for each unique Member

$memberships = Membership::where(‘club_id’, $id)->nPerGroup(‘member_id’, 1)->get();

except I can’t figure out how to sort the Memberships returned by their related Member->lastname, Member->firstname

Any hints or suggestions would be much appreciated! I should add that this query returns the correct sorted results http://laravel.io/bin/xK46P
Jibbe Verhave

Two comments:

Firstly, if you add scopeNPerGroup to the eloquent model, it will not be included in git since the vendor directory is included in .gitignore. Which means that you will lose the functionality when you migrate to a server using git. Laravel uses composer.lock to include all required files within vendor, which is why you have to run /composer install/ when you migrated your laravel code. However, when your laravel project is on a new server, and you run /composer install/ your original scopeNPerGroup function is lost. Therefore, include it somewhere else, e.g. AppCustom as a trait, make your model use the trait.

Secondly, this was extremely useful and a very thorough tutorial, I liked it. I customized the scopeNPerGroup function so it would order by ‘votes’ too. Than you very much.
Saad

I’m getting the Undefined relationship on model when calling with scope Here is the linked question on SO
https://stackoverflow.com/questions/49644933/call-to-undefined-relationship-on-model-laravel-using-scope
Jasterrr

I appreciate this but this scales pretty badly. On my local machine this query takes ~11 seconds for 2.3 million rows. I’m not sure how to index it properly because of @rank. I think that going N+1 for smaller N is better approach, especially if it’s a simple relation and if it’s properly indexed.
- Jarek
  
  That’s true.
  Whole eloquent scales pretty badly for anything that is more complex.
  Personally, using SQL, we use extensively raw queries/query builder, DB views, denormalized structure – whatever works best for a case we’re facing.
  
  Eloquent is beautiful for initial setup or small projects, later on its perks provide less and less value until, at some point, some of them become burden actually.
胡昊

I used your suggestion, but the query performance is very low, the comment table will scan the total number of entries, I added the index or the same. It is recommended to use get()->map(item->comments()->take(..)…)
胡昊

I used your suggestion, but the query performance is very low, the comment table will scan the total number of entries, I added the index or the same. It is recommended to use get()->map(… )
Jonas Staudenmeir

I created a package that allows eager loading with limit on all databases: https://github.com/staudenmeir/eloquent-eager-limit

SOFTonSOFA

Tweaking Eloquent relations – how to get N related models per parent ?

Related Post

Recent Posts

Author

Tags