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.

# Convertir la fonctionnalité temporelle Teradata NORMALIZE en Amazon Redshift SQL
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql"></a>

*Po Hong, Amazon Web Services*

## Résumé
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-summary"></a>

**NORMALIZE** est une extension Teradata de la norme ANSI SQL. Lorsqu'une table SQL inclut une colonne contenant un type de données **PERIOD**, **NORMALIZE** combine les valeurs qui se rejoignent ou se chevauchent dans cette colonne pour former une période unique qui consolide plusieurs valeurs de période individuelles. Pour utiliser **NORMALIZE**, au moins une colonne de la liste SQL **SELECT** doit être du type de données temporelles **PERIOD** de Teradata. Pour plus d'informations sur **NORMALIZE**, consultez la [documentation Teradata](https://docs.teradata.com/reader/2_MC9vCtAJRlKle2Rpb0mA/MIGI5UMEwgERC3Un7tEZ6g). 

Amazon Redshift ne prend pas en charge **NORMALIZE**, mais vous pouvez implémenter cette fonctionnalité en utilisant la syntaxe SQL native et la fonction de fenêtre **LAG** dans Amazon Redshift. Ce modèle se concentre sur l'utilisation de l'extension Teradata **NORMALIZE** avec la condition **ON MEETS OR OVERLAPS**, qui est le format le plus courant. Il explique comment cette fonctionnalité fonctionne dans Teradata et comment elle peut être convertie en syntaxe SQL native Amazon Redshift.

## Conditions préalables et limitations
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-prereqs"></a>

**Conditions préalables**
+ Connaissances et expérience de base de Teradata SQL
+ Connaissances et expérience d'Amazon Redshift

## Architecture
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-architecture"></a>

**Pile technologique source**
+ Entrepôt de données Teradata

**Pile technologique cible**
+ Amazon Redshift

**Architecture cible**

Pour une architecture de haut niveau permettant de migrer une base de données Teradata vers Amazon Redshift, consultez le [modèle Migrer une base de données Teradata vers Amazon Redshift à l'aide des agents d'extraction de données AWS SCT](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-teradata-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.html). La migration ne convertit pas automatiquement la phrase Teradata **NORMALIZE** en Amazon Redshift SQL. Vous pouvez convertir cette extension Teradata en suivant les instructions de ce modèle.

## Outils
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-tools"></a>

**Code**

Pour illustrer le concept et les fonctionnalités de **NORMALIZE**, considérez la définition de table suivante dans Teradata :

```
CREATE TABLE systest.project
     (    emp_id        INTEGER,
          project_name  VARCHAR(20),
          dept_id       INTEGER,
          duration      PERIOD(DATE)
     );
```

Exécutez le code SQL suivant pour insérer des exemples de données dans la table :

```
BEGIN TRANSACTION;

INSERT INTO systest.project VALUES (10, 'First Phase', 1000,  PERIOD(DATE '2010-01-10', DATE '2010-03-20') );
INSERT INTO systest.project VALUES (10, 'First Phase', 2000,  PERIOD(DATE '2010-03-20', DATE '2010-07-15') );

INSERT INTO systest.project VALUES (10, 'Second Phase', 2000,  PERIOD(DATE '2010-06-15', DATE '2010-08-18') );
INSERT INTO systest.project VALUES (20, 'First Phase', 2000,  PERIOD(DATE '2010-03-10', DATE '2010-07-20') );

INSERT INTO systest.project VALUES (20, 'Second Phase', 1000,  PERIOD(DATE '2020-05-10', DATE '2020-09-20') );

END TRANSACTION;
```

Résultats :

```
select * from systest.project order by 1,2,3;
 
 *** Query completed. 4 rows found. 4 columns returned.
 *** Total elapsed time was 1 second.
 
     emp_id  project_name              dept_id  duration
-----------  --------------------  -----------  ------------------------
         10  First Phase                  1000  ('10/01/10', '10/03/20')        
         10  First Phase                  2000  ('10/03/20', '10/07/15')
         10  Second Phase                 2000  ('10/06/15', '10/08/18')
         20  First Phase                  2000  ('10/03/10', '10/07/20')
         20  Second Phase                 1000  ('20/05/10', '20/09/20')
```

*Cas d'utilisation de Teradata NORMALIZE*

Ajoutez maintenant la clause SQL Teradata **NORMALIZE** à l'instruction **SELECT** :

```
SELECT NORMALIZE ON MEETS OR OVERLAPS emp_id, duration 
FROM systest.project 
ORDER BY 1,2;
```

Cette opération **NORMALIZE** est effectuée sur une seule colonne (`emp_id`). En effet`emp_id=10`, les trois valeurs de période qui se chevauchent en termes de durée fusionnent en une seule valeur de période, comme suit :  

```
     emp_id  duration
-----------  ------------------------
         10  ('10/01/10', '10/08/18')
         20  ('10/03/10', '10/07/20')
         20  ('20/05/10', '20/09/20')
```

L'instruction **SELECT** suivante exécute une opération **NORMALIZE** sur `project_name` et`dept_id`. Notez que la liste **SELECT** ne contient qu'une seule colonne **PERIOD**,`duration`.

```
SELECT NORMALIZE project_name, dept_id, duration 
FROM systest.project;
```

Sortie :

```
project_name              dept_id  duration
--------------------  -----------  ------------------------
First Phase                  1000  ('10/01/10', '10/03/20')
Second Phase                 1000  ('20/05/10', '20/09/20')
First Phase                  2000  ('10/03/10', '10/07/20')
Second Phase                 2000  ('10/06/15', '10/08/18')
```

*SQL équivalent à Amazon Redshift*

Amazon Redshift ne prend actuellement pas en charge le type de données **PERIOD** dans une table. Vous devez plutôt diviser un champ de données Teradata **PERIOD** en deux parties :`start_date, end_date`, comme suit :  

```
CREATE TABLE systest.project
     (    emp_id        INTEGER,
          project_name  VARCHAR(20),
          dept_id       INTEGER,
          start_date  DATE,
          end_date    DATE
     );
```

Insérez des exemples de données dans le tableau :

```
BEGIN TRANSACTION;
 
INSERT INTO systest.project VALUES (10, 'First Phase', 1000,  DATE '2010-01-10', DATE '2010-03-20' );
INSERT INTO systest.project VALUES (10, 'First Phase', 2000,  DATE '2010-03-20', DATE '2010-07-15');
 
INSERT INTO systest.project VALUES (10, 'Second Phase', 2000,  DATE '2010-06-15', DATE '2010-08-18' );
INSERT INTO systest.project VALUES (20, 'First Phase', 2000,  DATE '2010-03-10', DATE '2010-07-20' );
 
INSERT INTO systest.project VALUES (20, 'Second Phase', 1000,  DATE '2020-05-10', DATE '2020-09-20' );
 
END TRANSACTION;
```

Sortie :

```
 emp_id | project_name | dept_id | start_date |  end_date
--------+--------------+---------+------------+------------
     10 | First Phase  |    1000 | 2010-01-10 | 2010-03-20
     10 | First Phase  |    2000 | 2010-03-20 | 2010-07-15
     10 | Second Phase |    2000 | 2010-06-15 | 2010-08-18
     20 | First Phase  |    2000 | 2010-03-10 | 2010-07-20
     20 | Second Phase |    1000 | 2020-05-10 | 2020-09-20
(5 rows)
```

Pour réécrire la clause **NORMALIZE** de Teradata, vous pouvez utiliser la [fonction de fenêtre LAG dans Amazon](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LAG.html) Redshift. Cette fonction renvoie les valeurs d'une ligne à un décalage donné au-dessus (avant) de la ligne actuelle de la partition.

Vous pouvez utiliser la fonction **LAG** pour identifier chaque ligne qui commence une nouvelle période en déterminant si une période correspond ou chevauche la période précédente (0 dans l'affirmative et 1 dans le cas contraire). Lorsque cet indicateur est additionné de manière cumulative, il fournit un identifiant de groupe qui peut être utilisé dans la clause externe **Group By** pour obtenir le résultat souhaité dans Amazon Redshift.  

Voici un exemple d'instruction SQL Amazon Redshift qui utilise **LAG ()** :

```
SELECT emp_id, start_date, end_date, 
            (CASE WHEN start_date <= LAG(end_date) OVER (PARTITION BY emp_id ORDER BY start_date, end_date) THEN 0 ELSE 1 END) AS GroupStartFlag
FROM systest.project 
ORDER BY 1,2;
```

Sortie :

```
 emp_id | start_date |  end_date  | groupstartflag
--------+------------+------------+----------------
     10 | 2010-01-10 | 2010-03-20 |              1
     10 | 2010-03-20 | 2010-07-15 |              0
     10 | 2010-06-15 | 2010-08-18 |              0
     20 | 2010-03-10 | 2010-07-20 |              1
     20 | 2020-05-10 | 2020-09-20 |              1
(5 rows)
```

L'instruction SQL Amazon Redshift suivante se normalise uniquement sur la colonne : `emp_id`

```
SELECT T2.emp_id, MIN(T2.start_date) as new_start_date, MAX(T2.end_date) as new_end_date
FROM 
( SELECT T1.*, SUM(GroupStartFlag) OVER (PARTITION BY emp_id ORDER BY start_date ROWS UNBOUNDED PRECEDING) As GroupID
FROM ( SELECT emp_id, start_date, end_date, 
            (CASE WHEN start_date <= LAG(end_date) OVER (PARTITION BY emp_id ORDER BY start_date, end_date) THEN 0 ELSE 1 END) AS GroupStartFlag
FROM systest.project ) T1
) T2
GROUP BY T2.emp_id, T2.GroupID
ORDER BY 1,2;
```

Sortie :  

```
 emp_id | new_start_date | new_end_date
--------+----------------+------------------------------------
     10 | 2010-01-10     | 2010-08-18
     20 | 2010-03-10     | 2010-07-20
     20 | 2020-05-10     | 2020-09-20
(3 rows)
```

** **

L'instruction SQL Amazon Redshift suivante est normalisée sur les colonnes et : `project_name` `dept_id`

```
SELECT T2.project_name, T2.dept_id, MIN(T2.start_date) as new_start_date, MAX(T2.end_date) as new_end_date
FROM 
( SELECT T1.*, SUM(GroupStartFlag) OVER (PARTITION BY project_name, dept_id ORDER BY start_date ROWS UNBOUNDED PRECEDING) As GroupID
FROM ( SELECT project_name, dept_id, start_date, end_date, 
            (CASE WHEN start_date <= LAG(end_date) OVER (PARTITION BY project_name, dept_id ORDER BY start_date, end_date) THEN 0 ELSE 1 END) AS GroupStartFlag
FROM systest.project ) T1
) T2
GROUP BY T2.project_name, T2.dept_id, T2.GroupID
ORDER BY 1,2,3;
```

Sortie :

```
 project_name | dept_id | new_start_date | new_end_date
--------------+---------+----------------+--------------
 First Phase  |    1000 | 2010-01-10     | 2010-03-20
 First Phase  |    2000 | 2010-03-10     | 2010-07-20
 Second Phase |    1000 | 2020-05-10     | 2020-09-20
 Second Phase |    2000 | 2010-06-15     | 2010-08-18
(4 rows)
```

## Épopées
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-epics"></a>

### Convertir NORMALIZE en Amazon Redshift SQL
<a name="convert-normalize-to-amazon-redshift-sql"></a>


| Sous-tâche | Description | Compétences requises | 
| --- | --- | --- | 
| Créez votre code Teradata SQL. | Utilisez la phrase NORMALIZE en fonction de vos besoins. | SQL Developer | 
| Convertissez le code en Amazon Redshift SQL. | Pour convertir votre code, suivez les instructions de la section « Outils » de ce modèle. | SQL Developer | 
| Exécutez le code dans Amazon Redshift. | Créez votre table, chargez des données dans la table et exécutez votre code dans Amazon Redshift. | SQL Developer | 

## Ressources connexes
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-resources"></a>

**Références**
+ [Fonctionnalité temporelle Teradata NORMALIZE](https://docs.teradata.com/reader/2_MC9vCtAJRlKle2Rpb0mA/MIGI5UMEwgERC3Un7tEZ6g) (documentation Teradata)
+ [Fonction de fenêtre LAG](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LAG.html) (documentation Amazon Redshift)
+ [Migrer vers Amazon Redshift (site](https://aws.amazon.com/redshift/data-warehouse-migration/) Web AWS)
+ [Migrer une base de données Teradata vers Amazon Redshift à l'aide des agents d'extraction de données AWS SCT](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-teradata-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.html) (AWS Prescriptive Guidance)
+ [Convertir la fonctionnalité Teradata RESET WHEN en Amazon Redshift](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.html) SQL (AWS Prescriptive Guidance)

**Outils**
+ [Outil de conversion de schéma AWS (AWS SCT)](https://aws.amazon.com/dms/schema-conversion-tool/)

**Partenaires**
+ [AWS Migration Competency Partners](https://aws.amazon.com/migration/partner-solutions/#delivery)