Explication détaillée des problèmes liés aux requêtes du modèle Laravel d'optimisation du 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 tous les amis qui en ont besoin. apprenez avec l’éditeur ci-dessous.

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 comme suit :

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

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

Nous n'avons pas indiqué au modèle Post au moment de la requête que nous avions également besoin de tous les auteurs, donc à chaque fois Chaque fois qu'une requête distincte est effectuée pour obtenir le nom de l'auteur à partir d'une seule instance du modèle Post.

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 :

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

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

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

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

Si vous avez plusieurs modèles associés, vous pouvez les charger à l'aide d'un tableau :

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

Ensuite, nous redéfinissons la relation comme suit

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

Considérez le scénario suivant : Obtenez le profil de l'auteur d'un article publié.

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

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

En supposant que le AppPost::with('author')->get() ci-dessus comporte 100 enregistrements, combien de requêtes seront générées ?

En optimisant le chargement rapide, nous pouvons éviter les requêtes supplémentaires dans les relations imbriquées.

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

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

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

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 en fonction de conditions modèles associés. Dans ce cas, vous pouvez appeler paresseusement d'autres requêtes pour des données associées :

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

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

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

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.

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!