Detailed explanation of how Laravel optimizes Model queries through preloading

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

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 shown below:

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

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

We don't tell the Post model at query time that we also need all the authors, so every time we get the author's name from a single Post model instance, A separate query will occur.

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 use arrays Load them:

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

Next we redefine the following relationship

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

Consider the following situation: Get the profile of the author of the 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 queries will be generated?

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 associated models based on conditions. 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, I see three queries in total, but only when $posts->load() is called will be displayed.

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.

Related recommendations:

Sharing examples of Laravel using Alipay payment

Detailed explanation of Laravel's method of implementing supervisor to execute asynchronous processes

Detailed explanation of Laravel's task scheduling console

The above is the detailed content of Detailed explanation of how Laravel optimizes Model queries through preloading. For more information, please follow other related articles on the PHP Chinese website!