

 Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

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.

# SQL-Befehle
<a name="iceberg-writes-sql-syntax"></a>

Apache Iceberg-Tabellen in Amazon Redshift bieten eine leistungsstarke Möglichkeit, große analytische Datensätze in Ihrem Data Lake zu verwalten. Diese Tabellen unterstützen ACID-Transaktionen, Schemaentwicklung und Zeitreisefähigkeiten und bieten gleichzeitig eine hohe Leistung für Analyse-Workloads. Mithilfe von Apache Iceberg-Tabellen können Sie Ihre Daten effizient organisieren und partitionieren, Dateiformate und Komprimierung kontrollieren und sich nahtlos in andere AWS Dienste integrieren. 

Sie können partitionierte und unpartitionierte Iceberg-Tabellen mit den Befehlen and erstellen. `CREATE TABLE ... USING ICEBERG` `CREATE TABLE ... USING ICEBERG AS SELECT` Sie können auf Iceberg-Tabellen verweisen, indem Sie entweder die externe Schemanotation (`external_schema.table_name`) oder die dreiteilige Notation () verwenden. `"catalog_name".database_name.table_name` Die Beispiele in diesem Abschnitt veranschaulichen beide Methoden.

Nachdem Sie eine Tabelle erstellt haben, können Sie Daten mithilfe von `INSERT` Standardbefehlen hinzufügen. Beachten Sie, dass Amazon Redshift zwar mit vielen Iceberg-Datentypen funktioniert, Sie beim Einfügen von Informationen jedoch möglicherweise einige Datenformate konvertieren müssen. 

Sie können Iceberg-Tabellen mit einem Befehl anzeigen. `SHOW TABLES` Wenn Sie eine Tabelle aus dem entfernen möchten AWS Glue Data Catalog, können Sie den `DROP TABLE` Befehl verwenden. Beachten Sie, dass dadurch nur die Tabellenregistrierung entfernt wird. Die tatsächlichen Daten bleiben im Speicher, bis Sie sie separat löschen.

Sie können vorhandene Daten auch mit den `MERGE` Befehlen `DELETE``UPDATE`, und ändern. Alle anderen SQL-Anweisungen, wie z. B.`ALTER TABLE`, werden in Iceberg-Tabellen noch nicht unterstützt.

Sie können in eine Iceberg-Tabelle schreiben, die nicht von Amazon Redshift erstellt wurde. Es gibt jedoch einige Einschränkungen:
+ Bei der Tabelle muss es sich um eine Iceberg v2-Tabelle handeln.
+ Die Tabelle muss Parquet als Standarddatenformat verwenden.
+ Für die Tabelle darf die Metadatenkomprimierung nicht auf True gesetzt sein.
+ Die Tabelle darf nicht aktiviert werden Write-Audit-Publish (WAP).

In den folgenden Abschnitten wird die SQL-Syntax für das Erstellen, Einfügen, Ändern und Verwalten von Iceberg-Tabellen in Amazon Redshift demonstriert.

**Contents**
+ [CREATE TABLE](#iceberg-writes-create-table)
+ [CREATE TABLE AS SELECT](#iceberg-writes-create-table-as-select)
+ [SHOW TABLE](#iceberg-writes-show-table)
+ [INSERT INTO](#iceberg-writes-insert-into)
+ [DELETE](#iceberg-writes-delete)
+ [UPDATE](#iceberg-writes-update)
+ [MERGE](#iceberg-writes-merge)
+ [DROP TABLE](#iceberg-writes-drop-table)

## CREATE TABLE
<a name="iceberg-writes-create-table"></a>

```
CREATE TABLE [IF NOT EXISTS] {{<external_schema>}}.{{<table_name>}} (
  column_name data_type [, ...]
)
USING ICEBERG
[LOCATION 's3://{{your-bucket-name}}/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='<compression_value>')]
```

Sie können auch die dreiteilige Notation für S3-Tabellen-Buckets verwenden:

```
CREATE TABLE "{{<table_bucket_name>}}@s3tablescatalog".{{<database_name>}}.{{<table_name>}} (
  column_name data_type [, ...]
)
USING ICEBERG
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='<compression_value>')]
```

Beachten Sie, dass dies ein vorhandener externer Schemaname sein `{{<external_schema>}}` muss, in dem die externe Tabelle erstellt werden soll. Weitere Informationen zum Erstellen und Verwalten externer Schemas finden Sie unter [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html) in der Amazon Redshift Redshift-Dokumentation.

Die `LOCATION` Klausel definiert den Tabellenstandort für diese neu erstellte Iceberg-Tabelle. Kann für Amazon S3 S3-Tabellen `LOCATION` nicht angegeben werden, da der Tabellenstandort durch den Amazon S3 S3-Tabellenkatalog (`s3tablescatalog`) bestimmt wird. 

In allen anderen Fällen `LOCATION` ist dies erforderlich, und es sollte ein leerer Speicherort sein, was bedeutet, dass es keine vorhandenen Amazon S3 S3-Objekte gibt, die denselben Bucket und dasselbe Präfix teilen. Beachten Sie, dass sich die Amazon S3 S3-Bucket-Region in derselben Region wie der Amazon Redshift Redshift-Cluster befinden muss. 

 AWS Bietet jedoch eine Methode zum Replizieren von Daten aus Iceberg-Tabellen, die in einer anderen gespeichert sind, AWS Glue Data Catalog in eine andere AWS-Region, sodass Sie den Schreibvorgang in eine andere Region replizieren können. AWS-Region Weitere Informationen finden Sie unter Daten [replizieren](https://docs.aws.amazon.com/prescriptive-guidance/latest/apache-iceberg-on-aws/best-practices-workloads.html#workloads-replication). AWS-Regionen

`PARTITIONED BY`definiert die Iceberg-Tabellenpartition. Amazon Redshift unterstützt alle Iceberg v2-Partitionstransformationen mit Ausnahme von. `void` Hier ist die Liste der unterstützten Transformationen:
+ **Identität**
+ **Eimer [N]**
+ **kürzen [W]**
+ **Jahr**
+ **Monat**
+ **Tag**
+ **Stunde**

Die vollständigen Definitionen dieser Transformationen und der kompatiblen Datentypen finden Sie unter [Partitionstransformationen](https://iceberg.apache.org/spec/#partition-transforms) in der Apache Iceberg-Dokumentation.

Das `PARTITIONED BY` unterstützt mehrstufige Partitionierung. Sie können z. B. den folgenden Befehl ausführen:

```
CREATE TABLE ...
USING ICEBERG
LOCATION ...
PARTITIONED BY (bucket(16, id), year(ship_date));
```

Amazon Redshift unterstützt jedoch nicht die Verwendung einer einzelnen Spalte in mehr als einer Transformation. Beispielsweise wird die folgende Syntax nicht unterstützt:

```
CREATE TABLE ...
USING ICEBERG
LOCATION ...
PARTITIONED BY (bucket(16, ship_date), year(ship_date));
```

Die `TABLE PROPERTIES` Klausel definiert die zusätzlichen Tabelleneigenschaften für diese Iceberg-Tabelle. Die einzige Tabelleneigenschaft, die wir unterstützen`compression_type`, ist die Definition der Standardkomprimierung von Parquet-Datendateien. Wenn dies nicht angegeben ist, `snappy` wird es als Komprimierungscodec verwendet. Die möglichen Werte für `compression_type` sind:`zstd`,`brotli`, `gzip``snappy`, und`uncompressed`.

**Anmerkung**  
`CREATE TABLE ... LIKE ...`wird für Iceberg-Tabellen nicht unterstützt. Eisberg-Tabellen unterstützen auch keine Spalteneinschränkungen und Spaltenattribute wie dies bei RMS-Tabellen der Fall ist.

Alternativ können Sie eine Eisberg-Tabelle in einem einzigen Vorgang erstellen und auffüllen, indem Sie Folgendes verwenden: `CREATE TABLE AS SELECT`

## CREATE TABLE AS SELECT
<a name="iceberg-writes-create-table-as-select"></a>

```
CREATE TABLE {{<external_schema>}}.{{<table_name>}} [(
  column_name[, ...]
)]
USING ICEBERG
[LOCATION 's3://{{your-bucket-name}}/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='{{<compression-value>}}')]
AS
SELECT query
```

Sie können auch die dreiteilige Notation verwenden, um Tabellen in automatisch bereitgestellten Katalogen zu erstellen:

```
CREATE TABLE "{{<catalog_name>}}".{{<database_name>}}.{{<table_name>}} [(
  column_name[, ...]
)]
USING ICEBERG
[LOCATION 's3://{{your-bucket-name}}/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='{{<compression-value>}}')]
AS
SELECT query
```

Dies ähnelt der Anweisung, mit der Ausnahme, dass darauf eine `CREATE TABLE` `SELECT` Anweisung `CREATE` folgt, um die Tabelle mit Abfrageergebnissen zu füllen. `SELECT`

Mit `CREATE TABLE` dieser Klausel können Sie die Datentypen nicht mehr angeben, da die Spaltendatentypen von der `SELECT` Abfrage bestimmt werden.

Wenn die `SELECT` Abfrage aus irgendeinem Grund fehlschlägt, schlägt diese Abfrage fehl und die Iceberg-Tabelle wird nicht erstellt.

Sie können die Struktur Ihrer Iceberg-Tabellen wie folgt anzeigen: `SHOW TABLE`

## SHOW TABLE
<a name="iceberg-writes-show-table"></a>

```
SHOW TABLE {{<external_schema>}}.{{<table_name>}}
```

Sie können auch die dreiteilige Notation für automatisch gemountete Kataloge verwenden:

```
SHOW TABLE "{{<catalog_name>}}".{{<database_name>}}.{{<table_name>}}
```

`SHOW TABLE`zeigt die `CREATE TABLE` Anweisung für die Iceberg-Tabelle an. Der Befehl zeigt je nach Typ der Tabelle die entsprechenden Ergebnisse an. Im Folgenden finden Sie ein Beispiel für die `SHOW TABLE` Ausgabe für die Iceberg-Tabelle:

```
CREATE TABLE my_schema.items (id int, price decimal(5, 2))
USING ICEBERG
LOCATION 's3://my_s3_bucket/items/'
PARTITIONED BY (bucket(16, id))
TABLE PROPERTIES ('compression_type'='snappy')
```

**Anmerkung**  
Bei Amazon S3 S3-Tabellen wird die `LOCATION` Klausel in den `SHOW TABLE` Ergebnissen weggelassen, da der Tabellenspeicherort vom Amazon S3 S3-Tabellenkatalog verwaltet wird.

Nachdem Sie Tabellen erstellt haben, können Sie Daten hinzufügen, indem Sie`INSERT INTO`:

## INSERT INTO
<a name="iceberg-writes-insert-into"></a>

```
INSERT INTO {{<external_schema>}}.{{<table_name>}} [(column_name [, ...])] VALUES (...)
INSERT INTO {{<external_schema>}}.{{<table_name>}} [(column_name [, ...])] (SELECT query)

-- Using three-part notation for S3 table buckets:
INSERT INTO "{{<table_bucket_name>}}@s3tablescatalog".{{<database_name>}}.{{<table_name>}} [(column_name [, ...])] VALUES (...)
INSERT INTO "{{<table_bucket_name>}}@s3tablescatalog".{{<database_name>}}.{{<table_name>}} [(column_name [, ...])] (SELECT query)
```

Sie können eine `INSERT INTO` bestehende Iceberg-Tabelle mit der obigen Syntax erstellen. Wenn eine `VALUES` Klausel verwendet wird, geben Sie die Werte für die Spalten an, die von aufgelistet sind`column_name`, oder für alle Spalten, wenn `column_name` ein Teil weggelassen wird.

Wenn Daten in eine partitionierte Tabelle eingefügt werden, werden neue Zeilen gemäß der vordefinierten Partitionsspezifikation verteilt. Wenn die `SELECT` Abfrage aus irgendeinem Grund fehlschlägt, schlägt die Abfrage fehl und es werden keine Daten in die Iceberg-Tabelle eingefügt.

## DELETE
<a name="iceberg-writes-delete"></a>

Die `DELETE` Abfrage für die Iceberg-Tabelle verwendet die in der RMS-Tabelle vorhandene `DELETE` Syntax:

```
[ WITH [RECURSIVE] {{common_table_expression}} [, {{common_table_expression}} , ...] ]
DELETE [ FROM ] {{iceberg_table}}
[ { USING } {{table_name, ...}} ] [ WHERE {{condition}} ]
```

Sie können auch die dreiteilige Notation für S3-Tabellen-Buckets verwenden:

```
[ WITH [RECURSIVE] {{common_table_expression}} [, {{common_table_expression}} , ...] ]
DELETE [ FROM ] "{{<table_bucket_name>}}@s3tablescatalog".{{<database_name>}}.{{<table_name>}}
[ { USING } {{table_name, ...}} ] [ WHERE {{condition}} ]
```

`{{iceberg_table}}`Sie können über das `{{<external_schema>}}.{{<external_table_name>}}` Formular referenziert werden oder die dreiteilige Notation für den auto gemounteten Katalog verwenden. Siehe [Referenzieren von Iceberg-Tabellen in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/referencing-iceberg-tables.html).

Die `USING` Klausel `{{table_name}}` in the wird verwendet, um eine Verknüpfung mit der Zieltabelle herzustellen, um Zeilen zu löschen, die die Bedingung erfüllen. `WHERE` Das `{{table_name}}` kann eine Iceberg-Tabelle oder eine Amazon Redshift RMS-Tabelle sein.

Da Iceberg ein verstecktes Partitionsschema verwendet, kann der Benutzer die `DELETE` Abfrage verwenden, um Partitionen zu entfernen, wodurch der gleiche Effekt wie `ALTER TABLE ... DROP PARTITION ...` bei Hive-Tabellen erzielt wird.

Zum Beispiel, wenn wir die Iceberg-Tabelle wie folgt partitioniert haben:

```
CREATE TABLE my_external_schema.lineitem
(l_item_id int,
 l_ship_date varchar,
 ...
)
USING ICEBERG
LOCATION ...
PARTITIONED BY l_ship_date;
```

Dann können wir eine Partition einfach mit einer Abfrage wie dieser entfernen:

```
DELETE FROM my_external_schema.lineitem WHERE l_ship_date = '20251231';
```

Für Abfragen wie diese optimiert Amazon Redshift die Ausführung, sodass nur Metadaten ausgeführt werden und die Ausführung kurzgeschlossen wird. Im Gegensatz zu normalen `DELETE` Abfragen zeigt die Abfrage „Nur Metadaten löschen“ also keine Ausführungsschritte in`EXPLAIN`:

```
explain DELETE FROM my_external_schema.lineitem WHERE l_ship_date = '20251231';

 QUERY PLAN
------------
"XN Seq Scan Metadata of my_external_schema.lineitem location: "s3://s3-path//table-location" format:ICEBERG (cost=0.00..0.01 rows=0 width=0)"
(0 rows)
```

## UPDATE
<a name="iceberg-writes-update"></a>

Die `UPDATE` Abfragesyntax für die Iceberg-Tabelle ist der vorhandenen `UPDATE` Syntax für die RMS-Tabelle sehr ähnlich:

```
[ WITH [RECURSIVE] {{common_table_expression}} [, {{common_table_expression}} , ...] ]
UPDATE {{iceberg_table}} [ [ AS ] alias ] SET column = { {{expression}} } [,...]
[ FROM {{fromlist}} ]
[ WHERE {{condition}} ]
```

Sie können auch die dreiteilige Notation für S3-Tabellen-Buckets verwenden:

```
[ WITH [RECURSIVE] {{common_table_expression}} [, {{common_table_expression}} , ...] ]
UPDATE "{{<table_bucket_name>}}@s3tablescatalog".{{<database_name>}}.{{<table_name>}} [ [ AS ] alias ] SET column = { {{expression}} } [,...]
[ FROM {{fromlist}} ]
[ WHERE {{condition}} ]
```

`{{iceberg_table}}`Sie können über das `{{<external_schema>}}.{{<external_table_name>}}` Formular referenziert werden oder die dreiteilige Notation für den auto gemounteten Katalog verwenden. Siehe [Referenzieren von Iceberg-Tabellen in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/referencing-iceberg-tables.html).

Sie können eine Tabelle aktualisieren, indem Sie Informationen in anderen Tabellen referenzieren. Listen Sie diese anderen Tabellen in der FROM-Klausel auf oder verwenden Sie eine Unterabfrage als Teil der WHERE-Bedingung. Die Quelltabellen können entweder Iceberg-Tabellen oder Amazon Redshift RMS-Tabellen sein.

`UPDATE`kann auch auf partitionierten Tabellen ausgeführt werden. Wenn Spaltenwerte `UPDATE` geändert werden, die zur aktuellen Partitionsspezifikation gehören, würde die neue aktualisierte Zeile auf der Grundlage des neu aktualisierten Werts in die neue Partition eingefügt.

Zum Beispiel, wenn wir eine partitionierte Iceberg-Tabelle wie folgt haben:

```
CREATE TABLE my_external_schema.lineitem
(l_item_id int,
 l_ship_date varchar,
 ...
)
USING ICEBERG
LOCATION ...
PARTITIONED BY l_ship_date;

INSERT INTO my_external_schema.lineitem VALUES (10099, '20251231', ...);
```

Und wenn wir die folgende Aktualisierungsabfrage ausführen:

```
UPDATE my_external_schema.lineitem SET l_ship_date = '20260101'
WHERE l_item_id = 10099;
```

wir werden diese Zeile mit `l_item_id` 10099 von der Partition `20251231` auf die neue Partition `20260101` verschieben.

Es ist auch wichtig zu beachten, dass es möglich `UPDATE` ist, mehrere Kandidatenwerte zu haben. Betrachten Sie die folgende Abfrage:

```
CREATE TABLE my_ext_schema.t1(x1 int, y1 int) USING ICEBERG LOCATION ...;
CREATE TABLE my_ext_schema.t2(x2 int, y2 int) USING ICEBERG LOCATION ...;
INSERT INTO my_ext_schema.t1 VALUES (1,10), (2,20), (3,30);
INSERT INTO my_ext_schema.t2 VALUES (2,40), (2,50);
UPDATE my_ext_schema.t1 SET y1=y2 FROM my_ext_schema.t2 WHERE x1=x2;
```

In diesem Fall kann y1 40 oder 50 sein. Das Ergebnis ist nicht deterministisch. Sie können den Konfigurationsparameter `error_on_nondeterministic_update` auf true setzen, um in einem solchen Fall einen Abfragefehler zu erzwingen. Dies entspricht dem `UPDATE` Verhalten der vorhandenen RMS-Tabellen. Weitere Informationen finden Sie unter [error\_on\_nondeterministic\_update](https://docs.aws.amazon.com/redshift/latest/dg/r_error_on_nondeterministic_update.html).

## MERGE
<a name="iceberg-writes-merge"></a>

Die `MERGE` Abfrage führt Zeilen aus einer Quelltabelle bedingt mit einer Zieltabelle zusammen. Sie verwendet dieselbe `MERGE` Abfragesyntax wie die vorhandene RMS-Tabelle:

```
MERGE INTO {{target_iceberg_table}} USING {{source_table}} [ [ AS ] {{alias}} ]
ON {{match_condition}}
[ WHEN MATCHED THEN { UPDATE SET {{col_name}} = { {{expr}} } [,...] | DELETE }
  WHEN NOT MATCHED THEN INSERT [ ( {{col_name}} [,...] ) ]
  VALUES ( { {{expr}} } [, ...] )
| REMOVE DUPLICATES ]
```

Sie können auch die dreiteilige Notation für S3-Tabellen-Buckets verwenden:

```
MERGE INTO "{{<table_bucket_name>}}@s3tablescatalog".{{<database_name>}}.{{<table_name>}} USING {{source_table}} [ [ AS ] {{alias}} ]
ON {{match_condition}}
[ WHEN MATCHED THEN { UPDATE SET {{col_name}} = { {{expr}} } [,...] | DELETE }
  WHEN NOT MATCHED THEN INSERT [ ( {{col_name}} [,...] ) ]
  VALUES ( { {{expr}} } [, ...] )
| REMOVE DUPLICATES ]
```

`{{target_iceberg_table}}`Sie können über das `{{<external_schema>}}.{{<external_table_name>}}` Formular referenziert werden oder die dreiteilige Notation für den auto gemounteten Katalog verwenden. Siehe [Referenzieren von Iceberg-Tabellen in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/referencing-iceberg-tables.html).

Dabei `{{source_table}}` kann es sich entweder um eine Iceberg-Tabelle oder eine Amazon Redshift RMS-Tabelle handeln.

Wenn dieser `MERGE` Befehl verwendet `REMOVE DUPLICATES` wird, verwendet er den vereinfachten Modus. Weitere Informationen zum vereinfachten Modus finden Sie im ursprünglichen `MERGE` [Befehlsdokument](https://docs.aws.amazon.com/redshift/latest/dg/r_MERGE.html).

Bei der Ausführung der `MERGE` Abfrage generiert und speichert Amazon Redshift Zwischendatendateien am Speicherort der Zieltabelle. Diese Dateien werden am Ende der Abfrage automatisch gelöscht. Aus diesem Grund würde für die `MERGE` Abfrage eine `DELETE` Genehmigung für den Amazon S3 S3-Bucket erforderlich sein, um ordnungsgemäß zu funktionieren. Ein Fehler mit unzureichenden Berechtigungen würde ausgelöst werden, wenn der Garbage-Collection-Vorgang fehlschlägt. Für Amazon S3 S3-Tabellen wird die Garbage-Collection vom Amazon S3 S3-Tabellenservice verwaltet. Daher ist keine `DELETE` Genehmigung erforderlich, um eine `MERGE` Abfrage auszuführen.

## DROP TABLE
<a name="iceberg-writes-drop-table"></a>

Verwenden Sie den `DROP TABLE` folgenden Befehl, um eine Iceberg-Tabelle aus dem Katalog zu entfernen:

```
DROP TABLE {{<external_schema>}}.{{<table_name>}}
```

Sie können auch die dreiteilige Notation für automatisch gemountete Kataloge verwenden:

```
DROP TABLE "{{<catalog_name>}}".{{<database_name>}}.{{<table_name>}}
```

Das Löschen einer Iceberg-Tabelle ist ein reiner Metadaten-Vorgang. Es entfernt den Tabelleneintrag aus AWS Glue Data Catalog einem Amazon S3 S3-Tabellenkatalog, falls es sich um eine Amazon S3 S3-Tabelle handelt. Amazon Redshift bereinigt oder löscht keine vorhandenen Datendateien oder Metadatendateien unter dem Tabellenspeicherort. Sie können Funktionen in AWS Glue und Amazon S3 S3-Tabellen verwenden, um verwaiste Dateien zu entfernen. Weitere Informationen finden Sie unter [Löschen verwaister Dateien](https://docs.aws.amazon.com/glue/latest/dg/orphan-file-deletion.html). AWS Glue Informationen zu Amazon S3 S3-Tabellen finden Sie unter [Tabellenverwaltung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-maintenance.html).