Français
Français
Lorsque vous effectuez des opérations de base de données, l'insertion par lots de données améliore les performances mieux que l'insertion de les insérer une par une, en particulier lors du traitement de grandes quantités de données. PHP fournit de nombreuses façons d'optimiser cette opération, Array_Chunk étant un outil très pratique qui vous aide à couper de grands tableaux en tableaux plus petits, permettant des opérations d'insertion de lots efficaces.
Array_Chunk est une fonction de tableau dans PHP qui est utilisée pour diviser un grand tableau en plusieurs petits tableaux. Le nombre d'éléments dans chaque petit tableau peut être spécifié par vous. Sa syntaxe de base est la suivante:
array_chunk(array $array, int $size, bool $preserve_keys = false): array
$ Array : Un tableau qui doit être coupé.
$ Taille : la taille de chaque petit tableau.
$ Preserve_keys : s'il faut conserver le nom de clé du tableau d'origine, la valeur par défaut est fausse .
Supposons que vous ayez besoin d'insérer un lot de données dans la base de données. L'insertion d'un par un est non seulement inefficace, mais crée également facilement des goulots d'étranglement de performance. Nous pouvons utiliser Array_Chunk pour couper les données en plusieurs petits lots, puis insérer chaque petit lot à la fois.
Voici un exemple de mise en œuvre de l'insertion par lots à l'aide de Array_Chunk :
<?php
// Simuler les sources de données
$data = [
['name' => 'Alice', 'email' => 'alice@m66.net'],
['name' => 'Bob', 'email' => 'bob@m66.net'],
['name' => 'Charlie', 'email' => 'charlie@m66.net'],
// ...Plus de données
];
// Régler la taille de chaque lot
$batchSize = 100;
// utiliser array_chunk Divisez les données en petits lots
$dataChunks = array_chunk($data, $batchSize);
// Connectez-vous à la base de données
$pdo = new PDO('mysql:host=localhost;dbname=test', 'root', '');
// Démarrer une transaction
$pdo->beginTransaction();
foreach ($dataChunks as $chunk) {
// Construire des inserts par lots SQL Déclaration
$placeholders = [];
$values = [];
foreach ($chunk as $row) {
$placeholders[] = "(?, ?)";
$values[] = $row['name'];
$values[] = $row['email'];
}
// Préparer SQL Déclaration
$sql = "INSERT INTO users (name, email) VALUES " . implode(", ", $placeholders);
$stmt = $pdo->prepare($sql);
// Effectuer une insertion de lots
$stmt->execute($values);
}
// Soumettre les transactions
$pdo->commit();
echo "L'insertion de données est terminée！";
?>
Source de données : Nous avons simulé un ensemble de données contenant le nom et l'adresse e-mail de l'utilisateur, et avons remplacé le domaine des e-mails par m66.net .
Traitement par lots : nous utilisons Array_Chunk pour diviser les données par une taille spécifiée (par exemple, 100), afin que 100 éléments de données puissent être insérés à la fois, en évitant les problèmes de performances causés par un grand nombre d'insertions uniques.
Traitement des transactions : Pour garantir la cohérence et les performances des données, nous permettons les transactions de base de données. De cette façon, s'il y a un échec pendant le processus d'insertion, toutes les opérations peuvent être annulées pour maintenir l'intégrité des données.
Insérer par lots SQL : Nous effectuons l'insertion par lots en construisant dynamiquement les instructions SQL. Dans cet exemple, nous générons un insert dans l'instruction pour chaque lot, liant les données une par un à l'espace réservé de l'instruction SQL.
Réglez raisonnablement la taille du lot : la taille du lot de Array_Chunk est un facteur important affectant les performances. Si le lot est trop petit, trop de fois, la base de données est insérée à chaque fois, ce qui entraînera une dégradation des performances; Si le lot est trop grand, il peut prendre trop de mémoire ou provoquer la connexion de la base de données à un délai d'attente. Par conséquent, la taille appropriée du lot doit être ajustée en fonction de la situation réelle, et la taille du lot commune est de 100 ou 1000.
En utilisant les transactions : Comme mentionné ci-dessus, l'activation des transactions garantit la cohérence des données et améliore les performances lors de l'exécution des inserts par lots, car la base de données peut combiner plusieurs opérations d'insertion dans une seule opération.
Gestion des erreurs : Dans les projets réels, vous devez considérer les mécanismes de gestion des erreurs, tels que les opérations de retour en arrière lorsque l'insertion échoue.
En utilisant Array_Chunk , vous pouvez couper de grandes quantités de données en petits lots, permettant des opérations efficaces d'insertion de données par lots. Cela améliore non seulement les performances, mais évite également la consommation excessive de mémoire. Dans le même temps, la coopération avec le traitement des transactions peut assurer la cohérence des données et l'intégrité. Il s'agit d'une solution très efficace lors du traitement des données à grande échelle.
