Explication détaillée de la façon dont Laravel optimise les requêtes de modèle grâce au préchargement

Cet article vous présente principalement des informations pertinentes sur la façon d'utiliser le préchargement pour optimiser les requêtes du modèle Laravel. L'article le présente en détail à travers un exemple de code. Il a une certaine valeur d'apprentissage de référence pour les études ou le travail de chacun. suivez ci-dessous. Apprenons ensemble. J'espère que cela aide tout le monde.

Avant-propos

Cet article présente principalement le contenu pertinent sur l'utilisation du préchargement pour optimiser la requête du modèle Laravel, et le partage pour votre référence et votre étude. Sans plus tarder, jetons un coup d'œil à l'introduction détaillée :

Introduction

Le mappage objet-relationnel (ORM) crée des bases de données le travail devient très simple. Lorsque les relations entre les bases de données sont définies de manière orientée objet, les données du modèle associées peuvent être facilement interrogées et les développeurs peuvent ne pas remarquer les appels à la base de données sous-jacente.

Ce qui suit utilisera quelques exemples pour vous aider à mieux comprendre comment optimiser les requêtes.

Supposons que vous receviez 100 objets de la base de données et que chaque enregistrement ait 1 modèle associé (c'est-à-dire appartient à). L'utilisation de l'ORM par défaut générera 101 requêtes ; instance à chaque fois, une requête distincte se produit.

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

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

array_maps 100 requêtes ont eu lieu, plus la requête précédente, un total de 101 requêtes ont été générées.

Préchargement

Ensuite, si nous prévoyons d'utiliser les données du modèle associées, nous pouvons utiliser le préchargement pour Le nombre total de 101 requêtes est réduit à 2 requêtes. Dites simplement au modèle ce que vous devez charger. Comme suit :

Si vous activez la journalisation SQL, vous verrez que le préchargement ci-dessus ne générera que deux requêtes :

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

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

Si vous avez plusieurs modèles associés, alors vous pouvez utilisez un tableau pour les charger :

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

Ensuite, nous redéfinissons la relation suivante

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

Considérons la situation suivante : Obtenez le profil de l'auteur de l'article publié.

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

Supposons que ce qui précède

comporte 100 enregistrements, combien de requêtes seront générées ?

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

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

AppPost::with('author')->get()En optimisant le chargement rapide, nous pouvons éviter les requêtes supplémentaires dans les relations imbriquées.

Vous pouvez ouvrir votre journal SQL pour voir les trois requêtes correspondantes.

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

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

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

Chargement paresseux

Parfois, vous devrez peut-être simplement collecter des modèles associés en fonction des conditions. Dans ce cas, vous pouvez appeler paresseusement d'autres requêtes pour des données associées :

En regardant vos journaux SQL, vous voyez trois requêtes au total, mais seul $posts->load() sera affiché.

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

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

Conclusion

J'espère que vous en savez plus sur le chargement de modèles et comprenez comment cela fonctionne à un niveau plus profond. La documentation relative à Laravel est déjà très complète. J'espère que les exercices pratiques supplémentaires pourront vous aider à devenir plus confiant dans l'optimisation des requêtes relationnelles.

Résumé

Le texte original est traduit de eloquent-eager-loading, simplifiant la partie précédente de la construction des données.

Recommandations associées :

Partage Laravel d'exemples d'utilisation du paiement Alipay

Explication détaillée de la méthode de Laravel pour implémenter un superviseur pour exécuter des processus asynchrones

Explication détaillée de la console de planification des tâches de Laravel

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!