


Optimiser les suppressions de masse PostgreSQL avec le partitionnement de table
Dans la gestion de bases de données, la gestion efficace des opérations de données à grande échelle est essentielle. Un défi courant consiste à exécuter des suppressions massives sur de grandes tables sans nuire aux performances globales. Cet article examine comment la fonctionnalité de partitionnement de table de PostgreSQL peut accélérer considérablement le processus et
aider à maintenir des opérations de base de données fluides.
Découvrez plus de mon travail ici.
Le défi des suppressions massives
Supprimer un grand nombre de lignes d'une table PostgreSQL peut être une opération fastidieuse. Cela implique :
- Parcourir le tableau pour trouver les lignes à supprimer
- Suppression des lignes et mise à jour des index
- Passer l'aspirateur sur la table pour récupérer de l'espace
Pour les tables comportant des millions de lignes, ce processus peut entraîner des transactions de longue durée et des verrous de table, ce qui peut avoir un impact sur la réactivité de la base de données.
Entrez le partitionnement de la table
Le partitionnement de table est une technique dans laquelle une grande table est divisée en morceaux plus petits et plus faciles à gérer appelés partitions. Ces partitions sont des tables distinctes qui partagent le même schéma que la table parent.
Ma configuration de référence
Pour quantifier les bénéfices du partitionnement, j'ai mis en place un benchmark avec trois scénarios utilisant PostgreSQL dans un environnement conteneurisé :
- Table simple : Une table standard non partitionnée
- Table partitionnée (suppression de lignes) : Une table partitionnée par semaine, supprimant les lignes de la première semaine
- Table partitionnée (Partition Drop) : Identique au n°2, mais supprimant toute la partition de la première semaine
Spécifications du conteneur PostgreSQL
- Version PostgreSQL : 16.4
- Version Docker : 27.0.3
- Limites des ressources :
- Limite du processeur : 8 processeurs
- Limite de mémoire : 1 Go
Caractéristiques des données
- Total des records : 4 millions
- Distribution : Répartie uniformément sur 4 semaines (1 million par semaine)
- Indexation : Les deux tables (simples et partitionnées) ont un index sur la colonne temps
Principales conclusions
Scenario | Deletion Time | Table Size |
---|---|---|
Simple Table | 1.26s | 728 MB |
Partitioned (Delete Rows) | 734ms | 908 MB |
Partitioned (Drop Partition) | 6.43ms | 908 MB |
- Amélioration spectaculaire de la vitesse : La suppression d'une partition est 196 fois plus rapide que la suppression de lignes d'une simple table.
- Compromis en matière de stockage : Les tables partitionnées utilisent environ 25 % de stockage en plus en raison de métadonnées supplémentaires et d'index par partition.
- Impact d'insertion minimal : Le partitionnement n'a que légèrement augmenté le temps de remplissage des données (d'environ 2,8 %).
Pourquoi ça marche
- Opérations ciblées : Le partitionnement permet à la base de données de fonctionner avec un sous-ensemble de données, réduisant ainsi la portée des opérations.
- Opérations de métadonnées : La suppression d'une partition est avant tout une opération de métadonnées, évitant d'avoir à analyser et à supprimer des lignes individuelles.
- Contention de verrouillage réduite : Des partitions plus petites signifient moins de verrous, permettant une meilleure concurrence.
Points saillants de la mise en œuvre
Voici un exemple simplifié de la façon de configurer une table partitionnée dans PostgreSQL :
CREATE TABLE records (<br> id BIGSERIAL,<br> time TIMESTAMPTZ NOT NULL,<br> body TEXT<br> ) PARTITION BY RANGE (time); <p>CREATE TABLE records_week_1 PARTITION OF records<br> FOR VALUES FROM ('2023-01-01') TO ('2023-01-08');</p> <p>-- Create index on the partition<br> CREATE INDEX idx_records_week_1_time ON records_week_1 (time);</p> <p>-- To delete a week's worth of data:<br> ALTER TABLE records DETACH PARTITION records_week_1;<br> DROP TABLE records_week_1;<br> </p>
Conclusion
Pour les bases de données traitant des données de séries chronologiques ou tout scénario dans lequel les suppressions à grande échelle sont courantes, la mise en œuvre du partitionnement des tables peut entraîner des améliorations significatives des performances. Bien qu'il existe un petit compromis entre le stockage et la vitesse d'insertion, les gains en termes d'efficacité de suppression dépassent souvent de loin ces coûts.
En tirant parti du partitionnement, vous pouvez maintenir des performances élevées même si vos données augmentent, garantissant ainsi que votre base de données PostgreSQL reste réactive et efficace.
Lien vers le code de référence complet et les résultats détaillés
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Outils d'IA chauds

Undress AI Tool
Images de déshabillage gratuites

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

La façon la plus efficace d'écrire un kubernetesoperator est d'utiliser Go pour combiner kubebuilder et contrôleur-runtime. 1. Comprendre le modèle de l'opérateur: définir les ressources personnalisées via CRD, écrivez un contrôleur pour écouter les changements de ressources et effectuer des boucles de réconciliation pour maintenir l'état attendu. 2. Utilisez KubeBuilder pour initialiser le projet et créer des API pour générer automatiquement les CRD, les contrôleurs et les fichiers de configuration. 3. Définissez la structure de spécification et de statut de CRD dans API / V1 / MYAPP_TYPES.go, et exécutez MakeManifests pour générer CRDYAML. 4. Réconcilier dans le contrôleur

La panique est comme un programme "cardiaque" en Go. Le récupération peut être utilisé comme "outil de premiers soins" pour éviter les accidents, mais récupérer ne prend effet que dans la fonction de différence. 1. Le débit est utilisé pour éviter les laps de service, les journaux de journaux et les erreurs amicales de retour. 2. Il doit être utilisé en conjonction avec un repère et ne prend effet que sur la même goroutine. Le programme ne revient pas au point de panique après la récupération. 3. Il est recommandé de l'utiliser au niveau supérieur ou à l'entrée critique, et ne vous en abusez pas, et n'accordez pas la priorité à l'utilisation du traitement des erreurs. 4. Le modèle commun est d'encapsuler des fonctions Saferun pour envelopper une éventuelle logique de panique. Ce n'est qu'en maîtrisant ses scénarios d'utilisation et ses limitations qu'il peut jouer correctement son rôle.

L'allocation de pile convient aux petites variables locales avec des cycles de vie clairs et est automatiquement géré, à vitesse rapide mais de nombreuses restrictions; L'allocation de tas est utilisée pour les données avec des cycles de vie longs ou incertains, et est flexible mais a un coût de performance. Le compilateur GO détermine automatiquement la position d'allocation variable par analyse d'échappement. Si la variable peut s'échapper de la portée de la fonction actuelle, elle sera allouée au tas. Les situations courantes qui provoquent une évasion comprennent: le renvoi des pointeurs de variables locales, l'attribution de valeurs aux types d'interface et le passage des goroutines. Les résultats de l'analyse d'échappement peuvent être visualisés via -gcflags = "- m". Lorsque vous utilisez des pointeurs, vous devez faire attention au cycle de vie variable pour éviter les évasions inutiles.

Le langage GO peut être utilisé pour les calculs scientifiques et l'analyse numérique, mais il faut comprendre. L'avantage réside dans le support et les performances de la concurrence, qui conviennent aux algorithmes parallèles tels que la solution distribuée, la simulation Monte Carlo, etc.; Les bibliothèques communautaires telles que Gonum et MAT64 offrent des fonctions de calcul numérique de base; La programmation hybride peut être utilisée pour appeler C / C et Python via CGO ou Interface pour améliorer la praticité. La limitation est que l'écosystème n'est pas aussi mature que Python, la visualisation et les outils avancés sont plus faibles et certains documents de bibliothèque sont incomplets. Il est recommandé de sélectionner des scénarios appropriés en fonction des fonctionnalités GO et de se référer aux exemples de code source pour les utiliser en profondeur.

HTTP Log Middleware dans GO peut enregistrer les méthodes de demande, les chemins de requête, la propriété intellectuelle du client et le temps qui prend du temps. 1. Utilisez http.handlerfunc pour envelopper le processeur, 2. Enregistrez l'heure de début et l'heure de fin avant et après l'appel Suivant.Servehttp, 3. Obtenez le vrai client IP via R.RemoteAddr et X-Forwared-For Headers, 4. Utilisez le log.printf aux journaux de demande de sortie, 5. L'exemple de code complet a été vérifié pour s'exécuter et convient au démarrage d'un projet petit et moyen. Les suggestions d'extension incluent la capture des codes d'état, la prise en charge des journaux JSON et le suivi des ID de demande.

Utilisez fmt.scanf pour lire l'entrée formatée, adaptée aux données structurées simples, mais la chaîne est coupée lors de la rencontre des espaces; 2. Il est recommandé d'utiliser Bufio.Scanner pour lire la ligne par ligne, prend en charge les entrées multi-lignes, la détection EOF et l'entrée du pipeline et peut gérer les erreurs de numérisation; 3. Utilisez io.readall (os.stdin) pour lire toutes les entrées à la fois, adapté au traitement de grandes données de bloc ou de flux de fichiers; 4. La réponse clé en temps réel nécessite des bibliothèques tierces telles que golang.org/x/term, et Bufio est suffisant pour les scénarios conventionnels; Suggestions pratiques: utilisez fmt.scan pour une entrée simple interactive, utilisez bufio.scanner pour une entrée de ligne ou un pipeline, utilisez io.readall pour les données de gros bloc et gérez toujours

L'instruction Switch de Go ne sera pas exécutée tout au long du processus par défaut et quittera automatiquement après la correspondance de la première condition. 1. Switch commence par un mot-clé et peut transporter une valeur ou aucune valeur; 2. Les matchs de cas de haut en bas dans l'ordre, seul le premier match est exécuté; 3. Plusieurs conditions peuvent être répertoriées par des virgules pour correspondre au même cas; 4. Il n'est pas nécessaire d'ajouter manuellement la pause, mais peut être forcé; 5.Default est utilisé pour les cas inégalés, généralement placés à la fin.

Les génériques GO sont pris en charge depuis 1.18 et sont utilisés pour écrire du code générique pour le type de type. 1. La fonction générique imprimslice [tany] (s [] t) peut imprimer des tranches de tout type, telles que [] int ou [] chaîne. 2. Grâce au nombre de contraintes de type, les limites des types numériques tels que int et float, sum [tnumber] (tranche [] t) t La sommation sûre est réalisée. 3. La boîte de type générique de structure [tany] struct {Valuet} peut encapsuler n'importe quelle valeur de type et être utilisée avec le constructeur newbox [tany] (VT) * Box [t]. 4. Ajouter SET (VT) et Get () T Méthodes T à boxer [t] sans
