Preface
This article mainly introduces the relevant content on optimizing Laravel Model query using preload. We will share it for your reference and learning. Without further ado, let’s take a look at the detailed introduction:
introduce
Object Relational Mapping (ORM) makes the work of a database very simple. When defining database relationships in an object-oriented way, relevant model data can be easily queried, and developers may not pay attention to underlying database calls.
Here are some examples to further help you understand how to optimize queries.
Suppose you receive 100 objects from the database and each record has 1 association model (i.e. belongsTo). By default, using ORM will generate 101 queries; as follows:
//Get 100 published articles$posts = Post::limit(100)->get(); //One query
$authors = array_map(function($post) {
// Generate query to the author model return $post->author->name;
}, $posts);
We didn't tell the Post model when querying, we also needed all the authors, so each time we got the author's name from a single Post model instance, a separate query occurs.
100 queries occur when array_maps, plus the previous queries, a total of 101 queries are generated.
Preload
Next, if we intend to use the associated model data, we can use preload to reduce the total number of that 101 queries to 2 queries. Just tell the model what you need to load. as follows:
//Get 100 published articles - and preload the corresponding author of the article$posts = Post::with('author')->limit(100)->get();//2 queries
$authors = array_map(function($post) {
// Generate query to the author model return $post->author->name;//This is said that no query is generated}, $posts);
If you enable sql logs, you will see that the above preload will only generate two queries:
select * from `posts` select * from `authors` where `authors`.`id` in (?, ?, ?, ?, ?) [1,2,3,4,5]
If you have multiple associative models, you can load them with an array:
$posts = App\Post::with(['author', 'comments'])->get();
Next we redefine the relationship as follows
Post -> belongsTo -> Author //Each article belongs to only one userAuthor -> hasMany -> Post //Each user has multiple articlesAuthor -> hasOne -> Profile //Each user has only one introduction
Consider the following situation: Obtain the profile of the author to which the published article belongs.
//Get all articles - and preload the corresponding author of the article$posts = App\Post::with('author')->get();//Two inquiries
//Get their profile based on each `author`$posts->map(function ($post) {
//Although we will not generate a query directly through $author = $post->author, //But when $author->profile is called, a new query will be generated every time return $post->author->profile;
});
Assume that the aboveApp\Post::with('author')->get()With 100 records, how many queries will be generated?
By optimizing preloading, we can avoid additional queries in nested relationships.
//Get all articles - and preload the corresponding author of the article and the corresponding de profile of each author$posts = App\Post::with('')->get();//Three queries
$posts->map(function ($post) {
//No new query is generated 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 the associated models based on the conditions. In this case, you can lazyly call other queries for the relevant data:
$posts = App\Post::all();//One query
$posts->load('');//Two inquiries$posts->map(function ($post) {
//No new query is generated return $post->author->profile;
});
Looking at your sql logs, you see three queries in total, but they will only be displayed when you call $posts->load().
in conclusion
Hope you learn more about loading models and how they work on a deeper level. Laravel-related documentation is already very comprehensive, and I hope that additional practical exercises can help you have more confidence in optimizing relationship queries.
Summarize
The above is the entire content of this article. I hope the content of this article will be of some help to your study or work. If you have any questions, you can leave a message to communicate. Thank you for your support.
Original translation fromeloquent-eager-loading, simplify its previous construction data part.