Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Convierta la característica temporal NORMALIZE de Teradata en Amazon Redshift SQL
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql"></a>

*Po Hong, Amazon Web Services*

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

**NORMALIZE** es una extensión de Teradata del estándar ANSI SQL. Cuando una tabla SQL incluye una columna que tiene un tipo de datos tipo **PERIOD**, **NORMALIZE** combina los valores que coinciden o se superponen en esa columna para formar un período único que consolida varios valores de períodos individuales. Para utilizar **NORMALIZE**, al menos una columna de la lista SQL **SELECT** debe ser del tipo de datos **PERIOD** temporal de Teradata. Para obtener más información sobre **NORMALIZE**, consulte la [documentación de Teradata](https://docs.teradata.com/reader/2_MC9vCtAJRlKle2Rpb0mA/MIGI5UMEwgERC3Un7tEZ6g). 

Amazon Redshift no admite **NORMALIZE**, pero puede implementar esta funcionalidad mediante la sintaxis SQL nativa y la función de ventana **LAG** en Amazon Redshift. Este patrón se centra en el uso de la extensión **NORMALIZE** de Teradata con la condición **ON MEETS OR OVERLAPS**, que es el formato más popular. En él se explica cómo funciona esta función en Teradata y cómo se puede convertir a la sintaxis SQL nativa de Amazon Redshift.

## Requisitos previos y limitaciones
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-prereqs"></a>

**Requisitos previos **
+ Conocimientos y experiencia básicos de Teradata SQL
+ Conocimiento y experiencia en Amazon Redshift

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

**Pila de tecnología de origen**
+ Almacenamiento de datos de Teradata

**Pila de tecnología de destino**
+ Amazon Redshift

**Arquitectura de destino**

Para obtener una arquitectura de alto nivel para migrar una base de datos de Teradata a Amazon Redshift, consulte el patrón [Migración de una base de datos de Teradata a Amazon Redshift mediante agentes de extracción de datos SCT de AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-teradata-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.html). La migración no convierte automáticamente la frase **NORMALIZE** de Teradata en Amazon Redshift SQL. Puede convertir esta extensión de Teradata siguiendo las pautas de este patrón.

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

**Código**

Para ilustrar el concepto y la funcionalidad de **NORMALIZE**, considere la siguiente definición de tabla en Teradata:

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

Ejecute el siguiente código SQL para insertar datos de ejemplo en la tabla:

```
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;
```

Resultados:

```
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')
```

*Caso de uso de Teradata NORMALIZE*

Ahora añada la cláusula SQL **NORMALIZE** de Teradata a la sentencia **SELECT:**:

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

Esta operación **NORMALIZE** se realiza en una sola columna (`emp_id`). En este `emp_id=10` caso, los tres valores de período superpuestos en cuanto a la duración se fusionan en un único valor de período, de la siguiente manera:  

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

La siguiente instrucción **SELECT** realiza una operación **NORMALIZE** en `project_name` y. `dept_id` Tenga en cuenta que la lista **SELECT** contiene solo una columna **PERIOD**,`duration`.

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

Salida:

```
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 equivalente a Amazon Redshift*

Amazon Redshift actualmente no admite el tipo de datos **PERIOD** en una tabla. En su lugar, debe dividir un campo de datos **PERIOD** de Teradata en dos partes:`start_date, end_date`, de la siguiente manera:  

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

Inserte una fila de datos en la tabla:

```
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;
```

Salida:

```
 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)
```

Para reescribir la cláusula **NORMALIZE** de Teradata, puede utilizar la [función de ventana LAG de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LAG.html). Esta función devuelve los valores para una fila en un desplazamiento dado arriba (antes) de la fila actual en la partición.

Puede usar la función **LAG** para identificar cada fila que comienza un nuevo período determinando si un período coincide o se superpone con el período anterior (0 en caso afirmativo y 1 en caso negativo). Cuando este indicador se suma de forma acumulativa, proporciona un identificador de grupo que se puede utilizar en la cláusula externa **Group By** para obtener el resultado deseado en Amazon Redshift.  

A continuación, se muestra un ejemplo de sentencia SQL de Amazon Redshift que utiliza **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;
```

Salida:

```
 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)
```

La siguiente sentencia SQL de Amazon Redshift solo se normaliza en la columna: `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;
```

Salida:  

```
 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)
```

** **

La siguiente sentencia SQL de Amazon Redshift se normaliza en las columnas y: `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;
```

Salida:

```
 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)
```

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

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


| Tarea | Descripción | Habilidades requeridas | 
| --- | --- | --- | 
| Cree código SQL en Teradata. | Use la frase NORMALIZE en función de sus necesidades. | Desarrollador SQL | 
| Convierta el código a Amazon Redshift SQL. | Para convertir el código, siga las instrucciones de la sección «Herramientas» de este patrón. | Desarrollador SQL | 
| Ejecute el código en Amazon Redshift. | Cree la tabla, cargue los datos en la tabla y ejecute el código en Amazon Redshift. | Desarrollador SQL | 

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

**Referencias**
+ [Característica temporal NORMALIZE de Teradata](https://docs.teradata.com/reader/2_MC9vCtAJRlKle2Rpb0mA/MIGI5UMEwgERC3Un7tEZ6g) (documentación de Teradata)
+ [Función de ventana LAG](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LAG.html) (documentación de Amazon Redshift)
+ [Migración a Amazon Redshift](https://aws.amazon.com/redshift/data-warehouse-migration/) (sitio web de AWS)
+ [Migración de una base de datos de Teradata a Amazon Redshift con los agentes de extracción de datos de 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) (Recomendaciones de AWS)
+ [Convertir la característica RESET WHEN de Teradata a Amazon Redshift SQL](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.html) (Recomendaciones de AWS)

**Herramientas**
+ [Herramienta de conversión de esquemas de AWS (AWS SCT)](https://aws.amazon.com/dms/schema-conversion-tool/)

**Socios**
+ [Socios con competencias en migración de AWS](https://aws.amazon.com/migration/partner-solutions/#delivery)