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.

# Aufheben der Verschachtelung von Schemata
<a name="zero-etl-ddb-schema-unnesting"></a>

 Bei der Integration mit Analysediensten über Zero-ETL können Sie wählen, wie verschachtelte Strukturen in den Zieltabellen dargestellt werden. AWS Glue Zero-ETL bietet Optionen zum Entfernen von Schemaverschachtelungen, um komplexe Datenstrukturen in analysefreundlichere Formate zu reduzieren. 

## Optionen zum Aufheben der Verschachtelung
<a name="unnesting-options"></a>

 Wenn Sie eine Null-ETL-Integration mit einer Quelle erstellen, können Sie aus den folgenden Optionen zum Aufheben von Verschachtelungen wählen. Diese Optionen entsprechen bestimmten Aufzählungswerten, die Sie beim Aufrufen der API verwenden werden. CreateIntegrationTableProperty Bei allen Optionen ohne Verschachtelung würden wir die meisten inneren Ebenen durchqueren und den DDB-Typ nach besten Kräften dem spark/iceberg primitiven Zieltyp zuordnen. Die Typzuordnung zwischen Quell-DDB und Zieltabelle sieht wie folgt aus: 


| DDB-Quelldatentyp | Datentyp der Zieltabelle | 
| --- | --- | 
| "S" | StringType | 
| "B" | BinaryType | 
| "N" | DoubleType | 
| "BOOL" | BooleanType | 
| "SS" | ArrayType(StringType) | 
| "NS" | ArrayType(DoubleType) | 
| "BS" | ArrayType(BinaryType) | 
| "L" | ArrayType(StringType) | 
| "NULL" | Ignore | 
| "M" | StructType (OBEN/SUBSTANTIV) | 

Kein Aufheben der Verschachtelung — NO\_UNNEST  
 **API-Wert: `NO_UNNEST`**   
 Behält die ursprüngliche verschachtelte Struktur der Amazon DynamoDB DynamoDB-Elemente bei. Zuordnungen und Listen werden als strukturierte Spalten im Ziel gespeichert.   
 Ideal für: Beibehaltung der exakten Struktur Ihrer Amazon DynamoDB DynamoDB-Daten, wenn Ihre Analysetools mit verschachtelten Daten arbeiten können. 

Oberste Ebene — TOP\_LEVEL  
 **API-Wert: `TOP_LEVEL`**   
 Reduziert die oberste Ebene verschachtelter Zuordnungen in einzelne Spalten. Listenstrukturen bleiben verschachtelt.   
 Behält die exakte Struktur Ihrer Amazon DynamoDB DynamoDB-Daten bei, wenn Ihre Analysetools mit verschachtelten Daten arbeiten können, bei denen alle Informationen vom Typ DDB entfernt wurden.   
 Ideal für: Balance zwischen Erhaltung der Datenstruktur und Einfachheit der Abfrage, wenn Ihre Amazon DynamoDB-Tabellenelemente über ein konsistentes Schema verfügen. 

Alle Ebenen aufheben — FULL (Standard)  
 **API-Wert: `FULL`**   
 Reduziert alle verschachtelten Strukturen (Zuordnungen und Listen) rekursiv in einzelne Spalten mit Punktnotation für die Benennung.   
 Ideal für: Maximierung der Einfachheit von Abfragen bei der Arbeit mit tief verschachtelten Strukturen und Analytiktools, die flache Schemata bevorzugen.   
 Eine vollständige Aufhebung der Verschachtelung kann zu sehr breiten Tabellen mit vielen Spalten führen, wenn Ihre DynamoDB-Daten variable oder tief verschachtelte Strukturen aufweisen. 

**Example Verwenden von Optionen zum Aufheben von Verschachtelungen in der API**  
 Wenn Sie Schema-Unnesting über die CreateIntegrationTableProperty API konfigurieren, geben Sie die Option zum Entfernen von Verschachtelungen im Parameter an: UnnestSpec   

```
aws glue create-integration-table-property 
  --resource-arn "arn:aws:glue:us-east-1:123456789012:database/my_db" 
  --table-name "my-table" 
  --cli-input-json '{
      "TargetTableConfig": {
          "UnnestSpec": "FULL",
          "TargetTableName": "my-target-table",
      }
  }'
```

## Beispiele für das Aufheben von Verschachtelungen
<a name="unnesting-examples"></a>

 Stellen Sie sich ein DynamoDB-Element mit der folgenden Struktur vor: 

```
// Input DynamoDB Record
{
  "Item": {
    "col_1": {
      "S": "value_1"
    },
    "col_2": {
      "M": {
        "col_3": {
          "M": {
            "id": {
              "S": "value_3"
            }
          }
        },
        "col_4": {
          "BOOL": true
        }
      }
    }
  }
}
```

### Beispiel für NO\_UNNEST
<a name="no-unnesting-example"></a>

 Bei NO\_UNNEST wird die gesamte Zeile in einer Spalte plus dem Primärschlüssel gespeichert. DynamoDB-Typinformationen werden beibehalten. Dadurch wird die Kompatibilität mit Redshift-Abfragemustern aufrechterhalten. 

Resultierende Iceberg-Tabelle (vorausgesetzt, col\_1 ist der Primärschlüssel):


| col\_1 (Zeichenfolge) | Wert (Struktur) | 
| --- | --- | 
| Wert\_1 | <pre>{<br />  "col_2": {<br />    "M": {<br />      "col_3": {<br />        "M": {<br />          "id": {<br />            "S": "value_3"<br />          }<br />        }<br />      },<br />      "col_4": {<br />        "BOOL": true<br />      }<br />    }<br />  }<br />}</pre> | 

Abfragen müssten Struktur- und Array-Zugriffsmuster verwenden:

```
SELECT 
  value.col_1,
  value.col_2.M.col_3.M.id.S,
  value.col_2.M.col_4.BOOL
FROM product_table;
```

### TOP\_LEVEL-Beispiel
<a name="unnest-one-level-example"></a>

 Bei TOP\_LEVEL sind nur die Felder der obersten Ebene nicht verschachtelt, während die verschachtelten Felder als Strukturen erhalten bleiben. DynamoDB-Typinformationen werden entfernt und die Typisierung wird beibehalten. Konvertiert in einen Zeichenfolgentyp, wenn Schemakonflikte auftreten. 

Resultierende Glue-Tabelle nach der Replikation:


| col\_1 (Zeichenfolge) | col\_2 (Struktur) | 
| --- | --- | 
| Wert\_1 | <pre>{<br />  "col_3": {<br />    "id": "value_3"<br />  },<br />  "col_4": true<br />}</pre> | 

Abfragen würden für die erste Ebene vereinfacht:

```
SELECT 
  col_1, 
  col_2.col_3.id,
  col_2.col_4
FROM product_table;
```

### VOLLSTÄNDIGES Beispiel
<a name="unnest-all-levels-example"></a>

 Wenn FULL die Verschachtelung aufhebt, werden sowohl Felder der obersten Ebene als auch struct/map verschachtelte Felder reduziert. Die Punktnotation wird für verschachtelte Felder verwendet (z. B. „col\_2.col\_3.id“). Array-Elemente bleiben nicht verschachtelt. Jeder Blattknoten wird zu einer Spalte der obersten Ebene. 

Resultierende Glue-Tabelle nach der Replikation:


| col\_1 (Zeichenfolge) | col\_2.col\_3.id (Zeichenfolge) | col\_2.col\_4 (boolescher Wert) | 
| --- | --- | --- | 
| Wert\_1 | Wert\_3 | TRUE | 

Abfragen würden vollständig vereinfacht:

```
SELECT 
  col_1, 
  "col_2.col_3.id",
  "col_2.col_4"
FROM product_table;
```