Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Chargement de tables avec les commandes DML
Amazon Redshift prend en charge les commandes standard du langage de manipulation de données (INSERT, UPDATE et DELETE), que vous pouvez utiliser pour modifier les lignes des tables. Vous pouvez aussi utiliser la commande TRUNCATE pour des suppressions en bloc rapides.
**Note**
Nous vous encourageons vivement à utiliser la commande [COPY](r_COPY.md) pour charger de grandes quantités de données. La lenteur liée à l’utilisation d’instructions INSERT pour remplir une table peut être prohibitive. Sinon, si vos données existent déjà dans d’autres tables de bases de données Amazon Redshift, utilisez INSERT INTO ... SELECT FROM ou CREATE TABLE AS pour améliorer les performances. Pour plus d’informations, consultez [INSERT](r_INSERT_30.md) ou [CREATE TABLE AS](r_CREATE_TABLE_AS.md).
Si vous insérez, mettez à jour ou supprimez un nombre important de lignes dans une table, par rapport au nombre de lignes avant les modifications, exécutez les commandes ANALYZE et VACUUM sur la table lorsque vous avez terminé. Si un certain nombre de petites modifications s’accumulent au fil du temps dans votre application, vous souhaiterez peut-être planifier les commandes ANALYZE et VACUUM pour qu’elles s’exécutent à intervalles réguliers. Pour plus d’informations, consultez [Analyse des tables](t_Analyzing_tables.md) et [Exécution de l’opération VACUUM sur les tables](t_Reclaiming_storage_space202.md).
**Topics**
+ [Mise à jour et insertion de nouvelles données](t_updating-inserting-using-staging-tables-.md)
# Mise à jour et insertion de nouvelles données
Vous pouvez ajouter de manière efficace de nouvelles données à une table existante à l’aide de la commande MERGE. Effectuez une opération de fusion en créant une table intermédiaire, puis utilisez l’une des méthodes décrites dans cette section pour mettre à jour la table cible à partir de la table intermédiaire. Pour en savoir plus sur la commande MERGE, consultez [MERGE](r_MERGE.md).
[Exemples de fusion](merge-examples.md) utilise un exemple de jeu de données pour Amazon Redshift, appelé jeu de données TICKIT. Comme condition préalable, vous pouvez configurer les tables et les données TICKIT en suivant les instructions disponibles dans [Démarrage avec les tâches courantes liées aux bases de données](https://docs.aws.amazon.com/redshift/latest/gsg/database-tasks.html). Des informations plus détaillées sur le jeu de données en exemple sont disponibles dans la [base de données en exemple](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
## Méthode de fusion 1 : remplacement des lignes existantes
Si vous remplacez toutes les colonnes de la table cible, le moyen le plus rapide d’effectuer une fusion est de remplacer les lignes existantes. La table cible est analysée une seule fois, et une jointure interne est utilisée pour supprimer les lignes qui sont appelées à être mises à jour. Une fois que les lignes ont été supprimées, elles sont remplacées par de nouvelles lignes via une opération d’insertion unique à partir de la table intermédiaire.
Utilisez cette méthode si toutes les conditions suivantes sont vraies :
+ Votre table cible votre table intermédiaire contiennent les mêmes colonnes.
+ Vous avez l’intention de remplacer toutes les données des colonnes de la table cible par toutes les colonnes de la table intermédiaire.
+ Vous allez utiliser toutes les lignes de la table intermédiaire dans la fusion.
Si l’un de ces critères ne s’applique pas, utilisez la méthode de fusion 2 : spécification d’une liste de colonnes sans utiliser MERGE, décrite dans la section suivante.
Si vous n’utilisez pas toutes les lignes de la table intermédiaire, filtrez les instructions DELETE et INSERT en utilisant une clause WHERE pour ignorer les lignes qui ne sont pas modifiées. Cependant, si la plupart des lignes de la table intermédiaire ne prennent pas part à la fusion, nous recommandons d’exécuter les commandes UPDATE et INSERT en étapes distinctes, comme décrit ultérieurement dans cette section.
## Méthode de fusion 2 : spécification d’une liste de colonnes sans utiliser MERGE
Utilisez cette méthode pour mettre à jour des colonnes spécifiques de la table cible au lieu de remplacer des lignes entières. Cette méthode prend plus de temps que la méthode précédente, car elle nécessite une étape de mise à jour supplémentaire et elle n’utilise pas la commande MERGE. Utilisez cette méthode si l’une des conditions suivantes est vraie :
+ Certaines colonnes de la table cible ne doivent pas être mises à jour.
+ La plupart des lignes de la table intermédiaire ne sont pas utilisées dans les mises à jour.
**Topics**
+ [Méthode de fusion 1 : remplacement des lignes existantes](#merge-method-replace-existing-rows)
+ [Méthode de fusion 2 : spécification d’une liste de colonnes sans utiliser MERGE](#merge-method-specify-column-list)
+ [Création d’une table temporaire intermédiaire](merge-create-staging-table.md)
+ [Exécution d’une opération de fusion par remplacement des lignes existantes](merge-replacing-existing-rows.md)
+ [Exécution d’une opération de fusion en spécifiant une liste de colonnes sans utiliser la commande MERGE](merge-specify-a-column-list.md)
+ [Exemples de fusion](merge-examples.md)
# Création d’une table temporaire intermédiaire
La *table intermédiaire* est une table temporaire qui contient toutes les données qui seront utilisées pour apporter des modifications à la *table cible*, mises à jour et insertions incluses.
Une opération de fusion nécessite une jointure entre la table intermédiaire et la table cible. Pour rassembler les lignes de la jointure, définissez la clé de distribution de la table intermédiaire avec la même colonne que la clé de distribution de la table cible. Par exemple, si la table cible utilise une colonne de clé étrangère comme clé de distribution, utilisez la même colonne pour la clé de distribution de la table intermédiaire. Si vous créez la table intermédiaire à l’aide d’une instruction [CREATE TABLE LIKE](r_CREATE_TABLE_NEW.md#create-table-like), la table intermédiaire hérite de la clé de distribution de la table parent. Si vous utilisez une instruction CREATE TABLE AS, la nouvelle table n’hérite pas de la clé de distribution. Pour plus d'informations, consultez [Distribution de données pour l’optimisation des requêtes](t_Distributing_data.md)
Si la clé de distribution n’est pas la même que la clé primaire et que la clé de distribution n’est pas mise à jour dans le cadre de l’opération de fusion, ajoutez un prédicat de jointure redondant sur les colonnes de clé de distribution pour permettre une jointure colocalisée. Par exemple :
```
where target.primarykey = stage.primarykey
and target.distkey = stage.distkey
```
Pour vérifier que la requête utilise une jointure colocalisée, exécutez la requête avec [EXPLAIN](r_EXPLAIN.md) et recherchez DS\$1DIST\$1NONE sur l’ensemble des jointures. Pour plus d'informations, consultez [Évaluation du plan de requête](c_data_redistribution.md)
# Exécution d’une opération de fusion par remplacement des lignes existantes
Exécutez la totalité de l’opération de fusion détaillée dans la procédure, sauf la création et la suppression de la table intermédiaire temporaire, dans une même transaction. La transaction est annulée en cas d’échec d’une étape. L’utilisation d’une seule transaction réduit aussi le nombre de validations, ce qui permet de gagner du temps et d’économiser des ressources.
**Pour exécuter une opération de fusion par remplacement des lignes existantes**
1. Créez une table intermédiaire, puis complétez-la avec les données à fusionner, comme illustré dans le pseudocode suivant.
```
CREATE temp table stage (like target);
INSERT INTO stage
SELECT * FROM source
WHERE source.filter = 'filter_expression';
```
1. Utilisez MERGE pour effectuer une jointure interne avec la table intermédiaire afin de mettre à jour les lignes de la table cible qui ont une correspondance dans la table intermédiaire, puis insérez toutes les lignes restantes dans la table cible qui n’ont pas de correspondance dans la table intermédiaire.
Nous vous recommandons d’exécuter les opérations de mise à jour et d’insertion dans une même commande MERGE.
```
MERGE INTO target
USING stage [optional alias] on (target.primary_key = stage.primary_key)
WHEN MATCHED THEN
UPDATE SET col_name1 = stage.col_name1 , col_name2= stage.col_name2, col_name3 = {expr}
WHEN NOT MATCHED THEN
INSERT (col_name1 , col_name2, col_name3) VALUES (stage.col_name1, stage.col_name2, {expr});
```
1. Supprimez la table intermédiaire.
```
DROP TABLE stage;
```
# Exécution d’une opération de fusion en spécifiant une liste de colonnes sans utiliser la commande MERGE
Exécutez la totalité de l’opération de fusion détaillée dans la procédure dans une même transaction. La transaction est annulée en cas d’échec d’une étape. L’utilisation d’une seule transaction réduit aussi le nombre de validations, ce qui permet de gagner du temps et d’économiser des ressources.
**Pour exécuter une opération de fusion par spécification d’une liste de colonnes**
1. Placez l’ensemble de l’opération dans un seul bloc de transactions.
```
BEGIN transaction;
…
END transaction;
```
1. Créez une table intermédiaire, puis complétez-la avec les données à fusionner, comme illustré dans le pseudocode suivant.
```
create temp table stage (like target);
insert into stage
select * from source
where source.filter = 'filter_expression';
```
1. Mettez à jour la table cible à l’aide d’une jointure interne avec la table intermédiaire.
+ Dans la clause UPDATE, listez explicitement les colonnes à mettre à jour.
+ Effectuez une jointure interne avec la table intermédiaire.
+ Si la clé de distribution est différente de la clé primaire et que la clé de distribution n’est pas mise à jour, ajoutez une jointure redondante sur la clé de distribution. Pour vérifier que la requête utilise une jointure colocalisée, exécutez la requête avec [EXPLAIN](r_EXPLAIN.md) et recherchez DS\$1DIST\$1NONE sur l’ensemble des jointures. Pour plus d'informations, consultez [Évaluation du plan de requête](c_data_redistribution.md)
+ Si votre table cible est triée par horodatage, ajoutez un prédicat pour tirer parti des analyses à plage restreinte sur la table cible. Pour plus d’informations, consultez [Bonnes pratiques Amazon Redshift pour la conception de requêtes](c_designing-queries-best-practices.md).
+ Si vous n’utilisez pas toutes les lignes de la fusion, ajoutez une clause pour filtrer les lignes que vous ne voulez pas modifier. Par exemple, ajoutez un filtre d’inégalité sur une ou plusieurs colonnes afin d’exclure les lignes qui n’ont pas changé.
+ Placez les opérations de mise à jour, de suppression et d’insertion dans un même bloc de transaction de telle sorte qu’en cas de problème, tout puisse être annulé.
Par exemple :
```
begin transaction;
update target
set col1 = stage.col1,
col2 = stage.col2,
col3 = 'expression'
from stage
where target.primarykey = stage.primarykey
and target.distkey = stage.distkey
and target.col3 > 'last_update_time'
and (target.col1 != stage.col1
or target.col2 != stage.col2
or target.col3 = 'filter_expression');
```
1. Supprimez les lignes superflues de la table intermédiaire à l’aide d’une jointure interne avec la table cible. Certaines lignes de la table cible correspondent déjà aux lignes correspondantes de la table intermédiaire, tandis que d’autres ont été mises à jour lors de l’étape précédente. Dans les deux cas, elles ne sont pas nécessaires pour l’insertion.
```
delete from stage
using target
where stage.primarykey = target.primarykey;
```
1. Insérez les lignes restantes de la table intermédiaire. Utilisez la même liste de la colonne dans la clause VALUES que celle que vous avez utilisée dans l’instruction UPDATE à l’étape 2.
```
insert into target
(select col1, col2, 'expression'
from stage);
end transaction;
```
1. Supprimez la table intermédiaire.
```
drop table stage;
```
# Exemples de fusion
Les exemples suivants effectuent une fusion pour mettre à jour la table SALES. Le premier exemple utilise la méthode la plus simple pour supprimer les lignes de la table cible, puis insérer toutes les lignes de la table intermédiaire. Comme le deuxième exemple nécessite une mise à jour des colonnes de la sélection, elle inclut une étape de mise à jour supplémentaire.
[Exemples de fusion](#merge-examples) utilise un exemple de jeu de données pour Amazon Redshift, appelé jeu de données TICKIT. Comme condition préalable, vous pouvez configurer les tables et les données TICKIT en suivant les instructions disponibles dans le guide [Démarrage avec les tâches courantes liées aux bases de données](https://docs.aws.amazon.com/redshift/latest/gsg/database-tasks.html). Des informations plus détaillées sur le jeu de données en exemple sont disponibles dans la [base de données en exemple](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
**Exemple de source de données de fusion**
Les exemples de cette section nécessitent un exemple de source de données qui inclut les mises à jour et les insertions. Pour les exemples, nous allons créer un exemple de table nommée SALES\$1UPDATE qui utilise les données de la table SALES. Nous allons remplir la nouvelle table avec des données aléatoires qui représentant les nouvelles activités de vente pour décembre. Nous allons utiliser l’exemple de table SALES\$1UPDATE pour créer la table intermédiaire dans les exemples suivants.
```
-- Create a sample table as a copy of the SALES table.
create table tickit.sales_update as
select * from tickit.sales;
-- Change every fifth row to have updates.
update tickit.sales_update
set qtysold = qtysold*2,
pricepaid = pricepaid*0.8,
commission = commission*1.1
where saletime > '2008-11-30'
and mod(sellerid, 5) = 0;
-- Add some new rows to have inserts.
-- This example creates a duplicate of every fourth row.
insert into tickit.sales_update
select (salesid + 172456) as salesid, listid, sellerid, buyerid, eventid, dateid, qtysold, pricepaid, commission, getdate() as saletime
from tickit.sales_update
where saletime > '2008-11-30'
and mod(sellerid, 4) = 0;
```
**Exemple de fusion qui remplace les lignes existantes sur la base de clés correspondantes**
Le script suivant utilise la table SALES\$1UPDATE pour effectuer une opération de fusion sur la table SALES avec de nouvelles données pour l’activité de vente de décembre. Cet exemple remplace les lignes de la table SALES qui ont été mises à jour. Pour cet exemple, nous allons mettre à jour les colonnes qtysold et pricepaid, mais laisser commission et saletime inchangées.
```
MERGE into tickit.sales
USING tickit.sales_update sales_update
on ( sales.salesid = sales_update.salesid
and sales.listid = sales_update.listid
and sales_update.saletime > '2008-11-30'
and (sales.qtysold != sales_update.qtysold
or sales.pricepaid != sales_update.pricepaid))
WHEN MATCHED THEN
update SET qtysold = sales_update.qtysold,
pricepaid = sales_update.pricepaid
WHEN NOT MATCHED THEN
INSERT (salesid, listid, sellerid, buyerid, eventid, dateid, qtysold , pricepaid, commission, saletime)
values (sales_update.salesid, sales_update.listid, sales_update.sellerid, sales_update.buyerid, sales_update.eventid,
sales_update.dateid, sales_update.qtysold , sales_update.pricepaid, sales_update.commission, sales_update.saletime);
-- Drop the staging table.
drop table tickit.sales_update;
-- Test to see that commission and salestime were not impacted.
SELECT sales.salesid, sales.commission, sales.salestime, sales_update.commission, sales_update.salestime
FROM tickit.sales
INNER JOIN tickit.sales_update sales_update
ON
sales.salesid = sales_update.salesid
AND sales.listid = sales_update.listid
AND sales_update.saletime > '2008-11-30'
AND (sales.commission != sales_update.commission
OR sales.salestime != sales_update.salestime);
```
**Exemple de fusion qui spécifie une liste de colonnes sans utiliser MERGE**
L’exemple suivant effectue une opération de fusion pour mettre à jour SALES avec de nouvelles données pour l’activité de vente de décembre. Nous avons besoin d’exemples de données qui incluent les opérations de mise à jour et d’insertion, ainsi que les lignes qui n’ont pas changé. Pour cet exemple, nous voulons mettre à jour les colonnes QTYSOLD et PRICEPAID, mais laisser COMMISSION et SALETIME telles quelles. Le script suivant utilise la table SALES\$1UPDATE pour effectuer une opération de fusion sur la table SALES.
```
-- Create a staging table and populate it with rows from SALES_UPDATE for Dec
create temp table stagesales as select * from sales_update
where saletime > '2008-11-30';
-- Start a new transaction
begin transaction;
-- Update the target table using an inner join with the staging table
-- The join includes a redundant predicate to collocate on the distribution key –- A filter on saletime enables a range-restricted scan on SALES
update sales
set qtysold = stagesales.qtysold,
pricepaid = stagesales.pricepaid
from stagesales
where sales.salesid = stagesales.salesid
and sales.listid = stagesales.listid
and stagesales.saletime > '2008-11-30'
and (sales.qtysold != stagesales.qtysold
or sales.pricepaid != stagesales.pricepaid);
-- Delete matching rows from the staging table
-- using an inner join with the target table
delete from stagesales
using sales
where sales.salesid = stagesales.salesid
and sales.listid = stagesales.listid;
-- Insert the remaining rows from the staging table into the target table
insert into sales
select * from stagesales;
-- End transaction and commit
end transaction;
-- Drop the staging table
drop table stagesales;
```