Optimiser les performances de mise à jour en masse dans PostgreSQL

Utiliser PG 9.1 sur Ubuntu 12.04.

Il nous faut actuellement jusqu'à 24 heures pour exécuter un grand nombre d'instructions UPDATE sur une base de données, qui se présente sous la forme:

UPDATE table
SET field1 = constant1, field2 = constant2, ...
WHERE id = constid

(Nous ne faisons que remplacer des champs d'objets identifiés par un ID.) Les valeurs proviennent d'une source de données externe (pas déjà dans le DB dans une table).

Les tables ont des poignées d'indices chacune et aucune contrainte de clé étrangère. Aucun engagement n'est fait jusqu'à la fin.

Il faut 2h pour importer une partie pg_dumpde la base de données. Cela semble être une base de référence que nous devrions raisonnablement cibler.

Mis à part la production d'un programme personnalisé qui reconstruit en quelque sorte un ensemble de données que PostgreSQL peut réimporter, pouvons-nous faire quelque chose pour rapprocher les performances UPDATE en bloc de celles de l'importation? (C’est un domaine que nous pensons être bien géré par les arbres de fusion logarithmiques, mais nous nous demandons s’il est possible de faire quelque chose dans PostgreSQL.)

Quelques idées:

• abandonner tous les index non-ID et reconstruire ensuite?
• checkpoint_segments croissants, mais cela aide-t-il réellement à un débit soutenu à long terme?
• en utilisant les techniques mentionnées ici ? (Charger les nouvelles données sous forme de table, puis "fusionner" les anciennes données sans identifiant)

Fondamentalement, il y a beaucoup de choses à essayer et nous ne savons pas ce qui est le plus efficace ou si nous négligeons d'autres choses. Nous allons passer les prochains jours à expérimenter, mais nous pensions pouvoir le faire ici aussi.

J'ai une charge simultanée sur la table mais elle est en lecture seule.

Hypothèses

Comme il manque des informations dans le Q, je suppose:

• Vos données proviennent d'un fichier sur le serveur de base de données.
• Les données sont formatées de la même manière que la COPYsortie, avec un numéro unique id par ligne correspondant à la table cible.
  Sinon, formatez-le correctement en premier ou utilisez les COPYoptions pour gérer le format.
• Vous mettez à jour chaque ligne de la table cible ou la plupart d'entre elles.
• Vous pouvez vous permettre de supprimer et de recréer la table cible.
  Cela signifie pas d' accès simultané. Sinon, considérez cette réponse:
  • La meilleure façon de remplir une nouvelle colonne dans un grand tableau?
• Il n'y a aucun objet dépendant du tout, à l'exception des index.

Solution

Je suggère que vous adoptiez une approche similaire à celle décrite au lien de votre troisième puce . Avec des optimisations majeures.

Pour créer la table temporaire, il existe un moyen plus simple et plus rapide:

CREATE TEMP TABLE tmp_tbl AS SELECT * FROM tbl LIMIT 0;

Une seule grande UPDATEd'une table temporaire dans la base de données sera plus rapide que les mises à jour individuelles de l'extérieur de la base de données de plusieurs ordres de grandeur.

Dans le modèle MVCC de PostgreSQL , un UPDATEmoyen de créer une nouvelle version de ligne et de marquer l'ancienne comme étant supprimée. C'est à peu près aussi cher qu'un INSERTet un DELETEcombiné. De plus, il vous laisse beaucoup de tuples morts. De toute façon, comme vous mettez à jour toute la table, il serait plus rapide de simplement créer une nouvelle table et de supprimer l’ancienne.

Si vous avez assez de RAM disponible, définissez temp_buffers(uniquement pour cette session!) Suffisamment haut pour contenir la table temporaire en RAM - avant toute chose.

Pour obtenir une estimation de la quantité de RAM nécessaire, exécutez un test avec un petit échantillon et utilisez les fonctions de taille d'objet db :

SELECT pg_size_pretty(pg_relation_size('tmp_tbl'));  -- complete size of table
SELECT pg_column_size(t) FROM tmp_tbl t LIMIT 10;  -- size of sample rows

Script complet

SET temp_buffers = '1GB';        -- example value

CREATE TEMP TABLE tmp_tbl AS SELECT * FROM tbl LIMIT 0;

COPY tmp_tbl FROM '/absolute/path/to/file';

CREATE TABLE tbl_new AS
SELECT t.col1, t.col2, u.field1, u.field2
FROM   tbl     t
JOIN   tmp_tbl u USING (id);

-- Create indexes like in original table
ALTER TABLE tbl_new ADD PRIMARY KEY ...;
CREATE INDEX ... ON tbl_new (...);
CREATE INDEX ... ON tbl_new (...);

-- exclusive lock on tbl for a very brief time window!
DROP TABLE tbl;
ALTER TABLE tbl_new RENAME TO tbl;

DROP TABLE tmp_tbl; -- will also be dropped at end of session automatically

Charge simultanée

Les opérations simultanées sur la table (que j’avais exclues dans les hypothèses au début) attendent, une fois que la table est verrouillée près de la fin et échouent dès que la transaction est validée, car le nom de la table est résolu immédiatement en OID, mais la nouvelle table a un OID différent. La table reste cohérente, mais les opérations simultanées peuvent faire l'objet d'une exception et doivent être répétées. Détails dans cette réponse:

• La meilleure façon de remplir une nouvelle colonne dans un grand tableau?

UPDATE route

Si vous devez (suivre) la UPDATEroute, supprimez tout index non nécessaire lors de la mise à jour, puis recréez-le. Il est beaucoup moins coûteux de créer un index en un seul morceau que de le mettre à jour pour chaque ligne. Cela peut également permettre des mises à jour HOT .

J'ai décrit une procédure similaire en utilisant UPDATEdans cette réponse étroitement liée sur SO .

Si les données peuvent être rendues disponibles dans un fichier structuré, vous pouvez les lire avec un wrapper de données étrangères et effectuer une fusion sur la table cible.