Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Konvertieren Sie die temporale Funktion Teradata NORMALIZE in Amazon Redshift SQL
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql"></a>

*Po Hong, Amazon Web Services*

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

**NORMALIZE** ist eine Teradata-Erweiterung des ANSI SQL-Standards. **Wenn eine SQL-Tabelle eine Spalte mit dem Datentyp PERIOD enthält, kombiniert **NORMALIZE** Werte, die sich in dieser Spalte treffen oder sich überschneiden, zu einer einzigen Periode, die mehrere einzelne Periodenwerte konsolidiert.** Um **NORMALIZE** verwenden zu können, muss mindestens eine Spalte in der SQL **SELECT-Liste** den temporalen **PERID-Datentyp** von Teradata haben. Weitere Informationen zu **NORMALIZE** finden Sie in der [Teradata-Dokumentation](https://docs.teradata.com/reader/2_MC9vCtAJRlKle2Rpb0mA/MIGI5UMEwgERC3Un7tEZ6g). 

Amazon Redshift unterstützt **NORMALIZE** nicht, aber Sie können diese Funktionalität mithilfe der systemeigenen SQL-Syntax und der **LAG-Fensterfunktion** in Amazon Redshift implementieren. Dieses Muster konzentriert sich auf die Verwendung der Teradata **NORMALIZE-Erweiterung** mit der Bedingung **ON MEETS OR OVERLAPS**, dem beliebtesten Format. Es erklärt, wie diese Funktion in Teradata funktioniert und wie sie in die native SQL-Syntax von Amazon Redshift konvertiert werden kann.

## Voraussetzungen und Einschränkungen
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-prereqs"></a>

**Voraussetzungen**
+ Grundkenntnisse und Erfahrung mit Teradata SQL
+ Wissen und Erfahrung mit Amazon Redshift

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

**Quelltechnologie-Stack**
+ Teradata-Datawarehouse

**Zieltechnologie-Stack**
+ Amazon Redshift

**Zielarchitektur**

Eine allgemeine Architektur für die Migration einer Teradata-Datenbank zu Amazon Redshift finden Sie im Muster [Migrieren einer Teradata-Datenbank zu Amazon Redshift mithilfe von AWS SCT-Datenextraktionsagenten](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-teradata-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.html). Die Migration konvertiert die Teradata **NORMALIZE-Phrase** nicht automatisch in Amazon Redshift SQL. Sie können diese Teradata-Erweiterung konvertieren, indem Sie die Richtlinien in diesem Muster befolgen.

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

**Code**

Sehen Sie sich die folgende Tabellendefinition in Teradata an, um das Konzept und die Funktionalität von **NORMALIZE** zu veranschaulichen:

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

Führen Sie den folgenden SQL-Code aus, um Beispieldaten in die Tabelle einzufügen:

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

Ergebnisse:

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

*Anwendungsfall Teradata NORMALIZE*

**Fügen Sie nun die Teradata **NORMALIZE** SQL-Klausel zur SELECT-Anweisung hinzu:**

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

Diese **NORMALIZE-Operation** wird für eine einzelne Spalte () `emp_id` ausgeführt. Denn `emp_id=10` die drei sich überschneidenden Periodenwerte in Bezug auf die Dauer verschmelzen wie folgt zu einem einzigen Periodenwert:  

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

Die folgende **SELECT-Anweisung** führt eine **NORMALIZE-Operation** für und aus. `project_name` `dept_id` Beachten Sie, dass die **SELECT-Liste** nur eine **PERIOD-Spalte** enthält,`duration`.

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

Ausgabe:

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

Amazon Redshift unterstützt derzeit den **PERIOD-Datentyp** in einer Tabelle nicht. Stattdessen müssen Sie ein Teradata **PERIOD-Datenfeld** wie folgt in zwei Teile unterteilen: `start_date, end_date`  

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

Fügen Sie Beispieldaten in die Tabelle ein:

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

Ausgabe:

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

Um die **NORMALIZE-Klausel** von Teradata neu zu schreiben, können Sie die [LAG-Fensterfunktion](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LAG.html) in Amazon Redshift verwenden. Diese Funktion gibt die Werte für eine Zeile mit einem bestimmten Offset über (vor) der aktuellen Zeile in der Partition zurück.

Sie können die **LAG-Funktion** verwenden, um jede Zeile zu identifizieren, mit der eine neue Periode beginnt, indem Sie ermitteln, ob eine Periode mit der vorherigen Periode übereinstimmt oder sich mit ihr überschneidet (0, wenn ja und 1, wenn nein). Wenn dieses Flag kumulativ zusammengefasst wird, stellt es eine Gruppen-ID bereit, die in der äußeren **Group** By-Klausel verwendet werden kann, um das gewünschte Ergebnis in Amazon Redshift zu erzielen.  

Hier ist ein Beispiel für eine Amazon Redshift SQL-Anweisung, die **LAG ()** verwendet:

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

Ausgabe:

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

Die folgende Amazon Redshift SQL-Anweisung normalisiert nur die Spalte: `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;
```

Ausgabe:  

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

** **

Die folgende Amazon Redshift SQL-Anweisung normalisiert sowohl die Spalten als `project_name` auch`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;
```

Ausgabe:

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

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

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


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Erstellen Sie Ihren Teradata SQL-Code. | Verwenden Sie die NORMALIZE-Phrase entsprechend Ihren Bedürfnissen. | SQL Developer | 
| Konvertieren Sie den Code in Amazon Redshift SQL. | Folgen Sie den Richtlinien im Abschnitt „Tools“ dieses Musters, um Ihren Code zu konvertieren. | SQL Developer | 
| Führen Sie den Code in Amazon Redshift aus. | Erstellen Sie Ihre Tabelle, laden Sie Daten in die Tabelle und führen Sie Ihren Code in Amazon Redshift aus. | SQL Developer | 

## Zugehörige Ressourcen
<a name="convert-the-teradata-normalize-temporal-feature-to-amazon-redshift-sql-resources"></a>

**Referenzen**
+ [Temporale Funktion „Teradata NORMALIZE“](https://docs.teradata.com/reader/2_MC9vCtAJRlKle2Rpb0mA/MIGI5UMEwgERC3Un7tEZ6g) (Teradata-Dokumentation)
+ [LAG-Fensterfunktion](https://docs.aws.amazon.com/redshift/latest/dg/r_WF_LAG.html) (Amazon Redshift Redshift-Dokumentation)
+ [Zu Amazon Redshift migrieren](https://aws.amazon.com/redshift/data-warehouse-migration/) (AWS-Website)
+ [Migrieren Sie eine Teradata-Datenbank mithilfe von AWS SCT-Datenextraktionsagenten zu Amazon Redshift (AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-a-teradata-database-to-amazon-redshift-using-aws-sct-data-extraction-agents.html) Prescriptive Guidance)
+ [Konvertieren Sie die Teradata RESET WHEN-Funktion auf Amazon Redshift SQL](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/convert-the-teradata-reset-when-feature-to-amazon-redshift-sql.html) (AWS Prescriptive Guidance)

**Tools**
+ [AWS-Schemakonvertierungstool (AWS SCT)](https://aws.amazon.com/dms/schema-conversion-tool/)

**Partner**
+ [AWS-Kompetenzpartner für Migration](https://aws.amazon.com/migration/partner-solutions/#delivery)