As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Converta o atributo temporal Teradata NORMALIZE em Amazon Redshift SQL
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql"></a>

*Po Hong, Amazon Web Services*

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

**NORMALIZE** é uma extensão Teradata do padrão ANSI SQL. Quando uma tabela SQL inclui uma coluna que tem um tipo de dados **PERIOD**, **NORMALIZE** combina valores que se encontram ou se sobrepõem nessa coluna para formar um único período que consolida vários valores de períodos individuais. Para usar **NORMALIZE**, pelo menos uma coluna na lista SQL **SELECT** deve ser do tipo de dados **PERIOD** temporal do Teradata. Para obter mais informações sobre **NORMALIZE**, consulte a [Documentação do Teradata](https://docs.teradata.com/reader/2_MC9vCtAJRlKle2Rpb0mA/MIGI5UMEwgERC3Un7tEZ6g). 

O Amazon Redshift não é compatível com **NORMALIZE**, mas você pode implementar essa funcionalidade usando a sintaxe SQL nativa e a função de janela **LAG** no Amazon Redshift. Esse padrão se concentra no uso da extensão **NORMALIZE** do Teradata com a condição **ON MEETS OR OVERLAPS**, que é o formato mais popular. Ele explica como esse atributo funciona no Teradata e como ele pode ser convertido na sintaxe SQL nativa do Amazon Redshift.

## Pré-requisitos e limitações
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-prereqs"></a>

**Pré-requisitos **
+ Conhecimento e experiência básicos em Teradata SQL
+ Conhecimento e experiência no Amazon Redshift

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

**Pilha de tecnologia de origem**
+ Data warehouse Teradata

**Pilha de tecnologias de destino**
+ banco de dados de origem

**Arquitetura de destino**

Para obter uma arquitetura de alto nível para migrar um banco de dados Teradata para o Amazon Redshift, consulte o padrão [Migrar um banco de dados Teradata para o Amazon Redshift usando agentes de extração de dados da 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). A migração não converte automaticamente a frase **NORMALIZE** do Teradata para SQL do Amazon Redshift. Você pode converter essa extensão do Teradata seguindo as diretrizes nesse padrão.

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

**Código **

Para ilustrar o conceito e a funcionalidade do **NORMALIZE**, considere a seguinte definição de tabela no Teradata:

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

Execute o código SQL a seguir para inserir dados de exemplo na tabela:

```
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 do Teradata NORMALIZE*

Agora, adicione a cláusula Teradata **NORMALIZE** SQL à instrução **SELECT**:

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

Essa operação **NORMALIZE** é executada em uma única coluna (`emp_id`). Pois`emp_id=10`, os três valores de período sobrepostos em duração se aglutinam em um único valor de período, da seguinte forma:  

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

A instrução **SELECT** a seguir executa uma operação **`project_name`NORMALIZE** em e. `dept_id` Observe que a lista **SELECT** contém somente uma coluna **PERIOD**,`duration`.

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

Saída:

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

No momento, o Amazon Redshift não oferece suporte ao tipo de dados **PERIOD** em uma tabela. Em vez disso, você precisa dividir um campo de dados do Teradata **PERIOD** em duas partes:`start_date, end_date`, da seguinte forma:  

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

Insira os dados de amostra na tabela:

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

Saída:

```
 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 reescrever a cláusula **NORMALIZE** do Teradata, você pode usar a [função de janela LAG](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LAG.html) no Amazon Redshift. Esta função retorna os valores para uma linha em determinado deslocamento acima (antes) da linha atual na partição.

Você pode usar a função **LAG** para identificar cada linha que inicia um novo período determinando se um período atende ou se sobrepõe ao período anterior (0 se sim e 1 se não). Quando esse sinalizador é resumido cumulativamente, ele fornece um identificador de grupo que pode ser usado na cláusula externa **Group By** para chegar ao resultado desejado no Amazon Redshift.  

Aqui está um exemplo de instrução SQL do Amazon Redshift que usa **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;
```

Saída:

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

A seguinte instrução SQL do Amazon Redshift se normaliza somente na coluna: `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;
```

Saída:  

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

** **

A seguinte instrução SQL do Amazon Redshift se normaliza nas colunas e: `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;
```

Saída:

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

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

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


| Tarefa | Description | Habilidades necessárias | 
| --- | --- | --- | 
| Crie o seu código SQL do Teradata. | Use a frase NORMALIZE de acordo com as suas necessidades. | SQL Developer | 
| Converter o código para Amazon Redshift SQL. | Para converter seu código, siga as diretrizes na seção “Ferramentas” desse padrão. | SQL Developer | 
| Executar o código no Amazon Redshift. | Crie sua tabela, carregue dados na tabela e execute seu código no Amazon Redshift. | SQL Developer | 

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

**Referências**
+ [Atributo temporal do Teradata NORMALIZE](https://docs.teradata.com/reader/2_MC9vCtAJRlKle2Rpb0mA/MIGI5UMEwgERC3Un7tEZ6g) (documentação do Teradata)
+ [Função de janela LAG](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LAG.html) (documentação do Amazon Redshift)
+ [Migre para o Amazon Redshift](https://aws.amazon.com/redshift/data-warehouse-migration/) (site da AWS)
+ [Migre um banco de dados Teradata para o Amazon Redshift usando agentes de extração de dados da 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) (Recomendações da AWS)
+ [Converta o atributo Teradata RESET WHEN para o Amazon Redshift SQL](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.html) (Recomendações da AWS)

**Ferramentas**
+ [AWS Schema Conversion Tool (AWS SCT)](https://aws.amazon.com/dms/schema-conversion-tool/)

**Parceiros**
+ [Parceiros de competência em migração da AWS](https://aws.amazon.com/migration/partner-solutions/#delivery)