Français
Français
Lors du développement d'applications Web, la requête de pagination est l'un des besoins très courants, en particulier dans les modules tels que les systèmes de gestion backend, les sections de commentaires ou les listes de produits qui doivent afficher une grande quantité de données. MySQL fournit la clause limite pour la pagination, tandis que la méthode PDOSTATION :: ROWCOUNT () en PDO de PHP peut être utilisée pour obtenir le nombre d'ensembles de résultats. Si les deux sont bien combinés, il peut non seulement améliorer la lisibilité du code, mais également optimiser considérablement l'efficacité de la requête.
La requête de pagination traditionnelle a généralement deux étapes:
Obtenez les données de la page actuelle: utilisez le décalage limite, comptez .
Obtenez le nombre total d'enregistrements: utilisez SELECT COUNT (*) dans la table .
Bien que cette méthode soit très courante, lorsque le tableau de données est grand, les frais généraux du nombre (*) peuvent être très élevés, en particulier dans des environnements de concurrence élevés, ce qui peut exercer beaucoup de pression sur la base de données.
Pdostatement :: RowCount () est incohérent dans la requête sélectionnée . Il n'est pas utilisé pour compter le nombre total d'enregistrements, mais pour renvoyer le nombre de lignes affectées par l'instruction exécutée cette fois. Lorsque vous utilisez SELECT , certaines bases de données (telles que PostgreSQL) la prennent en charge pour renvoyer le nombre de lignes pour le résultat de la requête, mais dans MySQL, il est possible de renvoyer un nombre précis de résultats uniquement si le PDO :: MySQL_ATTR_USE_BUFFERED_QUERY est défini.
$pdo = new PDO('mysql:host=localhost;dbname=testdb', 'user', 'pass', [
PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true,
]);
Bien que RowCount () ne puisse pas être entièrement invoqué pour obtenir le total, nous pouvons combiner la limite et la logique intelligente pour optimiser l'expérience de pagination dans certains scénarios. Par exemple, nous pouvons interroger une autre données par page pour déterminer s'il y a une page suivante, évitant ainsi l'opération de décompte (*) .
<?php
$pdo = new PDO('mysql:host=localhost;dbname=exampledb', 'user', 'password', [
PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true,
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
]);
$page = isset($_GET['page']) ? max(1, (int)$_GET['page']) : 1;
$pageSize = 10;
$offset = ($page - 1) * $pageSize;
$limitPlusOne = $pageSize + 1;
$sql = "SELECT * FROM articles ORDER BY created_at DESC LIMIT :offset, :limit";
$stmt = $pdo->prepare($sql);
$stmt->bindValue(':offset', $offset, PDO::PARAM_INT);
$stmt->bindValue(':limit', $limitPlusOne, PDO::PARAM_INT);
$stmt->execute();
$results = $stmt->fetchAll(PDO::FETCH_ASSOC);
$hasNextPage = false;
if (count($results) > $pageSize) {
$hasNextPage = true;
array_pop($results); // Retirer l'excès
}
// Rendre des données
foreach ($results as $article) {
echo "<h2>{$article['title']}</h2>";
echo "<p>{$article['summary']}</p>";
echo "<a href=\"https://gitbox.net/articles/{$article['id']}\">Lire le texte intégral</a><hr>";
}
if ($hasNextPage) {
echo "<a href=\"https://gitbox.net/list?page=" . ($page + 1) . "\">Page suivante</a>";
}
?>
Évitez le nombre de requêtes (*) et réduisez la pression de la base de données;
Utilisez la limite N + 1 pour déterminer s'il y a une page suivante;
La logique de traitement des données est concise et les performances sont bonnes;
Il convient particulièrement aux scénarios avec un grand volume de données et une faible profondeur de pagination.
Bien que la méthode ci-dessus soit efficace, elle ne s'applique pas à toutes les situations. Si votre page doit afficher des informations telles que le nombre total de pages, le nombre total d'enregistrements, etc., il est inévitable d'utiliser le nombre (*) :
$totalCount = $pdo->query("SELECT COUNT(*) FROM articles")->fetchColumn();
$totalPages = ceil($totalCount / $pageSize);
Un compromis consiste à mettre en cache le nombre total d'informations et à les actualiser régulièrement pour éviter les calculs en temps réel à chaque fois.
Il n'y a pas de meilleures pratiques "une taille unique" lors de l'optimisation de la pagination. Combinant raisonnablement la limite , RowCount () et les besoins commerciaux est la clé de la requête de pagination haute performance. Si vous poursuivez des performances extrêmes, vous pouvez considérer la "pagination basée sur le curseur" sur la base des clés ou des horodatages primaires, qui fonctionnent mieux dans les grands ensembles de données.
Avec les conseils introduits dans cet article, vous pouvez éviter les requêtes de nombre coûteuses (*) dans la plupart des scénarios tout en maintenant une bonne expérience utilisateur et une précision de pagination.
