Français
Français
Lors du traitement de la requête de la base de données, la requête en PHP, si nous ne sommes intéressés qu'à une colonne dans l'ensemble de résultats, l'utilisation de mysqli_result :: fetch_column () est une manière très efficace. Cette approche est plus d'économie de mémoire que Fetch_assoc () ou Fetch_row () traditionnel, fonctionne en particulier mieux lorsqu'il s'agit de grandes quantités de données. Cet article explorera comment optimiser davantage l'utilisation de la mémoire lors de l'utilisation de fetch_column () pour améliorer les performances globales des programmes PHP.
L'un des moyens les plus directs et les plus efficaces d'optimiser la mémoire est de sélectionner uniquement la colonne dont vous avez réellement besoin dans les requêtes SQL au lieu d'utiliser SELECT * . Par exemple:
$result = $mysqli->query("SELECT username FROM users");
Cela peut réduire la quantité de données transmises par le serveur de base de données en PHP et réduire la consommation de mémoire à partir de la source.
fetch_assoc () Renvoie un tableau associatif, fetch_row () renvoie un tableau d'index et fetch_column () renvoie directement une seule valeur:
while ($username = $result->fetch_column()) {
// traiter avec$username
}
Cette méthode évite l'encapsulation du tableau inutile et réduit l'allocation de la mémoire, en particulier pour les scénarios où seule une certaine colonne de données est requise.
Une pratique courante consiste à mettre en cache tous les résultats dans un tableau d'abord, puis à traiter: le processus:
$usernames = [];
while ($username = $result->fetch_column()) {
$usernames[] = $username;
}
Si le volume de données est important, cela peut conduire à une grande quantité d'utilisation de la mémoire. Si la logique de traitement le permet, essayez de la lire et de le traiter en lisant, plutôt que de charger toutes les données à la fois:
while ($username = $result->fetch_column()) {
process_username($username); // 假设是某个traiter avec函数
}
Par défaut, MySQLI_Query () cache tous les résultats de la mémoire du client. Si le volume de données est particulièrement important, vous pouvez utiliser la constante MySQLI_USE_RESULT pour activer les requêtes non tamponnées:
$result = $mysqli->query("SELECT username FROM users", MYSQLI_USE_RESULT);
Cette méthode ne chargera pas tous les résultats en mémoire, mais obtiendra une ligne de données du serveur à la fois, en économisant plus de mémoire. Cependant, il est nécessaire de noter que les ensembles de résultats non comprimés ne peuvent pas exécuter d'autres requêtes avant le traitement.
Si votre script PHP lui-même effectue des tâches de haute charge (telles que de grandes quantités d'extraction de données), assurez-vous que le Memory_limit dans votre php.ini est défini raisonnablement, pour empêcher le débordement de la mémoire et ne pas régler des ressources système trop élevées et des déchets. Il peut être défini dynamiquement par les méthodes suivantes:
ini_set('memory_limit', '128M');
Cependant, il est préférable d'optimiser la logique du programme plutôt que de simplement augmenter les bouchons de mémoire.
Pour les fonctions qui doivent renvoyer plusieurs valeurs de colonne, le générateur peut être combiné avec l'effet de la charge retardée:
function get_usernames(mysqli_result $result): Generator {
while ($username = $result->fetch_column()) {
yield $username;
}
}
// utiliser
foreach (get_usernames($result) as $username) {
process_username($username);
}
L'avantage du générateur est qu'il ne charge pas toutes les données dans la mémoire à la fois, ce qui convient particulièrement à la gestion de grands ensembles de résultats.
En utilisant MySQLI_RESULT :: fetch_column () lui-même est une pratique d'optimisation de la mémoire, mais combinée avec d'autres techniques telles que l'interrogation uniquement des champs nécessaires, l'extraction de données lors du traitement et l'utilisation de requêtes et de générateurs non comprimés, il peut réduire davantage la consommation de mémoire de programmes PHP et améliorer les performances. Ces méthodes d'optimisation sont particulièrement importantes pour le traitement des scénarios avec de grands volumes de données.
Des expériences plus pratiques sur le PHP à haute performance interagissant avec les bases de données peuvent être trouvées à: https://gitbox.net/php-db-optimisation
