Detailed explanation of preloading optimization Laravel Model query related issues

This article mainly introduces you to the relevant information on how to use preloading to optimize Laravel Model queries. The article introduces it in great detail through sample code. It has certain reference learning value for everyone's study or work. Friends who need it Let’s learn with the editor below.

Preface

This article mainly introduces the relevant content about using preloading to optimize Laravel Model query, and shares it for your reference and study. Not much to say, let’s take a look at the detailed introduction:

Introduction

Object-relational mapping (ORM) makes the database work becomes very simple. When database relationships are defined in an object-oriented manner, related model data can be easily queried and developers may not notice the underlying database calls.

The following will use some examples to further help you understand how to optimize queries.

Suppose you receive 100 objects from the database and each record has 1 associated model (i.e. belongsTo). Using the ORM by default will generate 101 queries; as follows:

//获取已发布的100条文章
$posts = Post::limit(100)->get(); //一次查询

$authors = array_map(function($post) {
 // 对作者模型生成查询
 return $post->author->name;
}, $posts);

We did not tell the Post model when querying that we also need all authors, so each time from a single A separate query occurs every time the Post model instance gets the author's name.

array_maps 100 queries occurred, plus the previous query, a total of 101 queries were generated.

Preloading

Next, if we plan to use associated model data, we can use preloading to The total number of 101 queries is reduced to 2 queries. Just tell the model what you need to load. As follows:

//获取已发布的100条文章 - 并预加载文章对应作者
$posts = Post::with('author')->limit(100)->get();//2次查询

$authors = array_map(function($post) {
 // 对作者模型生成查询
 return $post->author->name;//这里讲不在产生查询
}, $posts);

If you enable sql logs, you will see that the above preloading will only generate two queries:

select * from `posts`
select * from `authors` where `authors`.`id` in (?, ?, ?, ?, ?) [1,2,3,4,5]

If you have multiple related models, you can load them using an array:

$posts = App\Post::with(['author', 'comments'])->get();

Next we redefine the relationship as follows

Post -> belongsTo -> Author //每个文章只属于一个用户
Author -> hasMany -> Post //每个用户拥有多个文章
Author -> hasOne -> Profile //每个用户只有一个简介

Consider the following scenario: Get the profile of the author of a published article.

//获取所有文章 - 并预加载文章对应作者
$posts = App\Post::with('author')->get();//两次查询

//根据每个 `作者` 获取其简介
$posts->map(function ($post) {
 //虽然我们直接通过$author = $post->author不会产生查询，
 //但当调用$author->profile时，每次都会产生一个新查询
 return $post->author->profile;
});

Assume that the above App\Post::with('author')->get() has 100 records, how many records will be generated What about the query?

By optimizing preloading, we can avoid extra queries in nested relationships.

//获取所有文章 - 并预加载文章对应作者及每个作者对应de profile
$posts = App\Post::with('author.profile')->get();//三次查询

$posts->map(function ($post) {
 //不在产生新查询
 return $post->author->profile;
});

You can open your sql log to see the corresponding three queries.

select * from `posts`
select * from `authors` where `authors`.`id` in (?, ?, ?, ?, ?) [.....]
select * from `profiles` where `profiles`.`author_id` in (?, ?, ?, ?, ?) [.....]

Lazy loading

Sometimes you may just need to collect associations based on conditions model. In this case you can lazily call other queries for related data:

$posts = App\Post::all();//一次查询

$posts->load('author.profile');//两次查询
$posts->map(function ($post) {
 //不在产生新查询
 return $post->author->profile;
});

Looking at your sql logs, you see a total of three queries, but only one that calls $ It will only be displayed when posts->load().

Conclusion

Hopefully you know more about loading models and understand how it works on a deeper level . The documentation related to Laravel is already very comprehensive. I hope the additional practical exercises can help you become more confident in optimizing relational queries.

Summary

The original text is translated from eloquent-eager-loading, simplifying the previous part of constructing data.

The above is the detailed content of Detailed explanation of preloading optimization Laravel Model query related issues. For more information, please follow other related articles on the PHP Chinese website!