Français
Français
Lorsque vous utilisez l'extension MySQLI de PHP pour les opérations de base de données, MySQLI_STMT :: STORE_RESULT () est un moyen courant de stocker les résultats de requête du serveur au client. Il fonctionne pour de nombreux scénarios, surtout lorsque nous devons traiter les résultats de la requête complets à la fois. Cependant, lorsque la quantité de données interrogées est importante, certaines choses méritent d'être notées si l'utilisation de cette méthode est appropriée. Cet article mènera une discussion approfondie sur la question de savoir si mysqli_stmt :: store_result () convient aux résultats de la requête à grande données, ainsi qu'aux problèmes clés qui doivent être prêts à l'attention pendant l'utilisation.
Dans MySQL, les données de requête sont généralement obtenues en utilisant des instructions sélectionnées . Dans MySQLI, si nous utilisons des instructions préparées pour exécuter une requête, nous utilisons généralement MySQLI_STMT :: STORE_RESULT () pour stocker les résultats de la requête au client. Cela signifie que les résultats seront transférés du serveur vers le client et enregistrés en mémoire, ce qui nous permet d'obtenir les résultats de la requête ligne par ligne en php en appelant bind_result () et d'autres méthodes.
<?php
// Créer une connexion de base de données
$mysqli = new mysqli("localhost", "username", "password", "database");
// Vérifiez la connexion
if ($mysqli->connect_error) {
die("Connection failed: " . $mysqli->connect_error);
}
// Requête de prétraitement
$stmt = $mysqli->prepare("SELECT id, name FROM users");
$stmt->execute();
// Stocker les résultats
$stmt->store_result();
// Résultats de liaison
$stmt->bind_result($id, $name);
// Obtenez les résultats de la requête
while ($stmt->fetch()) {
echo "ID: $id, Name: $name\n";
}
// Déclaration étroite
$stmt->close();
// Fermez la connexion de la base de données
$mysqli->close();
?>
Dans l'exemple ci-dessus, nous préparons d'abord une requête SQL et stockons les résultats de la requête en mémoire via la méthode store_result () . Après cela, nous pouvons utiliser la méthode bind_result () pour traiter les résultats ligne par ligne.
mysqli_stmt :: store_result () stocke les résultats de la requête en mémoire. Pour les ensembles de données de petite ou moyenne taille, cette méthode est très efficace et peut rapidement renvoyer les résultats de la requête. Cependant, lorsque les résultats de la requête contiennent une grande quantité de données, cette pratique apportera certains problèmes de performance, principalement manifestés dans les aspects suivants:
STORE_RESULT () Enregistrera tous les résultats de la requête en mémoire. Si la quantité de données interrogées est très importante, cela prendra beaucoup de mémoire, ce qui peut provoquer un écrasement des programmes PHP ou dépasser les limites de mémoire, en particulier dans les environnements avec des ressources de mémoire limitées.
Lorsque la quantité de données renvoyée par la requête est très importante, le processus de transfert de données du serveur MySQL vers le client peut être très lent. Même dans un environnement de réseau efficace, la transmission de volumes de données importants peut entraîner de longs temps d'attente, affectant la vitesse de réponse du programme et l'expérience utilisateur.
MySQL doit charger l'ensemble des résultats en mémoire lors de l'exécution de Store_Result () , qui occupera les ressources mémoire du serveur de base de données. Si le tableau de requête est très important, le serveur de base de données peut être soumis à une charge plus importante, entraînant une dégradation globale des performances et même affecter l'exécution d'autres requêtes.
Si la quantité de données dans le résultat de la requête que vous devez traiter est trop grande, l'utilisation de mysqli_stmt :: store_result () peut ne pas être le meilleur choix. Dans ce cas, les alternatives suivantes peuvent être prises en compte:
Comparé à Store_Result () , use_result () ne stocke pas tous les résultats de la requête en mémoire, mais transfère l'ensemble de résultats de la base de données vers la clientèle par ligne sous la forme d'un flux. Cela signifie que les données ne sont pas chargées en mémoire à la fois, pouvant ainsi gérer des ensembles de données plus grands.
<?php
// utiliser use_result Alternative store_result
$stmt->execute();
$result = $stmt->use_result();
while ($row = $result->fetch_assoc()) {
echo "ID: " . $row['id'] . ", Name: " . $row['name'] . "\n";
}
$stmt->close();
?>
Une autre méthode consiste à paginer les résultats de la requête ou à les lancer. En ajustant les requêtes SQL, limitez le nombre d'enregistrements obtenus à chaque fois et ne demandez qu'une partie des données. Cela réduit la pression de la mémoire et permet au programme de traiter de grandes quantités de données étape par étape.
Par exemple, vous pouvez utiliser les clauses de limite et de décalage de SQL pour paginer les requêtes:
<?php
$batch_size = 1000;
$offset = 0;
while (true) {
$stmt = $mysqli->prepare("SELECT id, name FROM users LIMIT ? OFFSET ?");
$stmt->bind_param("ii", $batch_size, $offset);
$stmt->execute();
$stmt->store_result();
if ($stmt->num_rows == 0) {
break; // S'il n'y a plus de données, la boucle sera sortie
}
$stmt->bind_result($id, $name);
while ($stmt->fetch()) {
echo "ID: $id, Name: $name\n";
}
$offset += $batch_size;
$stmt->close();
}
?>
Pour les grandes requêtes de données, il est également très important d'optimiser la conception de la base de données. Assurez-vous que les tables pertinentes ont été correctement indexées afin que la requête puisse être exécutée rapidement. De plus, les performances de requête peuvent être améliorées en interrogeant les caches, des tables de partitionnement, etc.
Lorsque nous écrivons du code et devons impliquer des adresses URL, nous pouvons spécifier la partie du nom de domaine de l'URL en tant que gitbox.net , par exemple:
echo "accéder GitBox.net Obtenez plus d'informations: <a href='http://gitbox.net/example'>Cliquez ici</a>";
Cela garantit la cohérence du code et la conformité avec des exigences spécifiques.
Dans l'ensemble, MySQLI_STMT :: STORE_RESULT () est très efficace lorsqu'il s'agit de petites et moyennes quantités de données, mais lorsqu'ils sont confrontés à de grandes quantités de données, elles peuvent être inapplicables en raison de la consommation de mémoire, des retards de transfert de données et de la charge excessive de la base de données. À l'heure actuelle, il est recommandé d'envisager d'utiliser MySQLI_STMT :: USE_RESULT () pour le traitement du streaming, ou de réduire la pression de la mémoire par la pagination et le traitement par lots. De plus, l'optimisation de la base de données est également la clé pour améliorer les performances. Pour interroger les volumes de données importants, la sélection rationnelle de méthodes et stratégies appropriées peut efficacement améliorer les performances et la stabilité de l'application.
