Français
Français
Lorsque vous utilisez des extensions MySQLI, MySQLI :: STMT_INIT est le moyen standard de créer un objet d'instruction, et la fonction de préparation est utilisée pour préparer des instructions de requête SQL. De nombreux développeurs peuvent rencontrer la situation où la fonction de préparation est appelée à plusieurs reprises dans des boucles ou des requêtes multiples lors de l'utilisation de l'extension mysqli . Cependant, les appels fréquents pour préparer la fonction affectent-ils les performances? Cet article analysera ce problème grâce à la mesure réelle et donnera des suggestions d'optimisation.
Tout d'abord, il est très important de comprendre le rôle de MySqli :: STMT_INIT et de préparer les fonctions. MySQLI :: STMT_INIT consiste à initialiser un nouvel objet d'instruction, et la fonction de préparation est utilisée pour passer des instructions SQL au serveur de base de données MySQL et les préparer, effectuant généralement des vérifications de syntaxe et des optimisations de requête avant l'exécution.
$conn = new mysqli("localhost", "username", "password", "database");
$stmt = $conn->stmt_init();
if ($stmt->prepare("SELECT id, name FROM users WHERE email = ?")) {
$stmt->bind_param("s", $email);
$stmt->execute();
$stmt->close();
}
Le code ci-dessus montre comment utiliser MySQLI :: STMT_INIT et se préparer à effectuer des opérations de requête.
Chaque appel à préparer enverra l'instruction SQL Query à la base de données pour l'analyse et l'optimisation. MySQL vérifiera la syntaxe de l'instruction de requête, générera le plan d'exécution et stockera les résultats dans le cache. Si l'instruction de requête est la même, le système de base de données utilisera le cache de requête. Cependant, les appels fréquents pour préparer même la même déclaration de requête peuvent entraîner des frais généraux supplémentaires, en particulier dans des environnements de concurrence élevés.
// Démonstration d'erreur：Appelé à chaque fois prepare fonction
foreach ($emails as $email) {
$stmt = $conn->stmt_init();
if ($stmt->prepare("SELECT id, name FROM users WHERE email = ?")) {
$stmt->bind_param("s", $email);
$stmt->execute();
$stmt->close();
}
}
Dans cet exemple, la fonction de préparation est appelée chaque boucle, ce qui provoque l'analyse et le plan exécuté généré par la base de données générée à chaque fois.
Les bases de données MySQL cachent généralement les requêtes exécutées, mais les appels fréquents à préparer entraîneront la fin de la base de données du plan d'exécution de la requête en cache, l'augmentation du processeur et des frais généraux de mémoire. Les appels répétés à long terme peuvent provoquer des temps de réponse plus lents, en particulier lors du traitement de grandes quantités de données.
Pour éviter d'appeler la préparation à chaque fois, les instructions SQL peuvent être précompilées et réutilisées. Même lorsque les requêtes sont exécutées plusieurs fois, des appels de préparation répétés doivent être évités.
// Démonstration d'optimisation：Appelé une seule fois prepare，Réutilisation ultérieure
$stmt = $conn->stmt_init();
if ($stmt->prepare("SELECT id, name FROM users WHERE email = ?")) {
foreach ($emails as $email) {
$stmt->bind_param("s", $email);
$stmt->execute();
}
$stmt->close();
}
Cette méthode réduit la surcharge de l'analyse répétée de la base de données des requêtes SQL en mettant l'appel de préparation en dehors de la boucle et en effectuant une seule opération de précompilation.
Si vos requêtes peuvent être effectuées à l'aide d'opérations par lots au lieu d'exécuter une par une, l'exécution de plusieurs requêtes SQL à la fois peut améliorer les performances. Dans MySQL, vous pouvez optimiser l'exécution de plusieurs opérations via des transactions et des inserts par lots.
// Démonstration d'exécution par lots：Utiliser des transactions pour effectuer plusieurs requêtes
$conn->begin_transaction();
foreach ($emails as $email) {
$stmt->bind_param("s", $email);
$stmt->execute();
}
$conn->commit();
$stmt->close();
Cette approche peut réduire la commutation des transactions et des connexions de la base de données, améliorant ainsi les performances.
Pour les applications de concurrence élevées, la mise en commun des connexions et les connexions persistantes peuvent améliorer considérablement les performances de la base de données. MySQLI fournit une fonctionnalité de connexion persistante, ce qui réduit les frais généraux d'établissement de connexions chaque fois qu'une demande est requise et réduit encore l'impact des performances des appels répétés à préparer .
Au cours du test réel, nous avons comparé les performances de la performance de deux scénarios sans optimisation et optimisation:
Sans optimisation, la base de données prend généralement plus de temps pour exécuter des requêtes pour chaque appel pour préparer la fonction, en particulier lorsque les requêtes SQL sont plus compliquées et que la perte de performances est plus évidente.
En réduisant le nombre d'appels pour préparer les fonctions et réutiliser les instructions, le temps d'exécution est considérablement raccourci, en particulier lors du traitement de grandes quantités de données, le code optimisé fonctionne mieux.
Aucune optimisation: chaque fois que la préparation est appelée, il faut beaucoup de temps pour exécuter la requête et a un CPU élevé et une empreinte mémoire.
Après l'optimisation: lors de la réutilisation des instructions précompilées et de l'utilisation de transactions à exécuter par lots, le temps de requête est considérablement raccourci et l'utilisation des ressources est efficacement contrôlée.
Grâce à l'analyse de cet article, nous pouvons conclure qu'un appel fréquent pour préparer la fonction affecte les performances de la base de données, en particulier dans le cas de la concurrence élevée et des requêtes complexes. Pour améliorer les performances, il est recommandé:
Précompiler et réutiliser les instructions SQL.
Utilisez des transactions pour exécuter plusieurs requêtes en lots.
Envisagez d'utiliser un pool de connexion ou une connexion persistante pour réduire les frais généraux de connexion.
Grâce aux méthodes d'optimisation ci-dessus, l'efficacité d'interaction entre l'application et la base de données peut être considérablement améliorée, optimisant ainsi les performances globales.
