temps de requête de l'association Laravel

Laravel est un framework PHP très populaire avec des fonctionnalités riches et une API facile à utiliser. Parmi eux, Eloquent ORM est l'un de ses composants de base de données les plus puissants, qui peut être utilisé pour interroger et corréler facilement.

Cependant, lorsque nous effectuons des requêtes de corrélation complexes, nous constaterons que le nombre de requêtes devient important, notamment lors de l'utilisation de boucles. Cela affectera non seulement les performances des requêtes, mais peut également provoquer des exceptions de connexion à la base de données.

Alors, comment pouvons-nous réduire le nombre de requêtes associées dans Laravel ? Ci-dessous, cet article proposera quelques solutions.

1. Chargement paresseux

Lors de l'exécution de requêtes associées, nous pouvons utiliser la fonction de chargement paresseux de Laravel, qui interrogera uniquement lorsque le modèle associé doit être utilisé.

Le chargement paresseux utilise la méthode magique __get(), donc tant qu'il est appelé sur le modèle associé, la requête associée sera déclenchée.

Par exemple :

$users = User::all();

foreach ($users as $user) {

echo $user->profile->name;

}

Si nous utilisons $users->profile directement dans la boucle foreach, alors Dans chaque boucle, une requête associée sera exécutée, ce qui entraînera un grand nombre de requêtes, nous pouvons donc utiliser le chargement paresseux pour l'optimiser.

$users = User::with('profile')->get();

foreach ($users as $user) {

echo $user->profile->name;

}

Lors de l'utilisation de la méthode with() pour précharger le modèle associé , le chargement différé est automatiquement activé et les requêtes ne sont effectuées que si vous devez utiliser le modèle associé.

2. Eager Loading

Tant que nous appelons manuellement le chargement paresseux, si nous ne effectuons pas une vérification complète du code, des requêtes répétées se produiront toujours, donc une solution plus approfondie consiste à utiliser Eager Loading (préchargement), qui Tous les modèles associés requis peuvent être chargés en même temps.

Par exemple :

$users = User::with('profile', 'posts')->get();

foreach ($users as $user) {

echo $user->profile->name;

foreach ($user->posts as $post) {
    echo $post->title;
}

}

utiliser with( ) Lors du chargement de plusieurs modèles associés en même temps, plusieurs requêtes SQL seront exécutées. Si nous n'avons besoin d'utiliser qu'un seul des modèles associés, cette méthode n'est pas le meilleur choix.

3. select déclare les champs associés

Dans Eloquent, nous pouvons utiliser la méthode select pour effectuer un filtrage sur un modèle et spécifier les colonnes spécifiques dont nous avons besoin, et il en va de même pour les modèles associés.

Par exemple :

$users = User::with(['profile' => function ($query) {

$query->select('user_id', 'name');

}])->get();

foreach ($users en tant que $user ) {

echo $user->profile->name; // 只会查询'profile'表中的'user_id'和'name'列

}

Dans cet exemple, en spécifiant la méthode select() pour afficher les colonnes dont vous avez besoin, vous pouvez laisser Eloquent ORM interroger uniquement certaines colonnes de données spécifiques à la fois. C'est un bon moyen d'interroger rapidement des données spécifiques. données, et fournit également Nous réduisons le nombre de requêtes supplémentaires afin de pouvoir limiter les requêtes aux modèles associés en utilisant cette approche.

4. Utiliser join pour les requêtes associées

En plus de traiter les modèles associés, dans certains cas spécifiques, les requêtes join peuvent être plus efficaces que les requêtes associées d'Eloquent.

Par exemple :

$users = DB::table('users')

->join('profiles', 'users.id', '=', 'profiles.user_id')
->join('posts', 'users.id', '=', 'posts.user_id')
->select('users.name', 'profiles.age', 'posts.title')
->get();

foreach ($users as $user) {

echo $user->name;
echo $user->age;
echo $user->title;

}

Bien que la requête de jointure augmente la complexité et la maintenabilité des instructions SQL, mais par rapport à Eloquent ORM, la requête de jointure peut mieux optimiser les performances des requêtes.

Résumé

Les méthodes ci-dessus sont des techniques efficaces que nous pouvons utiliser pour réduire le nombre de requêtes associées dans Laravel. En général, nous pouvons utiliser le préchargement et le chargement différé pour optimiser les performances des requêtes et éviter les requêtes répétées. Pour certaines requêtes spécifiques et complexes, nous pouvons envisager d'utiliser des requêtes de jointure pour obtenir des résultats plus efficaces.

Enfin, quelle que soit l'approche que nous adoptons, l'optimisation des requêtes est toujours importante, elle peut grandement améliorer les performances de nos applications et réduire notre temps de réponse.

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!