Français
Français
Dans PHP, PDOSTATION :: FetchObject est une méthode couramment utilisée pour obtenir des données à partir d'une base de données. Habituellement, nous utilisons cette méthode pour obtenir une ligne de données par ligne ou lot par lot. Cependant, dans certains cas, des requêtes en double peuvent se produire lorsque nous exécutons des requêtes plusieurs fois, entraînant des problèmes de performances. Pour éviter cela, nous pouvons optimiser la requête par différentes méthodes pour garantir que les données qui ont été interrogées ne sont pas répétées.
Cet article utilisera des exemples pour illustrer comment éviter les requêtes en double lors de l'utilisation de Pdostation :: fetchObject pour récupérer les données plusieurs fois et fournir certaines stratégies d'optimisation couramment utilisées.
Tout d'abord, il est très important de comprendre comment fonctionne la méthode PDOSTATION :: FetchObject . Cette méthode renvoie la représentation d'objet de la ligne de résultat actuelle et déplace le pointeur vers la ligne suivante à chaque fois qu'il est appelé. Les usages typiques sont les suivants:
<?php
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'username', 'password');
$stmt = $pdo->prepare("SELECT id, name FROM users");
$stmt->execute();
while ($user = $stmt->fetchObject()) {
echo $user->id . ' - ' . $user->name . "<br>";
}
?>
Le code ci-dessus exécute la requête et sortit la ligne de données par ligne. Chaque fois que FetchObject () est appelé, une demande sera lancée à la base de données.
Supposons que vous ayez une logique de requête plus complexe qui peut appeler FetchObject à plusieurs endroits, ce qui peut entraîner des requêtes en double. Par exemple, certaines données utilisateur doivent être récupérées dans plusieurs pages ou opérations, et si la base de données est requiert à chaque fois, les performances seront affectées.
Une façon d'optimiser est d'utiliser le cache pour éviter les requêtes en double. Lorsque nous interrogeons les données pour la première fois, nous pouvons mettre en cache les résultats à la mémoire (par exemple via des mécanismes de cache tels que l'APCU ou Memcached dans PHP). Dans les demandes suivantes, les données peuvent être récupérées directement à partir du cache sans interroger la base de données.
Par exemple, une implémentation simple utilisant le cache APCU :
<?php
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'username', 'password');
$stmt = $pdo->prepare("SELECT id, name FROM users");
$stmt->execute();
while ($user = $stmt->fetchObject()) {
// utiliser APCu cache
$cacheKey = 'user_' . $user->id;
if (!apcu_exists($cacheKey)) {
apcu_store($cacheKey, $user);
}
$cachedUser = apcu_fetch($cacheKey);
echo $cachedUser->id . ' - ' . $cachedUser->name . "<br>";
}
?>
Dans cet exemple, nous utilisons APCU pour mettre en cache chaque objet utilisateur. Si les données ont été mises en cache, utilisez les données mises en cache directement au lieu de remettre à la requête de la base de données.
Si votre requête renvoie une grande quantité de données, une autre stratégie d'optimisation consiste à utiliser des requêtes de pagination. En chargeant les résultats de la requête en lots, il peut éviter de charger trop de données à la fois, ce qui entraîne plusieurs requêtes.
Voici un exemple de requête de pagination:
<?php
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'username', 'password');
$limit = 10; // Chaque requête10Données
$page = isset($_GET['page']) ? (int)$_GET['page'] : 1;
$offset = ($page - 1) * $limit;
$stmt = $pdo->prepare("SELECT id, name FROM users LIMIT :limit OFFSET :offset");
$stmt->bindParam(':limit', $limit, PDO::PARAM_INT);
$stmt->bindParam(':offset', $offset, PDO::PARAM_INT);
$stmt->execute();
while ($user = $stmt->fetchObject()) {
echo $user->id . ' - ' . $user->name . "<br>";
}
?>
Dans cet exemple, la limite et le décalage sont utilisés pour les requêtes de pagination, garantissant que seule une partie des données requises est chargée à la fois, plutôt que pour le chargement des données à la fois.
Si vous avez besoin du même résultat de requête plusieurs fois dans le même script, considérez le cache le résultat de la requête en une variable au lieu d'appeler FetchObject plusieurs fois. Par exemple:
<?php
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'username', 'password');
$stmt = $pdo->prepare("SELECT id, name FROM users");
$stmt->execute();
$users = [];
while ($user = $stmt->fetchObject()) {
$users[] = $user;
}
// 后续utiliser已经加载的用户数据，Sans interroger à nouveau
foreach ($users as $user) {
echo $user->id . ' - ' . $user->name . "<br>";
}
?>
Ici, nous stockons les résultats de la requête dans le tableau des utilisateurs $ pour éviter la requête répétée de la base de données dans le code ultérieur.
En plus de la mise en cache et de la pagination, les éléments suivants sont certaines stratégies d'optimisation couramment utilisées:
Évitez d'utiliser SELECT * : Essayez de sélectionner uniquement les champs dont vous avez besoin pour réduire le transfert des données.
Requête par lots : essayez de remettre en question plusieurs enregistrements à la fois, plutôt que de les interroger un par un.
Index d'utilisation : assurez-vous que les champs pertinents de la table de base de données ont des index appropriés pour améliorer l'efficacité de la requête.
