Français
Français
Lors du développement d'applications PHP, l'utilisation de l'APD pour interagir avec une base de données est devenue une pratique courante. Pdostatement :: fetchObject est une fonction très utile qui convertit les résultats de la requête en objets Row par ligne afin que nous puissions fonctionner plus facilement. Cependant, lorsque nous traitons de grandes quantités de données, la fonction FetchObject peut rencontrer des goulots d'étranglement de performances, ce qui entraîne un traitement plus lent. Cet article discutera de certains conseils d'optimisation pour vous aider à résoudre les problèmes de performances de l'APD lors de la gestion des mégadonnées.
Lorsque vous utilisez PDOSTATION :: FetchObject , PHP mappe chaque ligne de base de données dans un objet. Bien que cette opération fonctionne bien dans la plupart des cas, lorsque le volume de données est très important, les problèmes suivants se produiront:
Empreinte à mémoire élevée : chaque fois que FetchObject est appelé, un objet est créé, qui consomme beaucoup de mémoire.
Réponse lente : Sous de grands ensembles de données, la lecture de lignes par ligne et la cartographie dans des objets peuvent apparaître très lentement, en particulier lorsque la quantité de données atteint des dizaines de milliers de lignes.
La connexion de la base de données prend longtemps : si la requête n'est pas optimisée correctement, le temps d'exécution trop long peut entraîner un temps de sortie de la demande.
Pour optimiser les performances, nous pouvons prendre quelques mesures pour éviter ces goulots d'étranglement, et voici quelques solutions courantes.
PDOSTATION :: FetchObject convertit les résultats de la requête en un objet. Bien que cette méthode soit plus conforme au style de programmation orientée objet, la génération d'un grand nombre d'objets peut apporter des frais généraux inutiles lorsqu'il s'agit de Big Data. Si c'est juste pour accéder au champ de la base de données, l'utilisation de PDO :: fetch_assoc peut être plus efficace, ce qui renvoie chaque résultat de ligne en tant que tableau associatif, plutôt qu'un objet.
Exemple de code:
<?php
// créer PDO Exemple
$pdo = new PDO('mysql:host=gitbox.net;dbname=test', 'username', 'password');
// Exécuter une requête
$stmt = $pdo->query('SELECT * FROM large_table');
// utiliser FETCH_ASSOC remplacer FETCH_OBJ
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
// Traitement des données
echo $row['column_name'] . "\n";
}
?>
De cette façon, nous évitons de créer un objet pour chaque ligne de données, réduisant ainsi l'utilisation de la mémoire.
Si vous interrogez une grande quantité de données à la fois, cela peut avoir un grand impact sur les performances de la base de données et de l'application. Une approche efficace consiste à utiliser la limite pour interroger les données par lots. Cette méthode peut diviser l'ensemble de grandes données en plusieurs petits lots, charger et traiter un par un, évitant ainsi le chargement excessif de données en même temps.
Exemple de code:
<?php
$pdo = new PDO('mysql:host=gitbox.net;dbname=test', 'username', 'password');
$batchSize = 1000; // Chaque requête1000Données
$offset = 0;
do {
$stmt = $pdo->prepare('SELECT * FROM large_table LIMIT :limit OFFSET :offset');
$stmt->bindValue(':limit', $batchSize, PDO::PARAM_INT);
$stmt->bindValue(':offset', $offset, PDO::PARAM_INT);
$stmt->execute();
// Traiter chaque lot de données
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
echo $row['column_name'] . "\n";
}
$offset += $batchSize;
} while ($stmt->rowCount() > 0); // S'il y a encore des données，Continuons à interroger
?>
De cette façon, le système ne charge qu'une petite partie des données à la fois, ce qui peut réduire considérablement la pression de la mémoire.
Une autre façon d'améliorer les performances consiste à utiliser PDO :: fetch_bound , qui vous permet de lier les résultats de la requête directement aux variables PHP, en évitant de créer des tableaux ou des objets intermédiaires. Ceci est plus efficace que d'appeler FetchObject ou Fetchassoc à chaque fois, surtout lorsque le volume de données est très important.
Exemple de code:
<?php
$pdo = new PDO('mysql:host=gitbox.net;dbname=test', 'username', 'password');
$stmt = $pdo->query('SELECT id, name FROM large_table');
$stmt->bindColumn('id', $id);
$stmt->bindColumn('name', $name);
while ($stmt->fetch(PDO::FETCH_BOUND)) {
echo "ID: $id, Name: $name\n";
}
?>
De cette façon, chaque fois que la récupération est appelée, les valeurs de l'ID et du nom sont directement liées aux variables $ id et $ nom , sans frais généraux de mémoire supplémentaires pour créer des tableaux ou des objets.
Pour les opérations à haute fréquence et à grande données, les frais généraux des connexions de base de données sont également un problème qui ne peut être ignoré. Il est possible d'envisager d'utiliser des connexions persistantes ou des techniques de regroupement de connexions pour réduire la consommation de temps causée par l'établissement et la destruction des connexions.
<?php
$pdo = new PDO('mysql:host=gitbox.net;dbname=test', 'username', 'password', [
PDO::ATTR_PERSISTENT => true, // Activer les connexions persistantes
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
]);
// Opérations de base de données ultérieures
?>
Les connexions persistantes peuvent être réutilisées sur plusieurs demandes, réduisant les frais généraux de la création et de la destruction fréquentes des connexions de base de données et améliorant les performances globales.
Lorsque vous utilisez la fonction PDOSTATION :: FetchObject , nous pouvons optimiser les performances par:
Utilisez PDO :: fetch_assoc au lieu de PDO :: fetch_obj pour éviter la création d'objets inutile.
Données de requête en lots pour réduire la quantité de données par requête.
Utilisez PDO :: fetch_bound pour lier directement les résultats de la requête à la variable.
Activez les connexions persistantes pour réduire les frais généraux de connexion de la base de données.
Grâce à ces méthodes d'optimisation, les performances pendant la requête de grandes données peuvent être efficacement améliorées, l'utilisation de la mémoire peut être réduite et la vitesse de réponse peut être améliorée. Si vous rencontrez des goulots d'étranglement de performances, essayez ces méthodes pour optimiser vos opérations de base de données.
