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.
# Amazon Redshift Spectrum
In diesem Abschnitt wird beschrieben, wie Sie Redshift Spectrum verwenden, um Daten effizient aus Amazon S3 zu lesen.
Mit Amazon Redshift Spectrum können Sie strukturierte und halbstrukturierte Daten aus Dateien in Amazon S3 auf effektive Weise abfragen und abrufen, ohne die Daten in Amazon-Redshift-Tabellen laden zu müssen. Redshift-Spectrum-Abfragen nutzen massive Parallelität zur sehr schnellen Ausführung bei sehr großen Datensätzen. Ein großer Teil der Verarbeitung findet auf der Redshift-Spectrum-Ebene statt, und die meisten Daten bleiben in Amazon S3. Mehrere Cluster können denselben Datensatz in Amazon S3 gleichzeitig abfragen, ohne dass Kopien der Daten für jeden Cluster erstellt werden müssen.
**Topics**
+ [Übersicht zu Amazon Redshift Spectrum](c-spectrum-overview.md)
+ [Erste Schritte mit Amazon Redshift Spectrum](c-getting-started-using-spectrum.md)
+ [Fragen Sie Amazon S3 S3-Tabellen von Amazon Redshift ab](querying-s3Tables.md)
+ [IAM-Richtlinien für Amazon Redshift Spectrum](c-spectrum-iam-policies.md)
+ [Redshift Spectrum und AWS Lake Formation](spectrum-lake-formation.md)
+ [Datendateien für Abfragen in Amazon Redshift Spectrum](c-spectrum-data-files.md)
+ [Externe Schemata in Amazon Redshift Spectrum](c-spectrum-external-schemas.md)
+ [Externe Tabellen für Redshift Spectrum](c-spectrum-external-tables.md)
+ [Verwenden von Apache-Iceberg-Tabellen mit Amazon Redshift](querying-iceberg.md)
+ [Abfrageleistung von Amazon Redshift Spectrum](c-spectrum-external-performance.md)
+ [Optionen für die Fehlerbehandlung](t_setting-data-handling-options.md)
+ [Beispiel: Durchführen korrelierter Unterabfragen in Redshift Spectrum](c_performing-correlated-subqueries-spectrum.md)
+ [Metriken in Amazon Redshift Spectrum](c-spectrum-metrics.md)
+ [Fehlerbehebung für Abfragen in Amazon Redshift Spectrum](c-spectrum-troubleshooting.md)
+ [Tutorial: Abfragen verschachtelter Daten mit Amazon Redshift Spectrum](tutorial-query-nested-data.md)
# Übersicht zu Amazon Redshift Spectrum
In diesem Thema werden Details der Verwendung von Redshift Spectrum zum effizienten Lesen aus Amazon S3 beschrieben.
Amazon Redshift Spectrum befindet sich auf dedizierten Amazon-Redshift-Servern, die von Ihrem Cluster unabhängig sind. Amazon Redshift verschiebt viele datenverarbeitungsintensive Aufgaben, wie etwa die Prädikatfilterung und -aggregierung, auf die Redshift-Spectrum-Ebene. So verwenden Redshift Spectrum-Abfragen viel weniger der Verarbeitungskapazität Ihres Clusters als andere Abfragen. Dazu kann Redshift Spectrum in intelligenter Weise skaliert werden. Auf der Grundlage der Anforderungen Ihrer Abfragen kann Redshift Spectrum potenziell Tausende von Instances nutzen und so sehr umfangreiche parallele Verarbeitungsmöglichkeiten bieten.
Sie erstellen Redshift Spectrum-Tabellen, indem Sie die Struktur für Ihre Dateien definieren und diese als Tabellen in einem externen Datenkatalog registrieren. Der externe Datenkatalog kann AWS Glue der im Lieferumfang von Amazon Athena enthaltene Datenkatalog oder Ihr eigener Apache Hive-Metastore sein. Sie können externe Tabellen von Amazon Redshift aus erstellen und verwalten, DDL-Befehle (Data Definition Language) nutzen oder jedes andere Tool verwenden, das sich mit dem externen Datenkatalog verbinden kann. Änderungen an dem externen Datenkatalog sind sofort für jeden Ihrer Amazon-Redshift-Cluster verfügbar.
Sie können optional die externen Tabellen auf einer oder mehreren Spalten partitionieren. Die Definition von Partitionen als Teil der externen Tabelle kann die Leistung verbessern. Diese Verbesserung beruht darauf, dass der Amazon-Redshift-Abfrageoptimierer Partitionen, die keine Daten für die Abfrage enthalten, entfernt.
Materialisierte Ansichten in Spectrum-Tabellen können Kosten und Leistung erheblich verbessern. Weitere Informationen finden Sie unter [Materialisierte Ansichten für externe Data-Lake-Tabellen in Amazon Redshift SpectrumMaterialisierte Ansichten für externe Data-Lake-Tabellen](materialized-view-external-table.md).
Nachdem Ihre Redshift-Spectrum-Tabellen definiert wurden, können Sie die Tabellen wie jede andere Amazon-Redshift-Tabelle abfragen oder verbinden. Redshift Spectrum unterstützt keine Aktualisierungsvorgänge auf externen Tabellen. Sie können Redshift Spectrum-Tabellen zu mehreren Amazon Redshift Redshift-Clustern hinzufügen und dieselben Daten auf Amazon S3 von jedem Cluster in derselben AWS Region abfragen. Wenn Sie Amazon-S3-Datendateien aktualisieren, stehen diese Daten sofort zur Abfrage von allen Ihren Amazon-Redshift-Clustern aus zur Verfügung.
Der AWS Glue Datenkatalog, auf den Sie zugreifen, ist möglicherweise verschlüsselt, um die Sicherheit zu erhöhen. Wenn der AWS Glue Katalog verschlüsselt ist, benötigen Sie den Schlüssel AWS Key Management Service (AWS KMS) für AWS Glue , um auf den AWS Glue Katalog zuzugreifen. AWS Glue Die Katalogverschlüsselung ist nicht in allen AWS Regionen verfügbar. Eine Liste der unterstützten AWS Regionen finden Sie unter [Verschlüsselung und sicheren Zugriff für AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/encryption-glue-resources.html) im *[AWS Glue Entwicklerhandbuch](https://docs.aws.amazon.com/glue/latest/dg/).*Weitere Informationen zur AWS Glue Datenkatalogverschlüsselung finden Sie unter [Verschlüsseln Ihres AWS Glue Datenkatalogs](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) im *[AWS Glue Entwicklerhandbuch](https://docs.aws.amazon.com/glue/latest/dg/)*.
**Anmerkung**
Sie können die Details für Redshift-Spectrum-Tabellen nicht mit den gleichen Ressourcen anzeigen, die Sie für Amazon-Redshift-Standardtabellen verwenden, wie [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md), [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md), PG\$1CLASS oder information\$1schema. Wenn Ihr Business Intelligence- oder Analyse-Tool externe Redshift Spectrum-Tabellen nicht erkennt, konfigurieren Sie Ihre Anwendung für die Ausführung von Abfragen für [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) und [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md).
## Amazon-Redshift-Spectrum-Regionen
Redshift Spectrum ist dort verfügbar AWS-Regionen , wo Amazon Redshift verfügbar ist, sofern in der regionsspezifischen Dokumentation nichts anderes angegeben ist. Informationen zur AWS-Region Verfügbarkeit in kommerziellen Regionen finden Sie unter [Service-Endpunkte](https://docs.aws.amazon.com/general/latest/gr/redshift-service.html#redshift_region) für die **Redshift-API** in der. *Allgemeine Amazon Web Services-Referenz*
# Einschränkungen für Amazon Redshift Spectrum
In diesem Thema werden Einschränkungen bei der Verwendung von Redshift Spectrum beschrieben.
Beachten Sie die folgenden Überlegungen bei der Verwendung von Redshift Spectrum:
+ Der Amazon Redshift Redshift-Cluster und der Amazon S3 S3-Bucket müssen sich in derselben AWS Region befinden.
+ Redshift Spectrum bietet keine Unterstützung für Enhanced VPC Routing mit bereitgestellten Clustern. Möglicherweise müssen Sie weitere Konfigurationsschritte ausführen, um auf Ihre Amazon-S3-Daten zuzugreifen. Weitere Informationen finden Sie unter [Redshift Spectrum und Enhanced VPC Routing](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html) im *Amazon-Redshift-Verwaltungshandbuch*.
+ Redshift Spectrum unterstützt Amazon-S3-Zugriffspunkt-Aliase. Weitere Informationen finden Sie unter [Verwenden eines Alias im Bucket-Stil für Ihren Zugriffspunkt](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-alias.html) im *Amazon-Simple-Storage-Service-Benutzerhandbuch*. Redshift Spectrum unterstützt jedoch keine VPC mit Amazon-S3-Zugriffspunkt-Aliase. Weitere Informationen finden Sie unter [Redshift Spectrum und Enhanced VPC Routing](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html) im *Amazon-Redshift-Verwaltungshandbuch*.
+ Sie können keine Aktualisierungs- oder Löschoperationen für externe Tabellen ausführen. Um eine neue externe Tabelle im angegebenen Schema zu erstellen, können Sie CREATE EXTERNAL TABLE verwenden. Weitere Hinweise zu CREATE EXTERNAL TABLE finden Sie unter [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Um die Ergebnisse einer SELECT-Abfrage in vorhandene externe Tabellen in externen Katalogen einzufügen, können Sie INSERT (externe Tabelle) verwenden. Weitere Informationen zu INSERT (externe Tabelle) finden Sie unter [INSERT (externe Tabelle)](r_INSERT_external_table.md).
+ Sofern Sie keine verwenden AWS Glue Data Catalog , die für AWS Lake Formation aktiviert ist, können Sie Benutzerberechtigungen für eine externe Tabelle nicht steuern. Sie gewähren oder widerrufen stattdessen die Berechtigungen für das externe Schema. Weitere Informationen zur Arbeit mit AWS Lake Formation finden Sie unter[Redshift Spectrum und AWS Lake Formation](spectrum-lake-formation.md).
+ Um Redshift Spectrum-Abfragen auszuführen, benötigt der Datenbankbenutzer die Berechtigung, temporäre Tabellen in der Datenbank zu erstellen. Das folgende Beispiel erteilt der Benutzergruppe `spectrumdb` temporäre Berechtigungen für die Datenbank `spectrumusers`.
```
grant temp on database spectrumdb to group spectrumusers;
```
Weitere Informationen finden Sie unter [GRANT](r_GRANT.md).
+ Wenn Sie den Athena-Datenkatalog oder den AWS Glue Datenkatalog als Metadatenspeicher verwenden, finden Sie weitere Informationen unter [Kontingente und Grenzwerte](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Amazon Redshift Management Guide*.
+ Redshift Spectrum unterstützt Amazon EMR nicht mit Kerberos.
# Erste Schritte mit Amazon Redshift Spectrum
In diesem Tutorial erfahren Sie, wie Sie mit Amazon Redshift Spectrum Daten direkt aus Dateien auf Amazon S3 abfragen. Wenn Sie bereits einen Cluster und einen SQL-Client haben, können Sie dieses Tutorial mit minimaler Einrichtung abschließen.
**Anmerkung**
Redshift Spectrum-Abfragen sind mit zusätzlichen Gebühren verbunden. Die Kosten für die Beispielabfragen in diesem Tutorial sind äußerst gering. Weitere Informationen zu Preisen finden Sie unter [Amazon Redshift Spectrum – Preise](https://aws.amazon.com/redshift/pricing/#redshift-spectrum-pricing).
## Voraussetzungen
Zu Verwendung von Redshift Spectrum benötigen Sie einen Amazon-Redshift-Cluster und einen SQL-Client, der mit Ihrem Cluster verbunden ist, damit Sie SQL-Befehle ausführen können. Der Cluster und die Datendateien in Amazon S3 müssen sich in derselben AWS-Region befinden.
Informationen zum Erstellen von Amazon-Redshift-Clustern finden Sie im Handbuch *Erste Schritte mit Amazon Redshift* unter [Erste Schritte mit von Amazon Redshift bereitgestellten Data Warehouses](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html). Informationen zu Möglichkeiten, eine Verbindung mit einem Cluster herzustellen, finden Sie unter [Verbinden mit von Amazon Redshift bereitgestellten Data Warehouses](https://docs.aws.amazon.com/redshift/latest/gsg/database-tasks.html) im Handbuch *Erste Schritte mit Amazon Redshift*.
In einigen der folgenden Beispiele befinden sich die Beispieldaten in der Region USA Ost (Nord-Virginia) (`us-east-1`), sodass Sie einen Cluster benötigen, der sich auch in `us-east-1` befindet. Oder Sie können Amazon S3 verwenden, um Datenobjekte aus den folgenden Buckets und Ordnern in Ihren Bucket zu kopieren, in AWS-Region dem sich Ihr Cluster befindet:
+ `s3://redshift-downloads/tickit/spectrum/customers/*`
+ `s3://redshift-downloads/tickit/spectrum/sales_partition/*`
+ `s3://redshift-downloads/tickit/spectrum/sales/*`
+ `s3://redshift-downloads/tickit/spectrum/salesevent/*`
Führen Sie einen Amazon-S3-Befehl ähnlich dem folgenden aus, um Beispieldaten, die sich in der Region USA Ost (Nord-Virginia) befinden, in Ihre AWS-Region zu kopieren. Erstellen Sie vor dem Ausführen des Befehls Ihren Bucket und die Ordner in Ihrem Bucket so, dass sie Ihrem Amazon-S3-Befehl entsprechen. Die Ausgabe des Amazon S3 S3-Befehls copy bestätigt, dass die Dateien *bucket-name* in das von Ihnen gewünschte Verzeichnis kopiert wurden AWS-Region.
```
aws s3 cp s3://redshift-downloads/tickit/spectrum/ s3://bucket-name/tickit/spectrum/ --copy-props none --recursive
```
## Erste Schritte mit Redshift Spectrum mithilfe von AWS CloudFormation
Als Alternative zu den folgenden Schritten können Sie auf die Redshift DataLake AWS CloudFormation Spectrum-Vorlage zugreifen, um einen Stack mit einem Amazon S3 S3-Bucket zu erstellen, den Sie abfragen können. Weitere Informationen finden Sie unter [Starten Sie Ihren AWS CloudFormation Stack und fragen Sie dann Ihre Daten in Amazon S3 ab](#c-getting-started-using-spectrum-query-s3-data-cfn).
## Erste Schritte mit Amazon Redshift Spectrum – Schritt für Schritt
Gehen Sie wie folgt vor, um mit der Verwendung von Amazon Redshift Spectrum zu beginnen:
+ [Schritt 1. Erstellen Sie eine IAM-Rolle für Amazon Redshift](#c-getting-started-using-spectrum-create-role)
+ [Schritt 2: Zuordnen der IAM-Rolle zu Ihrem Cluster](#c-getting-started-using-spectrum-add-role)
+ [Schritt 3: Erstellen eines externen Schemas und einer externen Tabelle](#c-getting-started-using-spectrum-create-external-table)
+ [Schritt 4: Abfragen Ihrer Daten in Amazon S3](#c-getting-started-using-spectrum-query-s3-data)
## Schritt 1. Erstellen Sie eine IAM-Rolle für Amazon Redshift
Ihr Cluster benötigt eine Autorisierung für den Zugriff auf Ihren externen Datenkatalog in AWS Glue oder Amazon Athena und Ihre Datendateien in Amazon S3. Diese Berechtigung wird durch die Referenzierung einer AWS Identity and Access Management -Rolle (IAM) gewährt, die mit Ihrem Cluster verbunden ist. Weitere Informationen zur Verwendung von Rollen mit Amazon Redshift finden Sie unter [Autorisierung von COPY- und UNLOAD-Vorgängen mit IAM-Rollen](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html).
**Anmerkung**
In bestimmten Fällen können Sie Ihren Athena-Datenkatalog zu einem AWS Glue Datenkatalog migrieren. Sie können dies tun, wenn sich Ihr Cluster in einer AWS Region befindet, die unterstützt AWS Glue wird, und Sie externe Redshift Spectrum-Tabellen im Athena-Datenkatalog haben. Um den AWS Glue Datenkatalog mit Redshift Spectrum zu verwenden, müssen Sie möglicherweise Ihre IAM-Richtlinien ändern. Weitere Informationen finden Sie unter [Upgrade auf den AWS Glue -Datenkatalog](https://docs.aws.amazon.com/athena/latest/ug/glue-athena.html#glue-upgrade) im *Athena-Benutzerhandbuch*.
Wenn Sie eine Rolle für Amazon Redshift erstellen, wählen Sie einen der folgenden Ansätze aus:
+ Wenn Sie Redshift Spectrum entweder mit einem Athena-Datenkatalog oder AWS Glue einem Datenkatalog verwenden, folgen Sie den unter beschriebenen Schritten. [So erstellen Sie eine IAM-Rolle für Amazon Redshift](#spectrum-get-started-create-role)
+ Wenn Sie Redshift Spectrum mit einem verwenden AWS Glue Data Catalog , für aktiviert ist AWS Lake Formation, gehen Sie wie folgt vor:
+ [So erstellen Sie eine IAM-Rolle für Amazon Redshift mit einem aktivierten AWS Glue Data Catalog AWS Lake Formation](#spectrum-get-started-create-role-lake-formation)
+ [So gewähren Sie SELECT-Berechtigungen für eine Tabelle, um diese in der Lake-Formation-Datenbank abzufragen](#spectrum-get-started-grant-lake-formation-table)
**So erstellen Sie eine IAM-Rolle für Amazon Redshift**
1. Öffnen Sie die [IAM-Konsole](https://console.aws.amazon.com/iam/home?#home).
1. Wählen Sie im Navigationsbereich **Roles** aus.
1. Wählen Sie **Create role** (Rolle erstellen) aus.
1. Wählen Sie **AWS -Service** als vertrauenswürdige Entität und dann **Redshift** als Anwendungsfall aus.
1. Wählen **Sie unter Anwendungsfall für andere AWS-Services** die Option **Redshift — Anpassbar** und wählen Sie dann **Weiter** aus.
1. Die Seite **Add permissions policy** (Berechtigungsrichtlinie hinzufügen) wird angezeigt. Wählen Sie `AmazonS3ReadOnlyAccess` und`AWSGlueConsoleFullAccess`, wenn Sie den AWS Glue Datenkatalog verwenden. Oder wählen Sie `AmazonAthenaFullAccess` aus, wenn Sie den Athena-Datenkatalog verwenden. Wählen Sie **Weiter** aus.
**Anmerkung**
Über die Richtlinie `AmazonS3ReadOnlyAccess` gewähren Sie dem Cluster Leseberechtigungen für alle Amazon-S3-Buckets. Um nur Zugriff auf den AWS Beispieldaten-Bucket zu gewähren, erstellen Sie eine neue Richtlinie und fügen Sie die folgenden Berechtigungen hinzu.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": "arn:aws:s3:::redshift-downloads/*"
}
]
}
```
1. Geben Sie in **Role name (Rollenname)** einen Namen für die Rolle ein, z. B. **myspectrum\$1role**.
1. Prüfen Sie die Rolleninformationen, und klicken Sie dann auf **Create role**.
1. Wählen Sie im Navigationsbereich **Roles**. Wählen Sie den Namen der neuen Rolle aus, um die Zusammenfassung anzuzeigen, und kopieren Sie den **Role ARN** in die Zwischenablage. Dieser Wert ist der Amazon-Ressourcenname (ARN) für die Rolle, die Sie soeben erstellt haben. Sie verwenden diesen Wert, wenn Sie externe Daten zur Referenzierung Ihrer Datendateien auf Amazon S3 erstellen.
**So erstellen Sie eine IAM-Rolle für Amazon Redshift mit einem aktivierten AWS Glue Data Catalog AWS Lake Formation**
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie im Navigationsbereich **Policies** aus.
Wenn Sie zum ersten Mal **Policies (Richtlinien)** auswählen, erscheint die Seite **Welcome to Managed Policies (Willkommen bei verwalteten Richtlinien)**. Wählen Sie **Get Started**.
1. Wählen Sie **Create Policy (Richtlinie erstellen)** aus.
1. Wählen Sie die Option zum Erstellen der Richtlinie auf der Registerkarte **JSON**.
1. Fügen Sie das folgende JSON-Richtliniendokument ein, das Zugriff auf den Datenkatalog gewährt, jedoch Administratorberechtigungen für Lake Formation verweigert.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RedshiftPolicyForLF",
"Effect": "Allow",
"Action": [
"glue:*",
"lakeformation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
------
1. Wählen Sie, wenn Sie fertig sind, **Review (Überprüfen)** aus. Die Richtlinienvalidierung meldet mögliche Syntaxfehler.
1. Geben Sie auf der Seite **Review Policy (Richtlinie überprüfen)** im Feld **Name (Name)** **myspectrum\$1policy** für die zu erstellende Richtlinie ein. Geben Sie eine **Beschreibung** ein (Optional) . Überprüfen Sie unter **Summary** die Richtlinienzusammenfassung, um die Berechtigungen einzusehen, die von Ihrer Richtlinie gewährt werden. Wählen Sie dann **Create policy** aus, um Ihre Eingaben zu speichern.
Nachdem Sie eine Richtlinie erstellt haben, können Sie Ihren Benutzern Zugriff erteilen.
Um Zugriff zu gewähren, fügen Sie Ihren Benutzern, Gruppen oder Rollen Berechtigungen hinzu:
+ Benutzer und Gruppen in: AWS IAM Identity Center
Erstellen Sie einen Berechtigungssatz. Befolgen Sie die Anweisungen unter [Erstellen eines Berechtigungssatzes](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
+ Benutzer, die in IAM über einen Identitätsanbieter verwaltet werden:
Erstellen Sie eine Rolle für den Identitätsverbund. Befolgen Sie die Anleitung unter [Eine Rolle für einen externen Identitätsanbieter (Verbund) erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) im *IAM-Benutzerhandbuch*.
+ IAM-Benutzer:
+ Erstellen Sie eine Rolle, die Ihr Benutzer annehmen kann. Befolgen Sie die Anleitung unter [Eine Rolle für einen IAM-Benutzer erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) im *IAM-Benutzerhandbuch*.
+ (Nicht empfohlen) Weisen Sie einem Benutzer eine Richtlinie direkt zu oder fügen Sie einen Benutzer zu einer Benutzergruppe hinzu. Befolgen Sie die Anweisungen unter [Hinzufügen von Berechtigungen zu einem Benutzer (Konsole)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) im *IAM-Benutzerhandbuch*.
**So gewähren Sie SELECT-Berechtigungen für eine Tabelle, um diese in der Lake-Formation-Datenbank abzufragen**
1. Öffnen Sie die Lake Formation Formation-Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Wählen Sie im Navigationsbereich **Data-Lake-Berechtigungen** und dann **Gewähren**.
1. Folgen Sie den Anweisungen unter [Gewähren von Tabellenberechtigungen mithilfe der benannten Ressourcenmethode](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html) im *AWS Lake Formation -Entwicklerhandbuch*. Geben Sie die folgenden Informationen ein:
+ Wählen Sie für **IAM role (IAM-Rolle)** die IAM-Rolle aus, die Sie erstellt haben (`myspectrum_role`). Wenn Sie den Amazon Redshift Query Editor ausführen, verwendet dieser die IAM-Rolle, um die erforderlichen Berechtigungen für die Daten zu erhalten.
**Anmerkung**
Um die SELECT-Berechtigung für die Tabelle in einem abzufragenden Lake-Formation-aktivierten Datenkatalog zu erteilen, gehen Sie wie folgt vor:
Registrieren Sie den Datenpfad in Lake Formation.
Gewähren Sie Benutzern die Berechtigung für diesen Pfad in Lake Formation.
Erstellte Tabellen finden Sie in dem in Lake Formation registrierten Pfad.
1. Wählen Sie **Grant (Erteilen)**.
**Wichtig**
Es hat sich bewährt, über Lake-Formation-Berechtigungen nur Zugriff auf die zugrundeliegenden Amazon-S3-Objekte zu gewähren. Um unbefugten Zugriff zu verhindern, entfernen Sie alle Berechtigungen, die für Amazon-S3-Objekte außerhalb von Lake Formation gewährt wurden. Wenn Sie zuvor auf Amazon-S3-Objekte zugegriffen haben, bevor Sie Lake Formation eingerichtet haben, entfernen Sie alle IAM-Richtlinien oder Bucket-Berechtigungen, die zuvor eingerichtet waren. Weitere Informationen finden Sie unter [Upgrading AWS Glue Data Permissions to the AWS Lake Formation Model](https://docs.aws.amazon.com/lake-formation/latest/dg/upgrade-glue-lake-formation.html) und [Lake Formation Permissions](https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html).
## Schritt 2: Zuordnen der IAM-Rolle zu Ihrem Cluster
Jetzt besitzen Sie eine IAM-Rolle, die Amazon Redshift zum Zugriff auf den externen Datenkatalog und auf Amazon S3 in Ihrem Namen berechtigt. An dieser Stelle müssen Sie diese Rolle Ihrem Amazon-Redshift-Cluster zuordnen.
**So ordnen Sie eine IAM-Rolle einem Cluster zu:**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon Redshift Redshift-Konsole unter [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/).
1. Wählen Sie im Navigationsmenü **Clusters** (Cluster) und dann den Namen des Clusters aus, den Sie aktualisieren möchten.
1. Wählen Sie für **Actions (Aktionen)** **Manage IAM roles (IAM-Rollen verwalten)** aus. Die Seite **IAM roles (IAM-Rollen)** wird angezeigt.
1. Wählen Sie **Enter ARN** (ARN eingeben) aus und geben Sie dann einen ARN oder eine IAM-Rolle ein. Oder wählen Sie eine IAM-Rolle aus der Liste aus. Wählen Sie dann **Add IAM role (IAM-Rolle hinzufügen)** aus, um sie zur Liste der **Attached IAM-Rollen (Zugewiesenen IAM-Rollen)** hinzuzufügen.
1. Wählen Sie **Done (Beenden)** aus, um die IAM-Rolle dem Cluster zuzuordnen. Der Cluster wird modifiziert, um die Änderung abzuschließen.
## Schritt 3: Erstellen eines externen Schemas und einer externen Tabelle
Erstellen Sie externe Tabellen in einem externen Schema. Das externe Schema verweist auf eine Datenbank im externen Datenkatalog und stellt den IAM-Rollen-ARN bereit, der Ihrem Cluster erlaubt, in Ihrem Namen auf Amazon S3 zuzugreifen. Sie können eine externe Datenbank in einem Amazon Athena Athena-Datenkatalog oder einem Apache Hive-Metastore wie Amazon EMR erstellen. AWS Glue Data Catalog Für dieses Beispiel erstellen Sie die externe Datenbank in einem Amazon-Athena-Datenkatalog, wenn Sie das externe Schema Amazon Redshift erstellen. Weitere Informationen finden Sie unter [Externe Schemata in Amazon Redshift Spectrum](c-spectrum-external-schemas.md).
**So erstellen Sie ein externes Schema und eine externe Tabelle:**
1. Um ein externes Schema zu erstellen, ersetzen Sie den ARN der IAM-Rolle im folgenden Befehl durch den Rollen-ARN, den Sie in [Schritt 1](#c-getting-started-using-spectrum-create-role) erstellt haben. Führen Sie dann den Befehl in Ihrem SQL-Client aus.
```
create external schema myspectrum_schema
from data catalog
database 'myspectrum_db'
iam_role 'arn:aws:iam::123456789012:role/myspectrum_role'
create external database if not exists;
```
1. Führen Sie zur Erstellung einer externen Tabelle den folgenden CREATE EXTERNAL TABLE-Befehl aus.
**Anmerkung**
Ihr Cluster und der Amazon-S3-Bucket müssen sich in der gleichen AWS-Region befinden. Für diesen Beispielbefehl CREATE EXTERNAL TABLE befindet sich der Amazon S3 S3-Bucket mit den Beispieldaten im Osten der USA (Nord-Virginia) AWS-Region. Laden Sie die [Datei `sales_ts.000`](https://s3.amazonaws.com/redshift-downloads/tickit/spectrum/sales/sales_ts.000) herunter, um die Quelldaten zu sehen. .
Sie können dieses Beispiel so ändern, dass es in einem anderen ausgeführt wird AWS-Region. Erstellen Sie einen Amazon S3 S3-Bucket in Ihrem gewünschten Format AWS-Region. Kopieren Sie die Verkaufsdaten mit einem Amazon-S3-Kopierbefehl. Aktualisieren Sie dann die Option für den Speicherort im `CREATE EXTERNAL TABLE`-Beispielbefehl auf Ihren Bucket.
```
aws s3 cp s3://redshift-downloads/tickit/spectrum/sales/ s3://bucket-name/tickit/spectrum/sales/ --copy-props none --recursive
```
Die Ausgabe des Amazon S3 S3-Befehls copy bestätigt, dass die Datei *bucket-name* in das von Ihnen gewünschte Verzeichnis kopiert wurde AWS-Region.
```
copy: s3://redshift-downloads/tickit/spectrum/sales/sales_ts.000 to s3://bucket-name/tickit/spectrum/sales/sales_ts.000
```
```
create external table myspectrum_schema.sales(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
row format delimited
fields terminated by '\t'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales/'
table properties ('numRows'='172000');
```
## Schritt 4: Abfragen Ihrer Daten in Amazon S3
Nach der Erstellung Ihrer externen Tabellen können Sie sie mit den gleichen SELECT-Anweisungen abfragen, mit denen Sie auch andere Amazon-Redshift-Tabellen abfragen. Diese SELECT-Anweisungsabfragen beinhalten die Verbindung von Tabellen, die Aggregierung von Daten und die Filterung auf Prädikaten.
**So fragen Sie Ihre Daten in Amazon S3 ab**
1. Abruf der Anzahl der Zeilen in der Tabelle MYSPECTRUM\$1SCHEMA.SALES.
```
select count(*) from myspectrum_schema.sales;
```
```
count
------
172462
```
1. Es wird empfohlen, dass Sie Ihre größeren Faktentabellen in Amazon S3 und Ihre kleineren Dimensionstabellen in Amazon Redshift speichern. Wenn Sie die Beispieldaten in [Laden von Daten](https://docs.aws.amazon.com/redshift/latest/gsg/cm-dev-t-load-sample-data.html) geladen haben, befindet sich in Ihrer Datenbank eine Tabelle mit dem Namen EVENT. Wenn dies nicht der Fall ist, erstellen Sie mit dem folgenden Befehl die Tabelle EVENT.
```
create table event(
eventid integer not null distkey,
venueid smallint not null,
catid smallint not null,
dateid smallint not null sortkey,
eventname varchar(200),
starttime timestamp);
```
1. Laden Sie die Tabelle „EVENT“, indem Sie den IAM-Rollen-ARN in dem folgenden COPY-Befehl durch den Rollen-ARN ersetzen, den Sie in erstellt haben [Schritt 1. Erstellen Sie eine IAM-Rolle für Amazon Redshift](#c-getting-started-using-spectrum-create-role). Sie können optional die [Quelldaten für `allevents_pipe.txt`](https://s3.amazonaws.com/redshift-downloads/tickit/allevents_pipe.txt) aus einem Amazon S3 S3-Bucket in herunterladen und anzeigen AWS-Region `us-east-1`.
```
copy event from 's3://redshift-downloads/tickit/allevents_pipe.txt'
iam_role 'arn:aws:iam::123456789012:role/myspectrum_role'
delimiter '|' timeformat 'YYYY-MM-DD HH:MI:SS' region 'us-east-1';
```
Das folgende Beispiel verbindet die externe Amazon-S3-Tabelle MYSPECTRUM\$1SCHEMA.SALES mit der lokalen Amazon-Redshift-Tabelle EVENT, um den Gesamtumsatz für die 10 führenden Veranstaltungen zu ermitteln.
```
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid) from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
```
```
eventid | sum
--------+---------
289 | 51846.00
7895 | 51049.00
1602 | 50301.00
851 | 49956.00
7315 | 49823.00
6471 | 47997.00
2118 | 47863.00
984 | 46780.00
7851 | 46661.00
5638 | 46280.00
```
1. Zeigen Sie den Abfrageplan für die vorherige Abfrage an. Beachten Sie, dass die Schritte `S3 Seq Scan`, `S3 HashAggregate` und `S3 Query Scan` für die Daten auf Amazon S3 ausgeführt wurden.
```
explain
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid)
from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
```
```
QUERY PLAN
-----------------------------------------------------------------------------
XN Limit (cost=1001055770628.63..1001055770628.65 rows=10 width=31)
-> XN Merge (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Merge Key: sum(sales.derived_col2)
-> XN Network (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Send to leader
-> XN Sort (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Sort Key: sum(sales.derived_col2)
-> XN HashAggregate (cost=1055770620.49..1055770620.99 rows=200 width=31)
-> XN Hash Join DS_BCAST_INNER (cost=3119.97..1055769620.49 rows=200000 width=31)
Hash Cond: ("outer".derived_col1 = "inner".eventid)
-> XN S3 Query Scan sales (cost=3010.00..5010.50 rows=200000 width=31)
-> S3 HashAggregate (cost=3010.00..3010.50 rows=200000 width=16)
-> S3 Seq Scan myspectrum_schema.sales location:"s3://redshift-downloads/tickit/spectrum/sales" format:TEXT (cost=0.00..2150.00 rows=172000 width=16)
Filter: (pricepaid > 30.00)
-> XN Hash (cost=87.98..87.98 rows=8798 width=4)
-> XN Seq Scan on event (cost=0.00..87.98 rows=8798 width=4)
```
## Starten Sie Ihren AWS CloudFormation Stack und fragen Sie dann Ihre Daten in Amazon S3 ab
Nachdem Sie einen Amazon Redshift Redshift-Cluster erstellt und eine Verbindung zum Cluster hergestellt haben, können Sie Ihre Redshift DataLake AWS CloudFormation Spectrum-Vorlage installieren und dann Ihre Daten abfragen.
CloudFormation installiert die Redshift Spectrum Getting DataLake Started-Vorlage und erstellt einen Stack, der Folgendes umfasst:
+ Eine Rolle namens `myspectrum_role`, die mit Ihrem Redshift-Cluster verknüpft ist
+ Ein externes Schema mit dem Namen `myspectrum_schema`
+ Eine externe Tabelle mit dem Namen `sales` in einem Amazon S3 Bucket
+ Eine Redshift-Tabelle mit dem Namen `event` und geladenen Daten
**So starten Sie Ihren Redshift Spectrum Getting Started Stack DataLake CloudFormation**
1. Klicken Sie auf [https://console.aws.amazon.com/cloudformation/home?#/stacks/new?stackName=DataLake&templateURL=https://s3.amazonaws.com/redshift-downloads/docs-downloads/DataLake.yml](https://console.aws.amazon.com/cloudformation/home?#/stacks/new?stackName=DataLake&templateURL=https://s3.amazonaws.com/redshift-downloads/docs-downloads/DataLake.yml) (CFN-Stack starten). Die CloudFormation Konsole wird mit der ausgewählten Vorlage DataLake .yml geöffnet.
Sie können auch die Redshift Spectrum Getting Started DataLake CloudFormation [CFN-Vorlage](https://s3.amazonaws.com/redshift-downloads/docs-downloads/DataLake.yml) herunterladen und anpassen, dann die CloudFormation Konsole ([https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/)) öffnen und einen Stack mit der benutzerdefinierten Vorlage erstellen.
1. Wählen Sie **Weiter** aus.
1. Geben Sie unter **Parameters** (Parameter) den Namen des Amazon-Redshift-Clusters, den Datenbanknamen und Ihren Namen als Datenbankbenutzer ein.
1. Wählen Sie **Next (Weiter)**.
Die Stack-Optionen werden angezeigt.
1. Klicken Sie auf **Next** (Weiter), um die Standardeinstellungen zu übernehmen.
1. Prüfen Sie die Informationen und wählen Sie unter **Funktionen** die Option **Ich bestätige, dass AWS CloudFormation möglicherweise IAM-Ressourcen erstellt** werden.
1. Wählen Sie **Create stack (Stack erstellen)** aus.
Falls während der Erstellung des Stacks ein Fehler auftritt, lesen Sie die folgenden Informationen:
+ Auf der Registerkarte CloudFormation **Ereignisse** finden Sie Informationen, die Ihnen bei der Behebung des Fehlers helfen können.
+ Löschen Sie den DataLake CloudFormation Stapel, bevor Sie den Vorgang erneut versuchen.
+ Vergewissern Sie sich, dass Sie mit Ihrer Amazon-Redshift-Datenbank verbunden sind.
+ Stellen Sie sicher, dass Sie die richtigen Informationen für den Namen des Amazon-Redshift-Clusters, den Datenbanknamen und den Namen des Datenbankbenutzers eingegeben haben.
### Abfragen Ihrer Daten in Amazon S3
Sie fragen externe Tabellen mit den gleichen SELECT-Anweisungen ab, mit denen Sie auch andere Amazon-Redshift-Tabellen abfragen. Diese SELECT-Anweisungsabfragen beinhalten die Verbindung von Tabellen, die Aggregierung von Daten und die Filterung auf Prädikaten.
Die folgende Abfrage gibt die Anzahl von Zeilen in der externen Tabelle `myspectrum_schema.sales` aus.
```
select count(*) from myspectrum_schema.sales;
```
```
count
------
172462
```
### Verbinden einer externen mit einer lokalen Tabelle
Das folgende Beispiel verbindet die externe Tabelle `myspectrum_schema.sales` mit der lokalen Tabelle `event`, um den Gesamtumsatz für die 10 führenden Veranstaltungen zu ermitteln.
```
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid) from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
```
```
eventid | sum
--------+---------
289 | 51846.00
7895 | 51049.00
1602 | 50301.00
851 | 49956.00
7315 | 49823.00
6471 | 47997.00
2118 | 47863.00
984 | 46780.00
7851 | 46661.00
5638 | 46280.00
```
### Aufrufen des Abfrageplans
Zeigen Sie den Abfrageplan für die vorherige Abfrage an. Beachten Sie, dass die Schritte `S3 Seq Scan`, `S3 HashAggregate` und `S3 Query Scan` für die Daten auf Amazon S3 ausgeführt wurden.
```
explain
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid)
from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
```
```
QUERY PLAN
-----------------------------------------------------------------------------
XN Limit (cost=1001055770628.63..1001055770628.65 rows=10 width=31)
-> XN Merge (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Merge Key: sum(sales.derived_col2)
-> XN Network (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Send to leader
-> XN Sort (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Sort Key: sum(sales.derived_col2)
-> XN HashAggregate (cost=1055770620.49..1055770620.99 rows=200 width=31)
-> XN Hash Join DS_BCAST_INNER (cost=3119.97..1055769620.49 rows=200000 width=31)
Hash Cond: ("outer".derived_col1 = "inner".eventid)
-> XN S3 Query Scan sales (cost=3010.00..5010.50 rows=200000 width=31)
-> S3 HashAggregate (cost=3010.00..3010.50 rows=200000 width=16)
-> S3 Seq Scan spectrum.sales location:"s3://redshift-downloads/tickit/spectrum/sales" format:TEXT (cost=0.00..2150.00 rows=172000 width=16)
Filter: (pricepaid > 30.00)
-> XN Hash (cost=87.98..87.98 rows=8798 width=4)
-> XN Seq Scan on event (cost=0.00..87.98 rows=8798 width=4)
```
# Fragen Sie Amazon S3 S3-Tabellen von Amazon Redshift ab
Amazon Redshift ist in Amazon S3 S3-Tabellen-Buckets integriert, sodass Sie mit Amazon Redshift auf S3-Tabellenressourcen zugreifen können. Ganz gleich, ob Sie gerade erst anfangen oder Tausende von Tabellen in Ihrer Iceberg-Umgebung verwalten, Tabellen-Buckets vereinfachen die Verwaltung von Data Lakes in jeder Größenordnung. Weitere Informationen finden Sie unter [Tabellen-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets.html).
In diesem Thema werden die ersten Schritte mit Amazon S3 Tables und Redshift sowie der Zugriff auf S3 Tables-Objekte mithilfe von Amazon Redshift beschrieben.
## Voraussetzungen
Bevor Sie S3-Tabellen von Amazon Redshift abfragen, müssen Sie S3-Tabellen mit integrieren. AWS Glue Data Catalog Anweisungen finden Sie unter [Integrieren von Amazon S3 S3-Tabellen mit AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/glue-federation-s3tables.html).
Nach der Integration von S3 Tables können IAM-Prinzipale mit den erforderlichen S3-Tabellen und AWS Glue IAM-Berechtigungen S3-Tabellen über den erkennen. AWS Glue Data Catalog AWS Glue Data Catalog
**Anmerkung**
Methode 3 (Automatisch gemounteter awsdatacatalog) erfordert zusätzliche Voraussetzungen. Details dazu finden Sie unter [Methode 3: Automatisch gemounteter AWS-Datenkatalog](#querying-s3Tables-method3).
## S3-Tabellen von Amazon Redshift abfragen
Gehen Sie folgendermaßen vor, um mit der Abfrage von S3-Tabellen zu beginnen:
+ Schritt 1: Eine IAM-Rolle für Amazon Redshift erstellen
+ Schritt 2: Fügen Sie Ihrem Amazon Redshift Redshift-Cluster eine IAM-Rolle hinzu
+ Schritt 3: S3-Tabellen von Amazon Redshift abfragen
### Schritt 1: Eine IAM-Rolle für Amazon Redshift erstellen
Ihr Cluster benötigt eine Autorisierung, um auf den externen S3-Tabellen-Katalog zugreifen zu können. AWS Glue Um diese Autorisierung bereitzustellen, verwendet Amazon Redshift eine IAM-Rolle, die Ihrem Cluster zugeordnet ist. Erstellen Sie eine IAM-Rolle mit den folgenden Richtlinienberechtigungen.
**Anmerkung**
Ersetzen Sie es in der Richtlinie und den Beispielen unten `us-west-2` durch Ihre AWS Region und `111122223333` durch Ihre AWS Konto-ID.
**Um eine Richtlinie zu erstellen:**
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie im Navigationsbereich **Richtlinien**.
1. Wählen Sie **Richtlinie erstellen** aus.
1. Wählen Sie den Tab **JSON**.
1. Fügen Sie das folgende JSON-Richtliniendokument ein:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "GlueDataCatalogPermissions",
"Effect": "Allow",
"Action": [
"glue:GetCatalog",
"glue:GetDatabase",
"glue:GetTable",
"glue:GetTables",
"glue:UpdateTable",
"glue:DeleteTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:catalog/s3tablescatalog",
"arn:aws:glue:us-west-2:111122223333:catalog/s3tablescatalog/*",
"arn:aws:glue:us-west-2:111122223333:database/s3tablescatalog/*/*",
"arn:aws:glue:us-west-2:111122223333:table/s3tablescatalog/*/*/*",
"arn:aws:glue:us-west-2:111122223333:database/*",
"arn:aws:glue:us-west-2:111122223333:table/*/*"
]
},
{
"Sid": "S3TablesDataAccessPermissions",
"Effect": "Allow",
"Action": [
"s3tables:GetTableBucket",
"s3tables:GetNamespace",
"s3tables:GetTable",
"s3tables:GetTableMetadataLocation",
"s3tables:GetTableData",
"s3tables:ListTableBuckets",
"s3tables:CreateTable",
"s3tables:PutTableData",
"s3tables:UpdateTableMetadataLocation",
"s3tables:ListNamespaces",
"s3tables:ListTables",
"s3tables:DeleteTable"
],
"Resource": [
"arn:aws:s3tables:us-west-2:111122223333:bucket/*",
"arn:aws:s3tables:us-west-2:111122223333:bucket/*/table/*"
]
}
]
}
```
1. Wählen Sie **Richtlinie prüfen**.
1. Geben Sie auf der Seite **„Richtlinie überprüfen**“ `GlueCatalogS3Tables_Policy` den **Namen** ein. Geben Sie optional eine Beschreibung ein. Lesen Sie die Richtlinienübersicht und wählen Sie dann **Richtlinie erstellen** aus.
**So erstellen Sie eine IAM-Rolle für Amazon Redshift:**
1. Öffnen Sie die [IAM-Konsole](https://console.aws.amazon.com/iam/).
1. Wählen Sie im Navigationsbereich **Roles** aus.
1. Wählen Sie **Create role** (Rolle erstellen) aus.
1. Wählen Sie **AWS Service** als vertrauenswürdige Entität und dann **Redshift** als Anwendungsfall.
1. Wählen **Sie unter Anwendungsfall für andere AWS Dienste** die Option **Redshift — Anpassbar** und dann **Weiter** aus.
1. Fügen Sie auf der Seite „**Berechtigungen hinzufügen**“ die `GlueCatalogS3Tables_Policy` Richtlinie an, die Sie oben erstellt haben. Wählen Sie **Weiter** aus.
1. Geben Sie in **Role name (Rollenname)** einen Namen für die Rolle ein, z. B. `RedshiftS3TablesRole`.
1. Überprüfen Sie die Informationen und wählen Sie dann **Rolle erstellen** aus.
1. Wählen Sie im Navigationsbereich **Rollen**. Wählen Sie den Namen Ihrer neuen Rolle aus, um die Zusammenfassung anzuzeigen, und kopieren Sie dann den **Rollen-ARN** in Ihre Zwischenablage. Sie verwenden diesen ARN, wenn Sie externe Schemas für S3-Tabellen-Namespaces erstellen.
**Anmerkung**
Beschränken Sie sich auf bestimmte Ressourcen, indem Sie den Platzhalter durch exakte Amazon-Ressourcennamen (ARNs) ersetzen.
### Schritt 2: Fügen Sie Ihrem Amazon Redshift Redshift-Cluster eine IAM-Rolle hinzu
Ordnen Sie die IAM-Rolle, die Sie in Schritt 1 konfiguriert haben, Ihrem Amazon Redshift Redshift-Cluster zu.
**Mithilfe der AWS Managementkonsole:**
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon Redshift Redshift-Konsole unter [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/).
1. Wählen Sie im Navigationsmenü **Clusters** (Cluster) und dann den Cluster aus, den Sie aktualisieren möchten.
1. Wählen Sie **unter Aktionen** die Option **IAM-Rollen verwalten** aus, um die aktuelle Liste der mit dem Cluster verknüpften IAM-Rollen anzuzeigen.
1. **Wählen Sie auf der Seite **„IAM-Rollen verwalten“ die IAM-Rolle** aus, die Sie hinzufügen möchten, und klicken Sie dann auf IAM-Rolle hinzufügen.**
1. Wählen Sie **Done (Beenden)**, um Ihre Änderungen zu speichern.
**Verwenden der AWS CLI:**
Führen Sie den folgenden Befehl aus, um eine IAM-Rolle einem vorhandenen Cluster oder Namespace zuzuordnen. Ersetzen Sie `my-redshift-cluster` oder `my-redshift-namespace` durch Ihre Cluster-ID oder Ihren Namespace und `111122223333` durch Ihre AWS Konto-ID.
```
aws redshift modify-cluster-iam-roles \
--cluster-identifier my-redshift-cluster \
--add-iam-roles arn:aws:iam::111122223333:role/RedshiftS3TablesRole
-- for serverless
aws redshift-serverless update-namespace \
--namespace-name my-redshift-namespace \
--iam-roles "arn:aws:iam::111122223333:role/RedshiftS3TablesRole"
```
Weitere Informationen finden Sie unter [Verknüpfen von IAM-Rollen mit Clustern](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) im *Amazon-Redshift-Verwaltungshandbuch*.
### Schritt 3: S3-Tabellen von Amazon Redshift abfragen
Wenn Sie S3-Tabellen mit integrieren AWS Glue Data Catalog, erstellt der Service eine föderierte Katalogstruktur, die Ressourcen von S3 Tables AWS Glue Katalogobjekten zuordnet:
+ Ein S3-Tabellen-Bucket wird zu einem **Katalog** im AWS Glue Data Catalog.
+ Ein S3-Namespace wird zu einer **AWS Glue Datenbank**.
+ Eine S3-Tabelle wird zu einem **AWS Glue Tabellenobjekt**.
Die Integration erstellt die folgende Hierarchie:
+ **Verbundkatalog:** `s3tablescatalog` (automatisch erstellt)
+ **Untergeordnete Kataloge:** Jeder S3-Tabellen-Bucket wird zu einem untergeordneten Katalog. `s3tablescatalog`
+ **Datenbanken:** Jeder S3-Namespace innerhalb eines Tabellen-Buckets wird zu einer Datenbank.
+ **Tabellen:** Jede S3-Tabelle innerhalb eines Namespace wird zu einer Tabelle.
Wenn Sie beispielsweise einen S3-Tabellen-Bucket `analytics-bucket` mit einem Namespace benannt haben, der eine Tabelle `sales` enthält`transactions`, AWS Glue Data Catalog wäre der vollständige Pfad in:. `s3tablescatalog/analytics-bucket/sales/transactions`
**Erstellen Sie einen Ressourcenlink**
Bevor Sie eine der drei unten aufgeführten Abfragemethoden verwenden können, müssen Sie einen Ressourcenlink in erstellen AWS Glue Data Catalog. Mithilfe von Ressourcenlinks kann Amazon Redshift über den Standardkatalog auf S3 Tables-Datenbanken verweisen.
*Mithilfe der AWS Glue Konsole:*
1. Öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Wählen Sie im Navigationsbereich **Datenbanken** aus.
1. Wählen Sie „**Erstellen**“ und anschließend „**Ressourcenlink**“.
1. Geben Sie auf der Seite **„Ressourcenlink erstellen**“ die folgenden Informationen ein:
+ **Name des Ressourcenlinks:** Geben Sie einen Namen für den Ressourcenlink ein (z. B.`sales_resource_link`).
+ **Gemeinsam genutzte Datenbank:** Geben Sie den Datenbankpfad für S3-Tabellen ein (z. B.`s3tablescatalog/analytics-bucket/sales`).
+ **Eigentümer der gemeinsam genutzten Datenbank:** Geben Sie Ihre AWS Konto-ID ein.
+ **Katalog-ID der gemeinsam genutzten Datenbank:** Geben Sie die Katalog-ID im folgenden Format ein`:s3tablescatalog/`.
1. Wählen Sie **Erstellen** aus.
*Verwenden der AWS CLI:*
```
aws glue create-database \
--region us-west-2 \
--cli-input-json '{
"CatalogId": "111122223333",
"DatabaseInput": {
"Name": "sales_resource_link",
"TargetDatabase": {
"CatalogId": "111122223333:s3tablescatalog/analytics-bucket",
"DatabaseName": "sales"
}
}
}'
```
Dieser Befehl erstellt einen Ressourcenlink mit dem Namen `sales_resource_link` in Ihrem AWS Glue Standard-Datenkatalog, der auf die `sales` Datenbank im S3-Tabellen-Bucket verweist`analytics-bucket`.
Sobald Ressourcenlinks erstellt wurden, bietet Amazon Redshift drei Methoden zur Abfrage von S3-Tabellen. Wählen Sie die Methode, die am besten zu Ihrem Anwendungsfall passt.
**Anmerkung**
Um einen Ressourcenlink auf Datenbankebene zu erstellen, muss der Redshift-Administrator über die `AWS Glue:CreateDatabase` Berechtigung für den Standardkatalog und die zu erstellende Datenbank verfügen.
#### Methode 1: EXTERNES SCHEMA ERSTELLEN
Verwenden Sie diese `CREATE EXTERNAL SCHEMA` Option, um ein externes Schema zu erstellen, das auf Ihre S3 Tables-Datenbank verweist. Diese Methode bietet eine explizite Kontrolle über die Benennung und Konfiguration von Schemas.
Vollständige Syntaxdetails finden Sie unter [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html) im *Amazon Redshift Database Developer Guide*.
**Beispiel**
Verwenden Sie den Datenbanknamen und die Katalog-ID aus Schritt 3. `111122223333`Ersetzen Sie es durch Ihre AWS Konto-ID.
```
CREATE EXTERNAL SCHEMA s3tables_schema
FROM DATA CATALOG DATABASE 'sales_resource_link'
IAM_ROLE 'arn:aws:iam::111122223333:role/RedshiftS3TablesRole'
REGION 'us-west-2'
CATALOG_ID '111122223333';
SELECT * FROM s3tables_schema.transactions;
```
#### Methode 2: DATENBANK AUS ARN ERSTELLEN
Verwenden Sie diese `CREATE DATABASE` `FROM ARN` Klausel, um eine Verbunddatenbank zu erstellen, die direkt auf Ihren AWS Glue Ressourcenlink verweist. Diese Methode ordnet die AWS Glue Datenbank automatisch einer Redshift-Datenbank zu.
Vollständige Syntaxdetails finden Sie unter [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) im *Amazon Redshift Database Developer Guide*.
**Beispiel**
Ersetzen Sie es `111122223333` durch Ihre AWS Konto-ID.
```
CREATE DATABASE s3tables_db
FROM ARN 'arn:aws:glue:us-west-2:111122223333:database/sales_resource_link'
WITH DATA CATALOG SCHEMA analytics_schema
IAM_ROLE 'arn:aws:iam::111122223333:role/RedshiftS3TablesRole';
SELECT * FROM s3tables_db.analytics_schema.transactions;
```
#### Methode 3: Automatisch gemounteter AWS-Datenkatalog
Amazon Redshift kann AWS Glue Data Catalog Datenbanken, einschließlich Ressourcenlinks für S3-Tabellen, automatisch über die `awsdatacatalog` Datenbank mounten. Für diese Methode muss der Verbundzugriff auf Spectrum (FAS) auf Ihrem Cluster aktiviert sein.
**Voraussetzungen**
Um die automatisch gemountete `awsdatacatalog` Datenbank verwenden zu können, müssen Sie den Verbundzugriff auf Spectrum aktivieren. Dadurch kann Amazon Redshift föderierte Identitätsanmeldedaten für den Zugriff auf externe AWS Glue Data Catalog Datenquellen verwenden.
Um den Verbundzugriff auf Spectrum zu aktivieren:
1. Stellen Sie mithilfe einer IAM-Identität mit den folgenden Berechtigungen eine Connect zu Ihrem Redshift-Cluster her:
+ `redshift:GetClusterCredentialsWithIAM`(für bereitgestellte Cluster) oder `redshift-serverless:GetCredentials` (für Serverless)
+ `AmazonS3ReadOnlyAccess`
+ `AWSGlueConsoleFullAccess`
+ Berechtigungen für S3-Tabellen (wie in Schritt 1 definiert)
1. Wenn Sie eine Verbindung mit einer IAM-Identität herstellen, erstellt Amazon Redshift automatisch einen Datenbankbenutzer mit dem Präfix `IAM:` (für Benutzer) oder `IAMR:` (für Rollen).
1. Erteilen Sie als Cluster-Administrator dem Verbundbenutzer Berechtigungen für den Zugriff auf das externe Schema. `my_user`Ersetzen Sie durch Ihre IAM-Rolle oder Ihren Benutzernamen:
```
GRANT ALL ON SCHEMA awsdatacatalog TO "IAMR:my_user";
```
Ausführliche Anweisungen zur Einrichtung des Verbundzugriffs finden Sie unter [Verwenden einer föderierten Identität zur Verwaltung des Amazon Redshift-Zugriffs auf lokale Ressourcen und externe Amazon Redshift Spectrum-Tabellen](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html) im *Amazon* Redshift Management Guide.
**S3-Tabellen abfragen**
Sobald der Verbundzugriff konfiguriert ist, überprüfen Sie die bereitgestellten Schemas und fragen Sie Ihre S3-Tabellen ab.
Überprüfen Sie die bereitgestellten Schemas:
```
SHOW SCHEMAS FROM DATABASE awsdatacatalog;
```
Fragen Sie S3-Tabellen mit dem Namen des Ressourcenlinks aus Schritt 3 ab:
```
SELECT * FROM awsdatacatalog.sales_resource_link.transactions;
```
# IAM-Richtlinien für Amazon Redshift Spectrum
In diesem Thema werden die erforderlichen IAM-Berechtigungen für die Verwendung von Redshift Spectrum beschrieben.
Standardmäßig verwendet Amazon Redshift Spectrum die AWS Regionen, die AWS Glue Data Catalog dies unterstützen AWS Glue. In anderen AWS Regionen verwendet Redshift Spectrum den Athena-Datenkatalog. Ihr Cluster benötigt eine Autorisierung, um auf Ihren externen Datenkatalog in AWS Glue oder Athena und Ihre Datendateien in Amazon S3 zuzugreifen. Sie erteilen diese Autorisierung, indem Sie auf eine AWS Identity and Access Management (IAM-) Rolle verweisen, die Ihrem Cluster zugeordnet ist. Wenn Sie einen Apache-Hive-Metastore zur Verwaltung Ihres Datenkatalogs verwenden, müssen Sie keinen Zugriff auf Athena ermöglichen.
Sie können Rollen miteinander verketten. Auf diese Weise kann der Cluster andere Rolle annehmen, die nicht dem Cluster angefügt sind. Weitere Informationen finden Sie unter [Verketten von IAM-Rollen in Amazon Redshift Spectrum](#c-spectrum-chaining-roles).
Der AWS Glue Katalog, auf den Sie zugreifen, ist möglicherweise verschlüsselt, um die Sicherheit zu erhöhen. Wenn der AWS Glue Katalog verschlüsselt ist, benötigen Sie den AWS KMS Schlüssel für, AWS Glue um auf den AWS Glue Datenkatalog zuzugreifen. Weitere Informationen finden Sie unter [Verschlüsseln Ihres AWS Glue Datenkatalogs](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) im *[AWS Glue Entwicklerhandbuch](https://docs.aws.amazon.com/glue/latest/dg/)*.
**Topics**
+ [Amazon-S3-Berechtigungen](#spectrum-iam-policies-s3)
+ [Kontoübergreifende Amazon-S3-Berechtigungen](#spectrum-iam-policies-cross-account)
+ [Richtlinien zum Gewähren oder Beschränken des Zugriffs mit Redshift Spectrum](#spectrum-iam-policies-spectrum-only)
+ [Richtlinien zum Gewähren von Mindestberechtigungen](#spectrum-iam-policies-minimum-permissions)
+ [Verketten von IAM-Rollen in Amazon Redshift Spectrum](#c-spectrum-chaining-roles)
+ [Steuern des Zugriffs auf den Datenkatalog AWS Glue](#c-spectrum-glue-acess)
## Amazon-S3-Berechtigungen
Ihr Cluster benötigt mindestens GET- und LIST-Zugriff zu Ihrem Amazon-S3-Bucket. Wenn sich Ihr Bucket nicht in demselben AWS Konto wie Ihr Cluster befindet, muss Ihr Bucket auch Ihren Cluster autorisieren, auf die Daten zuzugreifen. Weitere Informationen finden Sie unter [Autorisieren von Amazon Redshift, in Ihrem Namen auf andere AWS Dienste zuzugreifen](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html).
**Anmerkung**
Der Amazon-S3-Bucket kann keine Bucket-Richtlinie verwenden, die den Zugriff nur auf bestimmte VPC-Endpunkte beschränkt.
Die folgende Richtlinie gewährt GET- und LIST-Zugriff auf alle Amazon-S3-Buckets. Die Richtlinie erlaubt den Zugriff auf Amazon-S3-Buckets für Redshift Spectrum sowie COPY-Vorgänge.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": ["s3:Get*", "s3:List*"],
"Resource": "*"
}]
}
```
------
Die folgende Richtlinie gewährt GET- und LIST-Zugriff auf Ihren Amazon-S3-Bucket mit der Bezeichnung `amzn-s3-demo-bucket`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": ["s3:Get*", "s3:List*"],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}]
}
```
------
## Kontoübergreifende Amazon-S3-Berechtigungen
Um Redshift Spectrum die Erlaubnis zu erteilen, auf Daten in einem Amazon S3 S3-Bucket zuzugreifen, der zu einem anderen AWS Konto gehört, fügen Sie dem Amazon S3 S3-Bucket die folgende Richtlinie hinzu. Weitere Informationen finden Sie unter [ Beispiel 2: Bucket-Eigentümer erteilt kontoübergreifende Bucket-Berechtigungen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Example permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/spectrumrole"
},
"Action": [
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListMultipartUploadParts",
"s3:ListBucket",
"s3:ListBucketMultipartUploads"
],
"Resource": [
"arn:aws:s3:::bucketname",
"arn:aws:s3:::bucketname/*"
]
}
]
}
```
------
## Richtlinien zum Gewähren oder Beschränken des Zugriffs mit Redshift Spectrum
Die folgende Beispielrichtlinie ermöglicht den Zugriff auf Amazon-S3-Buckets für Amazon Redshift. Wenn Sie diese Richtlinie zu einer IAM-Rolle hinzufügen, empfehlen wir, eine IAM-Rolle zu verwenden, die nur für Amazon Redshift verwendet wird. Sie sollten vorhandene Rollen nicht wiederverwenden und dieser IAM-Rolle keine zusätzlichen Berechtigungen hinzufügen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucketVersions",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}
```
------
## Richtlinien zum Gewähren von Mindestberechtigungen
Die folgende Richtlinie gewährt die Mindestberechtigungen, die für die Verwendung von Redshift Spectrum mit Amazon S3 AWS Glue, und Athena erforderlich sind.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucketVersions",
"s3:ListBucket",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::bucketname",
"arn:aws:s3:::bucketname/folder1/folder2/*"
]
},
{
"Effect": "Allow",
"Action": [
"glue:CreateDatabase",
"glue:DeleteDatabase",
"glue:GetDatabase",
"glue:GetDatabases",
"glue:UpdateDatabase",
"glue:CreateTable",
"glue:DeleteTable",
"glue:BatchDeleteTable",
"glue:UpdateTable",
"glue:GetTable",
"glue:GetTables",
"glue:BatchCreatePartition",
"glue:CreatePartition",
"glue:DeletePartition",
"glue:BatchDeletePartition",
"glue:UpdatePartition",
"glue:GetPartition",
"glue:GetPartitions",
"glue:BatchGetPartition"
],
"Resource": "*"
}
]
}
```
------
Wenn Sie stattdessen Athena für Ihren Datenkatalog verwenden AWS Glue, erfordert die Richtlinie vollen Athena-Zugriff. Die folgende Richtlinie gewährt den Zugriff auf Athena-Ressourcen. Wenn sich Ihre externe Datenbank in einem Hive-Metastore befindet, benötigen Sie keinen Athena-Zugriff.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": ["athena:*"],
"Resource": ["*"]
}]
}
```
------
## Verketten von IAM-Rollen in Amazon Redshift Spectrum
Wenn Sie Ihrem Cluster eine Rolle zuordnen, kann Ihr Cluster diese Rolle übernehmen, um auf Amazon S3, Athena und in AWS Glue Ihrem Namen zuzugreifen. Wenn eine an den Cluster angefügte Rolle keinen Zugriff auf die erforderlichen Ressourcen hat, können Sie mit ihr eine andere Rolle verketten, die möglicherweise zu einem anderen Konto gehört. Ihr Cluster nimmt dann vorübergehend die verkettete Rolle an, um auf die Daten zuzugreifen. Sie können über verkettete Rollen auch kontoübergreifenden Zugriff gewähren. Sie können maximal 10 Rollen miteinander verketten. Jede Rolle in der Kette nimmt die nächste Rolle in der Kette an, bis hin zum Cluster, der die Rolle am Ende der Kette annimmt.
Zum Verketten von Rollen richten Sie eine Vertrauensstellung zwischen den Rollen ein. Eine Rolle, die eine andere Rolle annimmt, muss über eine Berechtigungsrichtlinie verfügen, die es ihr erlaubt, die angegebene Rolle anzunehmen. Die Rolle, die Berechtigungen übergibt, muss wiederum über eine Vertrauensstellung verfügen, die es ihr erlaubt, ihre Berechtigungen an eine andere Rolle zu übergeben. Weitere Informationen finden Sie unter [Verketten von IAM-Rollen in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles).
Wenn Sie den Befehl CREATE EXTERNAL SCHEMA ausführen, können Sie Rollen verketten, indem Sie eine durch Kommas getrennte Rollenliste hinzufügen. ARNs
**Anmerkung**
Die Liste der verketteten Rollen darf keine Leerstellen enthalten.
Im folgenden Beispiel wird `MyRedshiftRole` an den Cluster angehängt. `MyRedshiftRole` nimmt die Rolle `AcmeData` an, die zum Konto `111122223333` gehört.
```
create external schema acme from data catalog
database 'acmedb' region 'us-west-2'
iam_role 'arn:aws:iam::123456789012:role/MyRedshiftRole,arn:aws:iam::111122223333:role/AcmeData';
```
## Steuern des Zugriffs auf den Datenkatalog AWS Glue
Wenn Sie dies AWS Glue für Ihren Datenkatalog verwenden, können Sie mit Ihrer IAM-Richtlinie eine differenzierte Zugriffskontrolle auf den AWS Glue Datenkatalog anwenden. Beispielsweise können Sie festlegen, dass nur bestimmte Datenbanken und Tabellen für eine spezifische IAM-Rolle bereitgestellt werden.
In den folgenden Abschnitten werden die IAM-Richtlinien für verschiedene Zugriffsebenen auf im Datenkatalog gespeicherte Daten beschrieben. AWS Glue
**Topics**
+ [Richtlinie für Datenbankoperationen](#c-spectrum-glue-acess-database)
+ [Richtlinie für Tabellenoperationen](#c-spectrum-glue-acess-tables)
+ [Richtlinie für Partitionsoperationen](#c-spectrum-glue-acess-partitions)
### Richtlinie für Datenbankoperationen
Wenn Sie Benutzern Berechtigungen zum Anzeigen und Erstellen einer Datenbank erteilen möchten, benötigen sie Zugriffsrechte sowohl für die Datenbank als auch für den AWS Glue Datenkatalog.
Mit der folgenden Beispielabfrage wird eine Datenbank erstellt.
```
CREATE EXTERNAL SCHEMA example_db
FROM DATA CATALOG DATABASE 'example_db' region 'us-west-2'
IAM_ROLE 'arn:aws:iam::redshift-account:role/spectrumrole'
CREATE EXTERNAL DATABASE IF NOT EXISTS
```
Mit der folgenden IAM-Richtlinie werden die zum Erstellen einer Datenbank benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetDatabase",
"glue:CreateDatabase"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:catalog"
]
}
]
}
```
------
Mit der folgenden Beispielabfrage werden die aktuellen Datenbanken aufgelistet.
```
SELECT * FROM SVV_EXTERNAL_DATABASES WHERE
databasename = 'example_db1' or databasename = 'example_db2';
```
Mit der folgenden IAM-Richtlinie werden die zum Auflisten der aktuellen Datenbanken benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetDatabases"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:database/example_db1",
"arn:aws:glue:us-west-2:111122223333:database/example_db2",
"arn:aws:glue:us-west-2:111122223333:catalog"
]
}
]
}
```
------
### Richtlinie für Tabellenoperationen
Wenn Sie Benutzern Berechtigungen für View, Create, Drop, Alter oder andere Aktionen für Tabellen erteilen möchten, benötigen sie mehrere Zugriffsarten. Sie benötigen Zugriff auf die Tabellen selbst, die Datenbanken, zu denen sie gehören, und den Katalog.
Mit der folgenden Beispielabfrage wird eine externe Tabelle erstellt.
```
CREATE EXTERNAL TABLE example_db.example_tbl0(
col0 INT,
col1 VARCHAR(255)
) PARTITIONED BY (part INT) STORED AS TEXTFILE
LOCATION 's3://test/s3/location/';
```
Mit der folgenden IAM-Richtlinie werden die zum Erstellen einer externen Tabelle benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
Mit den folgenden Beispielabfragen werden die aktuellen externen Tabellen aufgelistet.
```
SELECT * FROM svv_external_tables
WHERE tablename = 'example_tbl0' OR
tablename = 'example_tbl1';
```
```
SELECT * FROM svv_external_columns
WHERE tablename = 'example_tbl0' OR
tablename = 'example_tbl1';
```
```
SELECT parameters FROM svv_external_tables
WHERE tablename = 'example_tbl0' OR
tablename = 'example_tbl1';
```
Mit der folgenden IAM-Richtlinie werden die zum Auflisten der aktuellen externen Tabellen benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetTables"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl1"
]
}
]
}
```
------
Mit der folgenden Beispielabfrage wird eine vorhandene Tabelle geändert.
```
ALTER TABLE example_db.example_tbl0
SET TABLE PROPERTIES ('numRows' = '100');
```
Mit der folgenden IAM-Richtlinie werden die zum Ändern einer vorhandenen Tabelle benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetTable",
"glue:UpdateTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
Mit der folgenden Beispielabfrage wird eine vorhandene Tabelle entfernt.
```
DROP TABLE example_db.example_tbl0;
```
Mit der folgenden IAM-Richtlinie werden die zum Entfernen einer vorhandenen Tabelle benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:DeleteTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
### Richtlinie für Partitionsoperationen
Wenn Sie Benutzern die Berechtigung zum Ausführen von Vorgängen auf Partitionsebene (Anzeigen, Erstellen, Entfernen, Ändern usw.) erteilen möchten, benötigen sie Berechtigungen für die Tabellen, zu denen die Partitionen gehören. Sie benötigen darüber hinaus Berechtigungen für die zugehörigen Datenbanken und den AWS Glue -Datenkatalog.
Mit der folgenden Beispielabfrage wird eine Partition erstellt.
```
ALTER TABLE example_db.example_tbl0
ADD PARTITION (part=0) LOCATION 's3://test/s3/location/part=0/';
ALTER TABLE example_db.example_t
ADD PARTITION (part=1) LOCATION 's3://test/s3/location/part=1/';
```
Mit der folgenden IAM-Richtlinie werden die zum Erstellen einer Partition benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetTable",
"glue:BatchCreatePartition"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
Mit der folgenden Beispielabfrage werden die aktuellen Partitionen aufgelistet.
```
SELECT * FROM svv_external_partitions
WHERE schemname = 'example_db' AND
tablename = 'example_tbl0'
```
Mit der folgenden IAM-Richtlinie werden die zum Auflisten der aktuellen Partitionen benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetPartitions",
"glue:GetTables",
"glue:GetTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
Mit der folgenden Beispielabfrage wird eine vorhandene Partition geändert.
```
ALTER TABLE example_db.example_tbl0 PARTITION(part='0')
SET LOCATION 's3://test/s3/new/location/part=0/';
```
Mit der folgenden IAM-Richtlinie werden die zum Ändern einer vorhandenen Partition benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetPartition",
"glue:UpdatePartition"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
Mit der folgenden Beispielabfrage wird eine vorhandene Partition entfernt.
```
ALTER TABLE example_db.example_tbl0 DROP PARTITION(part='0');
```
Mit der folgenden IAM-Richtlinie werden die zum Entfernen einer vorhandenen Partition benötigten Mindestberechtigungen erteilt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:DeletePartition"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
# Redshift Spectrum und AWS Lake Formation
In diesem Thema wird die Verwendung von Redshift Spectrum mit Lake Formation beschrieben. Lake Formation ist ein Service für den Austausch von Analytikdaten.
Sie können AWS Lake Formation damit zentral Zugriffsrichtlinien auf Datenbank-, Tabellen- und Spaltenebene für in Amazon S3 gespeicherte Daten definieren und durchsetzen. Nachdem Ihre Daten bei einem mit Lake Formation aktivierten AWS Glue Data Catalog registriert wurden, können Sie Abfragen über verschiedene Services senden, darunter auch Redshift Spectrum.
Lake Formation sorgt für die Sicherheit und Governance des Datenkatalogs. Sie können innerhalb von Lake Formation Berechtigungen für die Datenkatalogobjekte wie Datenbanken, Tabellen, Spalten und zugrundeliegenden Amazon-S3-Speicher gewähren und widerrufen.
**Wichtig**
Sie können Redshift Spectrum mit einem Datenkatalog, für den Lake Formation aktiviert ist, nur in AWS Regionen verwenden, in denen Lake Formation verfügbar ist. Eine Liste der verfügbaren Regionen finden Sie unter [AWS Lake Formation -Endpunkte und -Kontingente](https://docs.aws.amazon.com/general/latest/gr/lake-formation.html) im *Allgemeine AWS-Referenz*.
Wenn Sie Redshift Spectrum mit Lake Formation verwenden, haben Sie folgende Möglichkeiten:
+ Verwenden Sie Lake Formation für die zentrale Steuerung von Berechtigungen und Zugriffskontrollrichtlinien für alle Ihre Daten im Data Lake. Lake Formation stellt eine Berechtigungshierarchie bereit, mit der Sie den Zugriff auf Datenbanken und Tabellen in einem Datenkatalog steuern können. Weitere Informationen finden Sie unter [Übersicht über Lake-Formation-Berechtigungen](https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html) im *AWS Lake Formation -Entwicklerhandbuch*.
+ Erstellen Sie externe Tabellen und führen Sie Abfragen zu Daten im Data Lake aus. Bevor Benutzer in Ihrem Konto Abfragen ausführen können, registriert ein Data Lake-Kontoadministrator Ihre vorhandenen Amazon-S3-Pfade, die Quelldaten enthalten, mit Lake Formation. Der Administrator erstellt auch Tabellen und gewährt den Benutzern Berechtigungen. Zugriff kann auf Datenbanken, Tabellen oder Spalten gewährt werden. Der Administrator kann Datenfilter in Lake Formation verwenden, um eine detaillierte Zugriffskontrolle für Ihre sensiblen Daten zu gewähren, die in Amazon S3 gespeichert sind. Weitere Informationen finden Sie unter [Verwenden von Datenfiltern für die Sicherheit auf Zeilen- und Zellenebene](#spectrum-lake-formation-data-filters).
Nachdem die Daten im Datenkatalog registriert wurden, verifiziert Lake Formation jedes Mal, wenn Benutzer versuchen, Abfragen auszuführen, ob sie Zugriff auf die Tabelle für diesen spezifischen Prinzipal haben. Lake Formation vergibt temporäre Anmeldeinformationen an Redshift Spectrum und die Abfrage wird ausgeführt.
+ Führen Sie Redshift Spectrum-Abfragen AWS Glue Data Catalog anhand automatisch gemounteter IAM-Anmeldeinformationen aus, die Sie mit `GetCredentials` oder erhalten haben`GetClusterCredentials`, und verwalten Sie Lake Formation Formation-Berechtigungen nach Datenbankbenutzern (iamr:Username oder iam:Username).
Wenn Sie Redshift Spectrum mit einem für Lake Formation aktivierten Datenkatalog verwenden, muss eines der im Folgenden Genannten vorhanden sein:
+ Eine IAM-Rolle, die dem Cluster zugeordnet ist und über die Berechtigung für den Datenkatalog verfügt.
+ Eine IAM-Verbundidentität, die für die Verwaltung des Zugriffs auf externe Ressourcen konfiguriert ist. Weitere Informationen finden Sie unter [Verwenden einer Verbundidentität zur Verwaltung des Amazon-Redshift-Zugriffs auf lokale Ressourcen und externe Amazon-Redshift-Tabellen](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html).
**Wichtig**
Wenn Sie Redshift Spectrum mit einem für Lake Formation aktivierten Datenkatalog verwenden, können Sie IAM-Rollen nicht verketten.
*Weitere Informationen zu den Schritten, die AWS Lake Formation zur Einrichtung für die Verwendung mit Redshift Spectrum erforderlich sind, finden Sie unter [Tutorial: Erstellen eines Data Lake aus einer JDBC-Quelle in Lake Formation im AWS Lake Formation Developer](https://docs.aws.amazon.com/lake-formation/latest/dg/getting-started-tutorial-jdbc.html) Guide.* Weitere Informationen zur Integration in Redshift Spectrum finden Sie insbesondere unter [Abfrage der Daten im Data Lake mit Amazon Redshift Spectrum](https://docs.aws.amazon.com/lake-formation/latest/dg/tut-query-redshift.html). Die in diesem Thema verwendeten Daten und AWS Ressourcen hängen von den vorherigen Schritten im Tutorial ab.
## Verwenden von Datenfiltern für die Sicherheit auf Zeilen- und Zellenebene
Sie können Datenfilter definieren, AWS Lake Formation um den Zugriff Ihrer Redshift Spectrum-Abfragen auf Zeilen- und Zellenebene auf Daten zu steuern, die in Ihrem Datenkatalog definiert sind. Dazu führen Sie die folgenden Aufgaben aus:
+ Erstellen Sie in Lake Formation einen Datenfilter mit den folgenden Informationen:
+ Eine Spaltenspezifikation mit einer Liste von Spalten, die in Abfrageergebnissen ein- oder ausgeschlossen werden sollen.
+ Ein Zeilenfilterausdruck, der die Zeilen angibt, die in die Abfrageergebnisse aufgenommen werden sollen.
Weitere Informationen zum Erstellen eines Datenfilters finden Sie unter [Datenfilter in Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/data-filters-about.html) im *AWS Lake Formation -Entwicklerhandbuch*.
+ Erstellen Sie eine externe Tabelle in Amazon Redshift, die auf eine Tabelle in Ihrem Datenkatalog verweist, der für Lake Formation aktiviert ist. Weitere Informationen zum Abfragen einer Lake-Formation-Tabelle mithilfe von Redshift Spectrum finden Sie unter [Abfrage der Daten im Data Lake mit Amazon Redshift Spectrum](https://docs.aws.amazon.com/lake-formation/latest/dg/tut-query-redshift.html) im *AWS Lake Formation -Entwicklerhandbuch*.
Nachdem die Tabelle in Amazon Redshift definiert wurde, können Sie die Lake-Formation-Tabelle abfragen und nur auf die Zeilen und Spalten zugreifen, die vom Datenfilter zugelassen sind.
Eine ausführliche Anleitung zum Einrichten der Sicherheit auf Zeilen- und Zellenebene in Lake Formation und zum anschließenden Abfragen mithilfe von Redshift Spectrum finden Sie unter [Verwenden von Amazon Redshift Spectrum mit Sicherheitsrichtlinien auf Zeilen- und Zellebene, die in AWS Lake Formation definiert sind](https://aws.amazon.com/blogs/big-data/use-amazon-redshift-spectrum-with-row-level-and-cell-level-security-policies-defined-in-aws-lake-formation/).
# Datendateien für Abfragen in Amazon Redshift Spectrum
In diesem Abschnitt wird beschrieben, wie Sie Datendateien in Amazon S3 in einem Format erstellen, das Redshift Spectrum unterstützt.
Die Datendateien, die Sie für Abfragen in Amazon Redshift Spectrum verwenden, sind im Allgemeinen dieselben Dateitypen, die Sie für andere Anwendungen verwenden. Beispielsweise werden dieselben Dateitypen mit Amazon Athena, Amazon EMR und Quick verwendet. Sie können die Daten im Originalformat direkt aus Amazon S3 abfragen. Dazu müssen die Datendateien in einem Format vorliegen, das Redshift Spectrum unterstützt und sich in einem Amazon-S3-Bucket befinden, auf den Ihr Cluster zugreifen kann.
Der Amazon S3 S3-Bucket mit den Datendateien und der Amazon Redshift Redshift-Cluster müssen sich in derselben AWS Region befinden. Informationen zu den unterstützten AWS Regionen finden Sie unter[Amazon-Redshift-Spectrum-Regionen](c-spectrum-overview.md#c-spectrum-regions).
## Datenformate für Redshift Spectrum
Redshift Spectrum unterstützt die folgenden strukturierten und halbstrukturierten Datenformate.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/c-spectrum-data-files.html)
In der vorhergehenden Tabelle geben die Überschriften Folgendes an:
+ **Columnar (Spaltenorientiert)** – Gibt an, ob das Dateiformat Daten physisch in einer spaltenorientierten Struktur im Gegensatz zu einer zeilenorientierten Struktur speichert.
+ **Supports Parallel reads (Unterstützt parallele Lesevorgänge)** – Gibt an, ob das Dateiformat das Lesen einzelner Blöcke innerhalb der Datei unterstützt. Das Lesen einzelner Blöcke ermöglicht die verteilte Verarbeitung einer Datei über mehrere unabhängige Redshift-Spectrum-Anfragen, anstatt die vollständige Datei in einer einzigen Anforderung lesen zu müssen.
+ **Split Unit (Geteilte Einheit)** – Bei Dateiformaten, die parallel gelesen werden können, ist die geteilte Einheit der kleinste Datenblock, den eine einzelne Redshift-Spectrum-Anforderung verarbeiten kann.
**Anmerkung**
Die Zeitstempelwerte in Textdateien müssen das Format `yyyy-MM-dd HH:mm:ss.SSSSSS` haben, wie der folgende Zeitstempelwert zeigt: `2017-05-01 11:30:59.000000`.
Wir empfehlen die Verwendung eines nach Spalten organisierten Speicherdateiformats, wie etwa Apache Parquet. Amazon Redshift unterstützt das Apache Parquet v1-Datendateiformat. Mit einem solchen Format minimieren Sie die Datenübertragung aus Amazon S3, indem Sie nur die benötigten Spalten auswählen.
## Komprimierungstypen für Redshift Spectrum
Um den Speicherplatz zu reduzieren, die Leistung zu verbessern und die Kosten zu minimieren, empfehlen wir dringend, Ihre Datendateien zu komprimieren. Redshift Spectrum erkennt Dateikomprimierungstypen anhand der Dateierweiterung.
Redshift Spectrum unterstützt die folgenden Komprimierungstypen und Erweiterungen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/c-spectrum-data-files.html)
Amazon Redshift unterstützt außerdem die Komprimierung Zstandard (zstd) für Apache Parquet-Dateien und Apache Iceberg-Tabellen.
Sie können die Komprimierung auf verschiedenen Ebenen anwenden. Zumeist komprimieren Sie eine ganze Datei oder einzelne Blöcke innerhalb einer Datei. Das Komprimieren von Spaltenformaten auf Dateiebene bringt keine Leistungsvorteile.
Damit Redshift Spectrum eine Datei parallel lesen kann, muss Folgendes zutreffen:
+ Das Dateiformat unterstützt parallele Lesevorgänge.
+ Die Komprimierung auf Dateiebene (falls vorhanden) unterstützt parallele Lesevorgänge.
Es spielt keine Rolle, ob die einzelnen geteilten Einheiten innerhalb einer Datei mit einem Komprimierungsalgorithmus komprimiert werden, der parallel gelesen werden kann, da jede geteilte Einheit von einer einzigen Redshift-Spectrum-Anforderung verarbeitet wird. Ein Beispiel dafür sind Snappy-komprimierte Parquet-Dateien. Einzelne Zeilengruppen innerhalb der Parquet-Datei werden mit Snappy komprimiert, aber die oberste Struktur der Datei bleibt unkomprimiert. In diesem Fall kann die Datei parallel gelesen werden, da jede Redshift-Spectrum-Anforderung einzelne Zeilengruppen von Amazon S3 lesen und verarbeiten kann.
## Verschlüsselung für Redshift Spectrum
Redshift Spectrum entschlüsselt in transparenter Weise Datendateien, die mit den folgenden Verschlüsselungsoptionen verschlüsselt wurden:
+ Serverseitige Verschlüsselung (SSE-S3) mit einem von Amazon S3 verwalteten AES-256-Verschlüsselungsschlüssel.
+ Serverseitige Verschlüsselung mit Schlüsseln, die von AWS Key Management Service (SSE-KMS) verwaltet werden.
Redshift Spectrum unterstützt die clientseitige Amazon-S3-Verschlüsselung nicht. Weitere Informationen zur serverseitigen Verschlüsselung finden Sie unter [Schutz von Daten mittels serverseitiger Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) im *Amazon-Simple-Storage-Service-Benutzerhandbuch*.
Amazon Redshift unterstützt die massiv parallele Verarbeitung (Massively Parallel Processing, MPP) für die schnelle Ausführung komplexer Abfragen für sehr große Datenmengen. Redshift Spectrum verwendet das gleiche Prinzip auch für die Abfrage externer Daten und nutzt nach Bedarf mehrere Redshift Spectrum-Instances zum Scanning von Dateien. Setzen Sie die Dateien in separate Ordner für jede Tabelle.
Sie können mithilfe der folgenden Verfahren Ihre Daten für die parallele Verarbeitung optimieren:
+ Wenn Ihr Dateiformat oder Ihre Komprimierung das parallele Lesen nicht unterstützt, teilen Sie große Dateien in viele kleinere Dateien auf. Wir empfehlen Dateigrößen zwischen 64 MB und 1 GB.
+ Sorgen Sie dafür, dass alle Dateien etwa die gleiche Größe haben. Wenn einige Dateien viel größer als andere sind, kann Redshift Spectrum den Workload nicht gleichmäßig verteilen.
# Externe Schemata in Amazon Redshift Spectrum
In diesem Thema wird beschrieben, wie Sie externe Schemata mit Redshift Spectrum erstellen und verwenden. Externe Schemata sind Sammlungen von Tabellen, die Sie als Verweise für den Zugriff auf Daten außerhalb Ihres Amazon-Redshift-Clusters verwenden. Diese Tabellen enthalten Metadaten zu den externen Daten, die Redshift Spectrum liest.
Alle externen Tabellen müssen in einem externen Schema erstellt werden, das Sie mit einer [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)-Anweisung erstellen.
**Anmerkung**
Einige Anwendungen verwenden die Begriffe *Datenbank* und *Schema* mit gleicher Bedeutung. In Amazon Redshift verwenden wir den Begriff *Schema*.
Ein externes Amazon-Redshift-Schema verweist auf eine externe Datenbank in einem externen Datenkatalog. Sie können die externe Datenbank in Amazon Redshift, [in Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/catalog.html), in [AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/components-overview.html#data-catalog-intro) oder in einem Apache-Hive-Metastore, wie etwa [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html), erstellen. Wenn Sie eine externe Datenbank in Amazon Redshift erstellen, befindet sich diese im Athena-Datenkatalog. Zur Erstellung einer Datenbank in einem Hive-Metastore müssen Sie sie in Ihrer Hive-Anwendung erstellen.
Amazon Redshift benötigt in Ihrem Namen die Autorisierung zum Zugriff auf den Datenkatalog in Athena und die Datendateien in Amazon S3. Um diese Autorisierung bereitzustellen, erstellen Sie zunächst eine AWS Identity and Access Management (IAM-) Rolle. Dann fügen Sie die Rolle Ihrem Cluster hinzu und stellen den Amazon-Ressourcennamen (ARN) für die Rolle in der `CREATE EXTERNAL SCHEMA`-Anweisung von Amazon Redshift bereit. Weitere Informationen zur -Autorisierung finden Sie unter [IAM-Richtlinien für Amazon Redshift Spectrum](c-spectrum-iam-policies.md).
Um eine externe Datenbank gleichzeitig mit der Erstellung eines externen Schemas zu erstellen, geben Sie `FROM DATA CATALOG` an, und schließen Sie die `CREATE EXTERNAL DATABASE`-Klausel in Ihre `CREATE EXTERNAL SCHEMA`-Anweisung ein.
Das folgende Beispiel erstellt ein externes Schema mit der Bezeichnung `spectrum_schema` unter Verwendung der externen Datenbank `spectrum_db`.
```
create external schema spectrum_schema from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
create external database if not exists;
```
Wenn Sie Ihren Datenkatalog mit Athena verwalten, geben Sie den Athena-Datenbanknamen und die AWS -Region an, in der sich der Athena-Datenkatalog befindet.
Das folgende Beispiel erstellt ein externes Schema mit der Standarddatenbank `sampledb` im Athena-Datenkatalog.
```
create external schema athena_schema from data catalog
database 'sampledb'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
region 'us-east-2';
```
**Anmerkung**
Der `region` Parameter bezieht sich auf die AWS Region, in der sich der Athena-Datenkatalog befindet, nicht auf den Speicherort der Datendateien in Amazon S3.
Wenn Sie Ihren Datenkatalog mit einem Hive-Metastore, etwa mit Amazon EMR, verwalten, müssen Ihre Sicherheitsgruppen so konfiguriert sein, dass der Datenverkehr zwischen den Clustern möglich ist.
Geben Sie in der CREATE EXTERNAL SCHEMA-Anweisung `FROM HIVE METASTORE` an, und schließen Sie die URI und die Portnummer des Metastores ein. Im folgenden Beispiel wird ein externes Schema mittels einer Hive-Metastore-Datenbank namens erstellt `hive_db`.
```
create external schema hive_schema
from hive metastore
database 'hive_db'
uri '172.10.10.10' port 99
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
```
Um die externen Schemata für Ihren Cluster anzuzeigen, fragen Sie die Katalogtabelle PG\$1EXTERNAL\$1SCHEMA oder die Ansicht SVV\$1EXTERNAL\$1SCHEMAS ab. Das folgende Beispiel fragt SVV\$1EXTERNAL\$1SCHEMAS ab, wobei PG\$1EXTERNAL\$1SCHEMA und PG\$1NAMESPACE verbunden werden.
```
select * from svv_external_schemas
```
Für die vollständige Befehlssyntax und Beispiele vgl. [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
## Arbeiten mit externen Katalogen in Amazon Redshift Spectrum
Die Metadaten für externe Amazon-Redshift-Spectrum-Datenbanken und externe Tabellen werden in einem externen Datenkatalog gespeichert. Standardmäßig werden Redshift-Spectrum-Metadaten in einem Athena-Datenkatalog gespeichert. Sie können Redshift-Spectrum-Datenbanken und -Tabellen in Ihrer Athena-Konsole anzeigen und verwalten.
Sie können externe Datenbanken und externe Tabellen auch mit der Hive-Data-Definition-Language (DDL) unter Verwendung von Athena oder eines Hive-Metastores wie Amazon EMR erstellen und verwalten.
**Anmerkung**
Wir empfehlen die Verwendung von Amazon Redshift zur Erstellung und Verwaltung Ihrer externen Redshift-Spectrum-Datenbanken und externer Tabellen.
### Redshift Spectrum-Datenbanken in Athena anzeigen und AWS Glue
Sie können eine externe Datenbank erstellen, indem Sie die Klausel CREATE EXTERNAL DATABASE IF NOT EXISTS in Ihre CREATE EXTERNAL SCHEMA-Anweisung aufnehmen. In solchen Fällen werden die Metadaten der externen Datenbank in Ihrem Datenkatalog gespeichert. Die Metadaten für externe Tabellen, die Sie mit Qualifizierung durch das externe Schema erstellen, werden ebenfalls in Ihrem -Datenkatalog gespeichert.
Athena und AWS Glue pflegen einen Datenkatalog für jeden unterstützten AWS-Region. Um Tabellenmetadaten anzuzeigen, melden Sie sich bei Athena oder der AWS Glue Konsole an. Wählen Sie in Athena **Data sources**, your AWS Glue, und zeigen Sie dann die Details Ihrer Datenbank an. Wählen Sie in AWS Glue**Datenbanken**, Ihre externe Datenbank, und zeigen Sie dann die Details Ihrer Datenbank an.
Wenn Sie Ihre externen Tabellen mit Athena erstellen und verwalten, registrieren Sie die Datenbank mit CREATE EXTERNAL SCHEMA. Beispielsweise registriert der folgende Befehl die Athena-Datenbank mit der Bezeichnung `sampledb`.
```
create external schema athena_sample
from data catalog
database 'sampledb'
iam_role 'arn:aws:iam::123456789012:role/mySpectrumRole'
region 'us-east-1';
```
Wenn Sie die Systemansicht SVV\$1EXTERNAL\$1TABLES abfragen, sehen Sie Tabellen in der Athena-`sampledb`-Datenbank und die Tabellen, die Sie in Amazon Redshift erstellt haben.
```
select * from svv_external_tables;
```
```
schemaname | tablename | location
--------------+------------------+--------------------------------------------------------
athena_sample | elb_logs | s3://athena-examples/elb/plaintext
athena_sample | lineitem_1t_csv | s3://myspectrum/tpch/1000/lineitem_csv
athena_sample | lineitem_1t_part | s3://myspectrum/tpch/1000/lineitem_partition
spectrum | sales | s3://redshift-downloads/tickit/spectrum/sales
spectrum | sales_part | s3://redshift-downloads/tickit/spectrum/sales_part
```
### Registrieren einer Apache Hive-Metastore-Datenbank
Wenn Sie externe Tabellen in einem Apache Hive-Metastore erstellen, können Sie diese Tabellen mit CREATE EXTERNAL SCHEMA in Redshift Spectrum registrieren.
Geben Sie in der CREATE EXTERNAL SCHEMA-Anweisung die Klausel FROM HIVE METASTORE sowie die URI und die Portnummer des Hive-Metastores an. Die IAM-Rolle muss die Berechtigung zum Zugriff auf Amazon S3 enthalten, Athena-Berechtigungen sind jedoch nicht erforderlich. Das folgende Beispiel registriert einen Hive-Metastore.
```
create external schema if not exists hive_schema
from hive metastore
database 'hive_database'
uri 'ip-10-0-111-111.us-west-2.compute.internal' port 9083
iam_role 'arn:aws:iam::123456789012:role/mySpectrumRole';
```
### Zugriff Ihres Amazon-Redshift-Clusters auf Ihren Amazon-EMR-Cluster
Wenn sich Ihr Hive-Metastore in Amazon EMR befindet, müssen Sie Ihrem Amazon-Redshift-Cluster den Zugriff auf Ihren Amazon-Redshift-Cluster gewähren. Dazu erstellen Sie eine Amazon-EC2-Sicherheitsgruppe. Sie lassen dann den gesamten eingehenden Datenverkehr an die EC2-Sicherheitsgruppe aus der Sicherheitsgruppe Ihres Amazon-Redshift-Clusters und der Sicherheitsgruppe Ihres Amazon-EMR-Clusters zu. Dann fügen Sie die EC2-Sicherheitsgruppe Ihrem Amazon-Redshift-Cluster und Ihrem Amazon-EMR-Cluster hinzu.
**Aufrufen des Namens der Sicherheitsgruppe Ihres Amazon-Redshift-Clusters**
Um die Sicherheitsgruppe anzuzeigen, gehen Sie wie folgt vor:
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon Redshift Redshift-Konsole unter [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/).
1. Wählen Sie im Navigationsmenü die Option **Clusters** (Cluster) und anschließend in der Liste den gewünschten Cluster aus, um die Details zu dem Cluster zu öffnen.
1. Wählen Sie **Properties** (Eigenschaften) aus und sehen Sie sich den Abschnitt **Network and security** (Netzwerk und Sicherheit) an.
1. Machen Sie Ihre Sicherheitsgruppe in **VPC Security Group** (VPC-Sicherheitsgruppe) ausfindig und notieren Sie sie.
****
**Aufrufen des Namens der Amazon-EMR-Hauptknoten-Sicherheitsgruppe**
1. Öffnen Sie Ihren Amazon-EMR-Cluster. Weitere Informationen finden Sie unter [Verwenden von Sicherheitskonfigurationen zur Einrichtung der Clustersicherheit](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-security-configurations.html) im *Amazon-EMR-Verwaltungshandbuch*
1. Notieren Sie sich unter **Security and access** (Sicherheit und Zugriff) den Namen der Amazon-EMR-Hauptknoten-Sicherheitsgruppe.
![\[Ein Screenshot, der den Namen der Amazon-EMR-Hauptknoten-Sicherheitsgruppe in der Amazon-EMR-Konsole hervorhebt.\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/images/spectrum-emr-security-groups.png)
**So erstellen oder modifizieren Sie eine Amazon-EC2-Sicherheitsgruppe, um eine Verbindung zwischen Amazon Redshift und Amazon EMR zuzulassen**
1. Wählen Sie im Amazon-EC2-Dashboard **Security Groups** (Sicherheitsgruppen) aus. Weitere Informationen finden Sie unter [Sicherheitsgruppenregeln](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules.html) im *Amazon-EC2-Benutzerhandbuch*.
1. Wählen Sie **Create security group (Sicherheitsgruppe erstellen)** aus.
1. Wenn Sie VPC verwenden, wählen Sie die VPC aus, in der sich sowohl Ihr Amazon-Redshift- als auch Ihr Amazon-EMR-Cluster befinden.
1. Fügen Sie eine eingehende Regel hinzu.
1. Wählen Sie für **Type (Typ)** die Option **Custom TCP (Benutzerdefiniertes TCP)** aus.
1. Wählen Sie für **Source (Quelle)** die Option **Custom (Benutzerdefiniert)** aus.
1. Geben Sie den Namen Ihrer Amazon-Redshift-Sicherheitsgruppe ein.
1. Fügen Sie eine weitere eingehende Regel hinzu.
1. Wählen Sie unter **Type** die Option **TCP** aus.
1. Geben Sie für **Port Range (Portbereich)** **9083** ein.
**Anmerkung**
Der Standardport für einen EMR-HMS ist 9083. Wenn Ihr HMS einen anderen Port verwendet, geben Sie diesen in der eingehenden Regel und der Definition des externen Schemas an.
1. Wählen Sie für **Source (Quelle)** die Option **Custom (Benutzerdefiniert)** aus.
1. Geben Sie einen Namen und eine Beschreibung für die Sicherheitsgruppe ein.
1. Wählen Sie **Create security group (Sicherheitsgruppe erstellen)** aus.
**So fügen Sie die Amazon-EC2-Sicherheitsgruppe, die Sie im vorherigen Verfahren erstellt haben, Ihrem Amazon-Redshift-Cluster hinzu**
1. Wählen Sie Ihren Cluster in Amazon Redshift aus.
1. Wählen Sie **Properties (Eigenschaften)**.
1. Rufen Sie die **Network and security settings** (Netzwerk- und Sicherheitseinstellungen) auf und wählen Sie **Edit** (Bearbeiten) aus.
1. Wählen Sie in **VPC Security Group** (VPC-Sicherheitsgruppe) den Namen der neuen Sicherheitsgruppe aus.
1. Wählen Sie **Save Changes** (Änderungen speichern).
**So fügen Sie die Amazon-EC2-Sicherheitsgruppe zu Ihrem Amazon-EMR-Cluster hinzu**
1. Wählen Sie Ihren Cluster in Amazon EMR aus. Weitere Informationen finden Sie unter [Verwenden von Sicherheitskonfigurationen zur Einrichtung der Clustersicherheit](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-security-configurations.html) im *Amazon-EMR-Verwaltungshandbuch*
1. Wählen Sie unter **Hardware** den Link für den Master-Knoten.
1. Wählen Sie den Link in der Spalte **EC2 instance ID** (EC2-Instance-ID).
![\[Ein Screenshot, der einen Amazon-EC2-Instance-ID-Wert in der Amazon-EMR-Konsole hervorhebt.\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/images/spectrum-emr-add-security-group.png)
1. Wählen Sie für **Actions** (Aktionen) die Option **Security** (Sicherheit), **Change security groups** (Sicherheitsgruppen ändern) aus.
1. Wählen Sie unter **Associated sercurity groups** (Zugehörige Sicherheitsgruppen) die neue Sicherheitsgruppe und dann **Add security group** (Sicherheitsgruppe hinzufügen) aus.
1. Wählen Sie **Speichern**.
# Externe Tabellen für Redshift Spectrum
In diesem Thema wird beschrieben, wie Sie externe Tabellen mit Redshift Spectrum erstellen und verwenden. Externe Tabellen sind Tabellen, die Sie als Referenzen für den Zugriff auf Daten außerhalb Ihres Amazon-Redshift-Clusters verwenden. Diese Tabellen enthalten Metadaten zu den externen Daten, die Redshift Spectrum liest.
Sie erstellen eine externe Tabelle in einem externen Schema. Zum Erstellen externer Tabellen müssen Sie der Eigentümer des externen Schemas oder ein Superuser sein. Mit dem Befehl [ALTER SCHEMA](r_ALTER_SCHEMA.md) können Sie den Besitzer eines externen Schemas ändern. Das folgende Beispiel ändert den Eigentümer des Schemas `spectrum_schema` in `newowner`.
```
alter schema spectrum_schema owner to newowner;
```
Um eine Redshift Spectrum-Abfrage auszuführen, benötigen Sie die folgenden Berechtigungen:
+ Nutzungsberechtigung für das Schema
+ Berechtigung, temporäre Tabellen in der aktuellen Datenbank zu erstellen
Das folgende Beispiel erteilt der Benutzergruppe `spectrum_schema` Nutzungsberechtigungen für das Schema `spectrumusers`.
```
grant usage on schema spectrum_schema to group spectrumusers;
```
Das folgende Beispiel erteilt der Benutzergruppe `spectrumdb` temporäre Berechtigungen für die Datenbank `spectrumusers`.
```
grant temp on database spectrumdb to group spectrumusers;
```
Sie können eine externe Tabelle in Amazon Redshift AWS Glue, Amazon Athena oder einem Apache Hive-Metastore erstellen. Weitere Informationen finden Sie unter [Erste Schritte mit AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/getting-started.html) im *AWS Glue -Entwicklerhandbuch*, [Erste Schritte](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) im *Amazon-Athena-Benutzerhandbuch* oder [Apache Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive.html) im *Amazon-EMR-Entwicklerhandbuch*.
Wenn Ihre externe Tabelle in AWS Glue Athena oder einem Hive-Metastore definiert ist, erstellen Sie zunächst ein externes Schema, das auf die externe Datenbank verweist. Anschließend können Sie in Ihrer SELECT-Anweisung auf die externe Tabelle verweisen, indem Sie dem Tabellennamen den Schemanamen voranstellen, ohne dass Sie die Tabelle in Amazon Redshift erstellen müssen. Weitere Informationen finden Sie unter [Externe Schemata in Amazon Redshift Spectrum](c-spectrum-external-schemas.md).
Damit Amazon Redshift Tabellen in anzeigen kann AWS Glue Data Catalog, fügen Sie `glue:GetTable` der Amazon Redshift IAM-Rolle hinzu. Andernfalls wird möglicherweise eine Fehlermeldung wie die folgende angezeigt:
```
RedshiftIamRoleSession is not authorized to perform: glue:GetTable on resource: *;
```
Nehmen Sie beispielsweise an, Sie haben eine externe Tabelle mit der Bezeichnung `lineitem_athena` in einem externen Athena-Katalog definiert. In diesem Fall können Sie ein externes Schema mit der Bezeichnung `athena_schema` definieren und die Tabelle dann mit der folgenden SELECT-Anweisung abfragen.
```
select count(*) from athena_schema.lineitem_athena;
```
Verwenden Sie zur Definition einer externen Tabelle in Amazon Redshift den Befehl [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Die Anweisung für die externe Tabelle definiert die Tabellenspalten, das Format Ihrer Datendateien sowie den Speicherort Ihrer Daten in Amazon S3. Redshift Spectrum scannt die Dateien in dem angegebenen Ordner und in allen Unterordnern. Redshift Spectrum ignoriert verborgene Dateien und Dateien, die mit einem Punkt, einem Unterstrich oder einem Hash-Zeichen ( . , \$1 oder \$1) oder mit einer Tilde (\$1) enden.
Im folgenden Beispiel wird eine Tabelle namens SALES im externen Amazon-Redshift-Schema namens erstellt `spectrum`. Die Daten befinden sich in Textdateien, die Tabulatoren als Trennzeichen verwenden.
```
create external table spectrum.sales(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
row format delimited
fields terminated by '\t'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales/'
table properties ('numRows'='172000');
```
Um externe Tabellen anzuzeigen, führen Sie eine Abfrage für die Systemansicht [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) aus.
## Pseudospalten
Standardmäßig erstellt Amazon Redshift externe Tabellen mit den Pseudospalten `$path`, `$size` und `$spectrum_oid`. Wählen Sie die Spalte `$path` aus, um den Pfad zu den Datendateien auf Amazon S3 anzuzeigen, und die Spalte `$size`, um die Größe der Datendateien für jede Zeile anzuzeigen, die von einer Abfrage zurückgegeben wird. Die Spalte `$spectrum_oid` bietet die Möglichkeit, korrelierte Abfragen mit Redshift Spectrum durchzuführen. Ein Beispiel finden Sie unter [Beispiel: Durchführen korrelierter Unterabfragen in Redshift Spectrum](c_performing-correlated-subqueries-spectrum.md). Die Spaltennamen `$path`, `$size` und `$spectrum_oid` müssen in doppelte Anführungszeichen eingeschlossen werden. Eine SELECT \$1-Klausel gibt die Pseudospalten nicht zurück. Sie müssen die Spaltennamen `$path`, `$size` und `$spectrum_oid` explizit in Ihre Abfrage einfügen, wie im folgenden Beispiel gezeigt.
```
select "$path", "$size", "$spectrum_oid"
from spectrum.sales_part where saledate = '2008-12-01';
```
Sie können die Erstellung von Pseudospalten für eine Sitzung deaktivieren, indem Sie den Konfigurationsparameter `spectrum_enable_pseudo_columns` auf `false` festlegen. Weitere Informationen finden Sie unter [spectrum\$1enable\$1pseudo\$1columns](r_spectrum_enable_pseudo_columns.md). Sie können auch nur die Pseudospalte `$spectrum_oid` deaktivieren, indem Sie `enable_spectrum_oid` auf `false` festlegen. Weitere Informationen finden Sie unter [enable\$1spectrum\$1oid](r_spectrum_enable_spectrum_oid.md). Wenn Sie die Pseudospalte `$spectrum_oid` deaktivieren, wird allerdings auch die Unterstützung für korrelierte Abfragen mit Redshift Spectrum deaktiviert.
**Wichtig**
Bei Auswahl von `$size`, `$path` oder `$spectrum_oid` fallen Gebühren an, da Redshift Spectrum die Datendateien auf Amazon S3 scannt, um die Größe des Ergebnissatzes zu bestimmen. Weitere Informationen finden Sie unter [Amazon-Redshift-Preise](https://aws.amazon.com/redshift/pricing/).
### Beispiel für Pseudospalten
Das folgende Beispiel gibt die Gesamtgröße der entsprechenden Datendateien für eine externe Tabelle zurück.
```
select distinct "$path", "$size"
from spectrum.sales_part;
$path | $size
--------------------------------------------------------------------------+-------
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/ | 1616
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/ | 1444
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/ | 1644
```
## Partitionierung externer Redshift-Spectrum-Tabellen
Wenn Sie Ihre Daten partitionieren, können Sie die Menge der von Redshift Spectrum gescannten Daten durch Filterung auf dem Partitionierungsschlüssel begrenzen. Sie können Ihre Daten nach jedem beliebigen Schlüssel partitionieren.
Häufig werden die Daten nach der Zeit partitioniert. So können Sie etwa die Partitionierung nach Jahr, Monat, Datum oder Stunde durchführen. Wenn Sie aus zahlreichen Quellen kommende Daten haben, können Sie auch nach Datenquellen-ID und Datum partitionieren.
Die folgende Vorgehensweise beschreibt die Partitionierung Ihrer Daten.
**So partitionieren Sie Ihre Daten:**
1. Speichern Sie Ihre Daten gemäß Ihrem Partitionierungsschlüssel in Ordnern in Amazon S3.
Erstellen Sie einen Ordner für jeden Partitionierungswert, und benennen Sie den Ordner mit Partitionsschlüssel und -wert. Zum Beispiel: Wenn Sie nach Datum partitionieren, haben Sie möglicherweise Ordner mit den Bezeichnungen `saledate=2017-04-01`, `saledate=2017-04-02` und so weiter. Redshift Spectrum scannt die Dateien im Partitionierungsordner und in allen Unterordnern. Redshift Spectrum ignoriert verborgene Dateien und Dateien, die mit einem Punkt, einem Unterstrich oder einem Hash-Zeichen ( . , \$1 oder \$1) oder mit einer Tilde (\$1) enden.
1. Erstellen Sie eine externe Tabelle, und geben Sie den Partitionierungsschlüssel in der PARTITIONED BY-Klausel an.
Der Partitionierungsschlüssel darf nicht der Name einer Spalte sein. Als Datentyp kommt SMALLINT, INTEGER, BIGINT, DECIMAL, REAL, DOUBLE PRECISION, BOOLEAN, CHAR, VARCHAR, DATE oder TIMESTAMP infrage.
1. Fügen Sie die Partitionen hinzu.
Fügen Sie mit [ALTER TABLE](r_ALTER_TABLE.md) … ADD PARTITION jede Partition hinzu, und geben Sie dabei die Partitionierungsspalte und den Schlüsselwert sowie den Speicherort des Partitionierungsordners in Amazon S3 an. Sie können mehrere Partitionen mit einer einzelnen ALTER TABLE … ADD-Anweisung hinzufügen. Im folgenden Beispiel werden Partitionen für `'2008-01'` und `'2008-03'` hinzugefügt.
```
alter table spectrum.sales_part add
partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-03-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/';
```
**Anmerkung**
Wenn Sie den AWS Glue Katalog verwenden, können Sie mit einer einzigen ALTER TABLE-Anweisung bis zu 100 Partitionen hinzufügen.
### Beispiele für die Datenpartitionierung
In diesem Beispiel erstellen Sie eine externe Tabelle, die von einem einzelnen Partitionsschlüssel partitioniert wird, und eine externe Tabelle, die von zwei Partitionsschlüsseln partitioniert wird.
Die Beispieldaten für dieses Beispiel befinden sich in einem Amazon S3 S3-Bucket, der allen authentifizierten AWS Benutzern Lesezugriff gewährt. Ihr Cluster und Ihre externen Datendateien müssen sich in derselben AWS-Region befinden. Der Beispieldaten-Bucket befindet sich in der Region USA Ost (Nord-Virginia) (us-east-1). Zum Zugriff auf die Daten mit Redshift Spectrum muss sich Ihr Cluster ebenfalls in us-east-1 befinden. Führen Sie zur Auflistung der Ordner in Amazon S3 den folgenden Befehl aus.
```
aws s3 ls s3://redshift-downloads/tickit/spectrum/sales_partition/
```
```
PRE saledate=2008-01/
PRE saledate=2008-03/
PRE saledate=2008-04/
PRE saledate=2008-05/
PRE saledate=2008-06/
PRE saledate=2008-12/
```
Wenn Sie noch kein externes Schema haben, führen Sie den folgenden Befehl aus. Ersetzen Sie Ihre (IAM) -Rolle durch den Amazon Resource Name AWS Identity and Access Management (ARN).
```
create external schema spectrum
from data catalog
database 'spectrumdb'
iam_role 'arn:aws:iam::123456789012:role/myspectrumrole'
create external database if not exists;
```
#### Beispiel 1: Partitionierung mit einem einzelnen Partitionsschlüssel
Im folgenden Beispiel erstellen Sie eine externe Tabelle, die nach Monaten partitioniert ist.
Führen Sie zur Erstellung einer nach Monat partitionierten Tabelle den folgenden Befehl aus.
```
create external table spectrum.sales_part(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
partitioned by (saledate char(10))
row format delimited
fields terminated by '|'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales_partition/'
table properties ('numRows'='172000');
```
Führen Sie zum Hinzufügen der Partitionen den folgenden ALTER TABLE-Befehl aus.
```
alter table spectrum.sales_part add
partition(saledate='2008-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-03')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/'
partition(saledate='2008-04')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04/';
```
Führen Sie die folgende Abfrage aus, um Daten aus der partitionierten Tabelle auszuwählen.
```
select top 5 spectrum.sales_part.eventid, sum(spectrum.sales_part.pricepaid)
from spectrum.sales_part, event
where spectrum.sales_part.eventid = event.eventid
and spectrum.sales_part.pricepaid > 30
and saledate = '2008-01'
group by spectrum.sales_part.eventid
order by 2 desc;
```
```
eventid | sum
--------+---------
4124 | 21179.00
1924 | 20569.00
2294 | 18830.00
2260 | 17669.00
6032 | 17265.00
```
Um externe Tabellenpartitionen anzuzeigen, führen Sie eine Abfrage für die Systemansicht [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md) aus.
```
select schemaname, tablename, values, location from svv_external_partitions
where tablename = 'sales_part';
```
```
schemaname | tablename | values | location
-----------+------------+-------------+-------------------------------------------------------------------------
spectrum | sales_part | ["2008-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01
spectrum | sales_part | ["2008-03"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03
spectrum | sales_part | ["2008-04"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04
```
#### Beispiel 2: Partitionierung mit mehreren Partitionsschlüsseln
Führen Sie zur Erstellung einer nach `date` und `eventid` partitionierten externen Tabelle den folgenden Befehl aus.
```
create external table spectrum.sales_event(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
partitioned by (salesmonth char(10), event integer)
row format delimited
fields terminated by '|'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/salesevent/'
table properties ('numRows'='172000');
```
Führen Sie zum Hinzufügen der Partitionen den folgenden ALTER TABLE-Befehl aus.
```
alter table spectrum.sales_event add
partition(salesmonth='2008-01', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=101/'
partition(salesmonth='2008-01', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=102/'
partition(salesmonth='2008-01', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=103/'
partition(salesmonth='2008-02', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=101/'
partition(salesmonth='2008-02', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=102/'
partition(salesmonth='2008-02', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=103/'
partition(salesmonth='2008-03', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=101/'
partition(salesmonth='2008-03', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=102/'
partition(salesmonth='2008-03', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=103/';
```
Führen Sie die folgende Abfrage aus, um Daten aus der partitionierten Tabelle auszuwählen.
```
select spectrum.sales_event.salesmonth, event.eventname, sum(spectrum.sales_event.pricepaid)
from spectrum.sales_event, event
where spectrum.sales_event.eventid = event.eventid
and salesmonth = '2008-02'
and (event = '101'
or event = '102'
or event = '103')
group by event.eventname, spectrum.sales_event.salesmonth
order by 3 desc;
```
```
salesmonth | eventname | sum
-----------+-----------------+--------
2008-02 | The Magic Flute | 5062.00
2008-02 | La Sonnambula | 3498.00
2008-02 | Die Walkure | 534.00
```
## Mapping externer Tabellenspalten zu ORC-Spalten
Sie verwenden externe Amazon-Redshift-Spectrum-Tabellen zur Abfrage von Dateien im ORC-Format. Das ORC (Optimized Row Columnar) Format ist ein in Spalten organisiertes Speicherdateiformat, dass genestete Datenstrukturen unterstützt. Weitere Informationen zur Abfrage verschachtelter Daten finden Sie unter [Abfragen verschachtelter Daten mit Amazon Redshift Spectrum](tutorial-query-nested-data.md#tutorial-nested-data-overview).
Wenn Sie eine externe Tabelle erstellen, die auf Daten in einer ORC-Datei verweist, weisen Sie jede Spalte in der externen Tabelle einer Spalte in den ORC-Daten zu. Verwenden Sie dazu eines der folgenden verfahren.
+ [Mapping nach Position](#orc-mapping-by-position)
+ [Mapping nach Spaltenname](#orc-mapping-by-name)
Das Mapping nach Spaltenname ist das Standardverfahren.
### Mapping nach Position
Beim Positions-Mapping wird die erste in der externen Tabelle definierte Spalte der ersten Spalte in der ORC-Datendatei zugewiesen, die zweite der zweiten usw. Das Mapping nach Position erfordert, dass die Reihenfolge der Spalten in der externen Tabelle und in der ORC-Datei einander entsprechen. Wenn die Reihenfolge der Spalten nicht übereinstimmt, können Sie die Spalten nach Name zuweisen.
**Wichtig**
In früheren Versionen verwendete Redshift Spectrum standardmäßig das Positions-Mapping. Wenn Sie für vorhandene Tabellen mit dem Positions-Mapping fortfahren müssen, stellen Sie die Tabelleneigenschaft `orc.schema.resolution` auf `position`, wie das folgende Beispiel zeigt.
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='position');
```
Beispielsweise ist die Tabelle `SPECTRUM.ORC_EXAMPLE` wie folgt definiert.
```
create external table spectrum.orc_example(
int_col int,
float_col float,
nested_col struct<
"int_col" : int,
"map_col" : map>
>
) stored as orc
location 's3://example/orc/files/';
```
Die Tabellenstruktur kann wie folgt abstrahiert werden.
```
• 'int_col' : int
• 'float_col' : float
• 'nested_col' : struct
o 'int_col' : int
o 'map_col' : map
- key : int
- value : array
- value : float
```
Die zugrunde liegende ORC-Datei hat die folgende Dateistruktur.
```
• ORC file root(id = 0)
o 'int_col' : int (id = 1)
o 'float_col' : float (id = 2)
o 'nested_col' : struct (id = 3)
- 'int_col' : int (id = 4)
- 'map_col' : map (id = 5)
- key : int (id = 6)
- value : array (id = 7)
- value : float (id = 8)
```
In diesem Beispiel können Sie jede Spalte der externen Tabelle einer Spalte in der ORC-Datei streng nach Position zuweisen. Nachfolgend sehen Sie das Mapping.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/c-spectrum-external-tables.html)
### Mapping nach Spaltenname
Beim Namens-Mapping weisen Sie Spalten in einer externen Tabelle benannten Spalten in ORC-Dateien auf derselben Ebene und demselben Namen zu.
Zum Beispiel: Angenommen, Sie möchten die Tabelle aus dem vorherigen Beispiel, `SPECTRUM.ORC_EXAMPLE`, einer ORC-Datei mit der folgenden Dateistruktur zuweisen.
```
• ORC file root(id = 0)
o 'nested_col' : struct (id = 1)
- 'map_col' : map (id = 2)
- key : int (id = 3)
- value : array (id = 4)
- value : float (id = 5)
- 'int_col' : int (id = 6)
o 'int_col' : int (id = 7)
o 'float_col' : float (id = 8)
```
Mit Positionierungszuweisung versucht Redshift Spectrum das folgende Mapping.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/c-spectrum-external-tables.html)
Wenn Sie eine Tabelle mit dem vorherigen Positions-Mapping abfragen, schlägt der Befehl SELECT bei der Typenvalidierung fehl, da die Strukturen unterschiedlich sind.
Sie weisen dieselbe externe Tabelle beiden in den vorherigen Beispielen gezeigten Dateistrukturen mithilfe des Spaltennamen-Mappings zu. Die Tabellenspalten `int_col`, `float_col` und `nested_col` werden nach Spaltenname zu Spalten mit denselben Namen in der ORC-Datei zugewiesen. Die Spalte mit der Bezeichnung `nested_col` in der externen Tabelle ist eine `struct`-Spalte mit Unterspalten mit den Bezeichnungen `map_col` und `int_col`. Die Unterspalten werden ebenfalls korrekt den entsprechenden Spalten in der ORC-Datei nach Spaltenname zugewiesen.
## Erstellen externer Tabellen für in Apache Hudi verwaltete Daten
Um Daten im Apache-Hudi-Format CoW (Copy on Write) abzufragen, können Sie externe Amazon-Redshift-Spectrum-Tabellen verwenden. Eine Hudi-Copy-On-Write-Tabelle ist eine Sammlung von Apache-Parquet-Dateien, die in Amazon S3 gespeichert sind. Sie können Copy-on-Write-Tabellen (CoW) in den Apache-Hudi-Versionen 0.5.2, 0.6.0, 0.7.0, 0.8.0, 0.9.0, 0.10.0, 0.10.1, 0.11.0 und 0.11.1 lesen, die mit Einfüge-, Lösch- und Upsert-Schreiboperationen erstellt und geändert werden. Bootstrap-Tabellen werden beispielsweise nicht unterstützt. Weitere Informationen finden Sie unter [Copy On Write Table](https://hudi.apache.org/docs/next/table_types#copy-on-write-table) in der Open-Source-Dokumentation von Apache Hudi.
Wenn Sie eine externe Tabelle erstellen, die auf Daten im Hudi-CoW-Format verweist, weisen Sie jede Spalte in der externen Tabelle einer Spalte in den Hudi-Daten zu. Das Mapping erfolgt nach Spalte.
Die DDL-Anweisungen (Data Definition Language) für die partitionierten und nicht partitionierten Hudi-Tabellen ähneln den Anweisungen für andere Apache-Parquet-Dateiformate. Für Hudi-Tabellen definieren Sie `INPUTFORMAT` als `org.apache.hudi.hadoop.HoodieParquetInputFormat`. Der `LOCATION`-Parameter muss auf den Basisordner der Hudi-Tabelle verweisen, der den `.hoodie`-Ordner enthält, der erforderlich ist, um die Hudi-Commit-Timeline zu erstellen. In manchen Fällen kann der SELECT-Vorgang auf einer Hudi-Tabelle fehlschlagen. Sie erhalten dann die Nachricht No valid Hudi commit timeline found (Keine gültige Hudi-Commit-Timeline gefunden). Wenn dies der Fall ist, sollten Sie überprüfen, ob sich der `.hoodie`-Ordner am richtigen Ort befindet und die gültige Hudi-Commit-Timeline enthält.
**Anmerkung**
Das Apache-Hudi-Format wird nur unterstützt, wenn Sie einen verwenden AWS Glue Data Catalog. Es wird nicht unterstützt, wenn Sie einen Apache-Hive-Metastore als externen Katalog verwenden.
Die DDL für die Definition einer nicht partitionierten Tabelle hat das folgende Format.
```
CREATE EXTERNAL TABLE tbl_name (columns)
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://s3-bucket/prefix'
```
Die DDL für die Definition einer partitionierten Tabelle hat das folgende Format.
```
CREATE EXTERNAL TABLE tbl_name (columns)
PARTITIONED BY(pcolumn1 pcolumn1-type[,...])
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://s3-bucket/prefix'
```
Um Partitionen zu einer partitionierten Hudi-Tabelle hinzuzufügen, führen Sie den Befehl ALTER TABLE ADD PARTITION aus, wobei der `LOCATION`-Parameter auf den Amazon-S3-Unterordner mit den Dateien verweist, die zur Partition gehören.
Die DDL zum Hinzufügen von Partitionen hat das folgende Format.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION 's3://s3-bucket/prefix/partition-path'
```
## Erstellen externer Tabellen für in Delta Lake verwaltete Daten
Um Daten in Delta-Lake-Tabellen abzufragen, können Sie externe Tabellen von Amazon Redshift Spectrum verwenden.
Um aus Redshift Spectrum auf eine Delta-Lake-Tabelle zuzugreifen, generieren Sie vor der Abfrage ein Manifest. Ein Delta-Lake-*Manifest* enthält eine Liste von Dateien, aus denen ein konsistenter Snapshot in der Delta-Lake-Tabelle besteht. In einer partitionierten Tabelle gibt es ein Manifest pro Partition. Eine Delta-Lake-Tabelle ist eine Sammlung von Apache-Parquet-Dateien, die in Amazon S3 gespeichert sind. Weitere Informationen finden Sie unter [Delta Lake](https://delta.io) in der Open-Source-Dokumentation von Delta Lake.
Wenn Sie eine externe Tabelle erstellen, die auf Daten in Delta-Lake-Tabellen verweist, weisen Sie jede Spalte in der externen Tabelle einer Spalte in der Delta-Lake-Tabelle zu. Das Mapping erfolgt nach Spaltenname.
Die DDL für partitionierte und nicht partitionierte Delta-Lake-Tabellen ähnelt der für andere Apache-Parquet-Dateiformate. Für Delta-Lake-Tabellen definieren Sie `INPUTFORMAT` als `org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat` und `OUTPUTFORMAT` als `org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat`. Der `LOCATION`-Parameter muss auf den Manifestordner im Basisordner der Tabelle verweisen. Gründe für ein mögliches Fehlschlagen des SELECT-Vorgangs bei Delta-Lake-Tabellen finden Sie unter [Einschränkungen und Fehlerbehebung bei Delta-Lake-Tabellen](#c-spectrum-column-mapping-delta-limitations).
Die DDL für die Definition einer nicht partitionierten Tabelle hat das folgende Format.
```
CREATE EXTERNAL TABLE tbl_name (columns)
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://s3-bucket/prefix/_symlink_format_manifest'
```
Die DDL für die Definition einer partitionierten Tabelle hat das folgende Format.
```
CREATE EXTERNAL TABLE tbl_name (columns)
PARTITIONED BY(pcolumn1 pcolumn1-type[,...])
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://s3-bucket>/prefix/_symlink_format_manifest'
```
Um Partitionen zu einer partitionierten Delta-Lake-Tabelle hinzuzufügen, führen Sie den Befehl ALTER TABLE ADD PARTITION aus, wobei der `LOCATION`-Parameter auf den Amazon-S3-Unterordner verweist, der das Manifest für die Partition enthält.
Die DDL zum Hinzufügen von Partitionen hat das folgende Format.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION
's3://s3-bucket/prefix/_symlink_format_manifest/partition-path'
```
Sie können auch eine DDL ausführen, die direkt auf die Data-Lake-Manifestdatei verweist.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION
's3://s3-bucket/prefix/_symlink_format_manifest/partition-path/manifest'
```
### Einschränkungen und Fehlerbehebung bei Delta-Lake-Tabellen
Beachten Sie Folgendes, wenn Sie Delta-Lake-Tabellen aus Redshift Spectrum abfragen:
+ Wenn ein Manifest auf einen Snapshot oder eine Partition verweist, der/die nicht mehr vorhanden ist, schlagen Abfragen fehl, bis ein neues gültiges Manifest generiert wurde. Der Grund hierfür kann beispielsweise ein VACUUM-Vorgang in einer zugrundeliegenden Tabelle sein.
+ Delta-Lake-Manifeste bieten nur Konsistenz auf Partitionsebene.
Die folgende Tabelle zeigt einige Gründe für Fehler bei der Abfrage einer Data-Lake-Tabelle.
| Fehlermeldung | Möglicher Grund |
| --- | --- |
| Delta Lake manifest in bucket *s3-bucket-1* cannot contain entries in bucket *s3-bucket-2*. | Die Manifesteinträge verweisen auf Dateien in einem anderen Amazon-S3-Bucket als dem angegebenen. |
| Delta Lake files are expected to be in the same folder. | Die Manifesteinträge verweisen auf Dateien mit einem anderen Amazon-S3-Präfix als dem angegebenen. |
| File *filename* listed in Delta Lake manifest *manifest-path* was not found. | Eine im Manifest aufgelistete Datei wurde nicht in Amazon S3 gefunden. |
| Error fetching Delta Lake manifest. | Das Manifest wurde nicht in Amazon S3 gefunden. |
| Invalid S3 Path. | Ein Eintrag in der Manifestdatei ist kein gültiger Amazon-S3-Pfad oder die Manifestdatei ist beschädigt. |
# Verwenden von Apache-Iceberg-Tabellen mit Amazon Redshift
**Anmerkung**
Um die beste Leistung bei der Verwendung von Apache Iceberg-Tabellen mit Amazon Redshift zu erzielen, müssen Sie Spaltenstatistiken für die Tabellen generieren, die AWS Glue verwenden. Weitere Informationen finden Sie unter [Generieren von Spaltenstatistiken für Iceberg-Tabellen](https://docs.aws.amazon.com/glue/latest/dg/iceberg-generate-column-stats.html) im *AWS Glue -Entwicklerhandbuch*.
In diesem Thema wird beschrieben, wie Sie Tabellen im Apache Iceberg-Format mit Redshift Spectrum oder Redshift Serverless verwenden. Apache Iceberg ist ein Hochleistungsformat für sehr große Analytiktabellen.
Sie können Redshift Spectrum oder Redshift Serverless verwenden, um Apache-Iceberg-Tabellen abzufragen, die im AWS Glue Data Catalog katalogisiert sind. Apache Iceberg ist ein Open-Source-Tabellenformat für Data Lakes. Weitere Informationen finden Sie unter [Apache Iceberg](https://iceberg.apache.org/) in der Apache-Iceberg-Dokumentation.
Amazon Redshift bietet Transaktionskonsistenz für Abfragen von Apache-Iceberg-Tabellen. Sie können die Daten in Ihren Tabellen mithilfe von ACID-konformen Services (Atomizität, Konsistenz, Isolation, Dauerhaftigkeit) wie Amazon Athena und Amazon EMR bearbeiten, während Sie Abfragen mit Amazon Redshift ausführen. Amazon Redshift kann die in den Apache-Iceberg-Metadaten gespeicherten Tabellenstatistiken verwenden, um Abfragepläne zu optimieren und Dateiscans während der Abfrageverarbeitung zu reduzieren. Mit Amazon Redshift SQL können Sie Redshift-Tabellen mit Data-Lake-Tabellen verbinden.
So führen Sie die ersten Schritte für Iceberg-Tabellen mit Amazon Redshift aus:
1. Erstellen Sie mit einem kompatiblen Service wie Amazon Athena oder Amazon EMR eine Apache Iceberg-Tabelle in einer AWS Glue Data Catalog Datenbank. Informationen zum Erstellen einer Iceberg-Tabelle mit Athena finden Sie unter [Verwenden von Apache-Iceberg-Tabellen](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg.html) im *Amazon-Athena-Benutzerhandbuch*.
1. Erstellen Sie einen Amazon-Redshift-Cluster oder eine Redshift-Serverless-Arbeitsgruppe mit einer zugehörigen IAM-Rolle, die den Zugriff auf Ihren Data Lake ermöglicht. Informationen zum Erstellen von Clustern oder Arbeitsgruppen finden Sie unter [Erste Schritte mit von Amazon Redshift bereitgestellten Data Warehouses](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) und [Erste Schritte mit von Redshift Serverless bereitgestellten Data Warehouses](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html) im Handbuch *Erste Schritte mit Amazon Redshift*.
1. Stellen Sie mithilfe des Abfrage-Editors v2 oder eines SQL-Clients eines Drittanbieters eine Verbindung mit Ihrem Cluster oder Ihrer Arbeitsgruppe her. Informationen zum Herstellen von Verbindungen mit Query Editor V2 finden Sie unter [Herstellen einer Verbindung zu einem von Amazon Redshift bereitgestellten Data Warehouse mit SQL-Clienttools](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html) im *Managementleitfaden zu Amazon Redshift*.
1. Erstellen Sie in Ihrer Amazon-Redshift-Datenbank ein externes Schema für eine bestimmte Datenkatalogdatenbank, die Ihre Iceberg-Tabellen enthält. Informationen zum Erstellen eines externen Schemas finden Sie unter [Externe Schemata in Amazon Redshift Spectrum](c-spectrum-external-schemas.md).
1. Führen Sie SQL-Abfragen aus, um auf die Iceberg-Tabellen in dem von Ihnen erstellten externen Schema zuzugreifen.
## Überlegungen zur Verwendung von Apache-Iceberg-Tabellen mit Amazon Redshift
Bei der Verwendung von Amazon Redshift mit Iceberg-Tabellen sollten Sie Folgendes berücksichtigen:
+ **Unterstützung der Iceberg-Version** – Amazon Redshift unterstützt die Ausführung von Abfragen für die folgenden Versionen von Iceberg-Tabellen:
+ Version 1 definiert, wie große Analysetabellen mithilfe unveränderlicher Datendateien verwaltet werden.
+ Version 2 fügt die Möglichkeit hinzu, Update- und Löschvorgänge auf Zeilenebene zu unterstützen, während die vorhandenen Datendateien unverändert bleiben und die Änderungen der Tabellendaten mithilfe von Löschdateien verarbeitet werden.
Den Unterschied zwischen Tabellen der Version 1 und Version 2 finden Sie unter [Formatversionsänderungen](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) in der Apache-Iceberg-Dokumentation.
+ **Hinzufügen von Partitionen** – Sie müssen Partitionen für Ihre Apache-Iceberg-Tabellen nicht manuell hinzufügen. Neue Partitionen in Apache-Iceberg-Tabellen werden automatisch von Amazon Redshift erkannt und es ist kein manueller Vorgang erforderlich, um Partitionen in der Tabellendefinition zu aktualisieren. Alle Änderungen der Partitionsspezifikation werden auch automatisch auf Ihre Abfragen angewendet, ohne dass der Benutzer eingreifen muss.
+ **Erfassen von Iceberg-Daten in Amazon Redshift** – Sie können die Befehle INSERT INTO oder CREATE TABLE AS verwenden, um Daten aus Ihrer Iceberg-Tabelle in eine lokale Amazon-Redshift-Tabelle zu importieren. Derzeit können Sie den Befehl COPY nicht verwenden, um den Inhalt einer Apache-Iceberg-Tabelle in eine lokale Amazon-Redshift-Tabelle zu importieren.
+ **Materialisierte Ansichten** – Sie können materialisierte Ansichten für Apache-Iceberg-Tabellen wie jede andere externe Tabelle in Amazon Redshift erstellen. Die gleichen Überlegungen wie für andere Data-Lake-Tabellenformate gelten auch für Apache-Iceberg-Tabellen. Automatisches Umschreiben von Abfragen und automatische materialisierte Ansichten für Data-Lake-Tabellen werden derzeit nicht unterstützt.
+ **AWS Lake Formation feinkörnige Zugriffskontrolle** — Amazon Redshift unterstützt eine AWS Lake Formation differenzierte Zugriffskontrolle für Apache Iceberg-Tabellen.
+ **Benutzerdefinierte Datenverarbeitungsparameter** – Amazon Redshift unterstützt benutzerdefinierte Datenverarbeitungsparameter für Apache-Iceberg-Tabellen. Sie verwenden benutzerdefinierte Datenverarbeitungsparameter für vorhandene Dateien, um die Daten, die in externen Tabellen abgefragt werden, anzupassen und Scanfehler zu vermeiden. Diese Parameter bieten die Möglichkeit, Diskrepanzen zwischen dem Tabellenschema und den tatsächlichen Daten in Dateien zu bearbeiten. Sie können benutzerdefinierte Datenverarbeitungsparameter auch für Apache-Iceberg-Tabellen verwenden.
+ **Zeitreiseabfragen** – Zeitreiseabfragen werden derzeit mit Apache-Iceberg-Tabellen nicht unterstützt.
+ **Preise** – Wenn Sie von einem Cluster aus auf Iceberg-Tabellen zugreifen, werden Ihnen die Redshift-Spectrum-Preise berechnet. Wenn Sie von einer Arbeitsgruppe aus auf Iceberg-Tabellen zugreifen, werden Ihnen die Redshift-Serverless-Preise berechnet. Weitere Informationen zu Preisen von Redshift Spectrum und Redshift Serverless finden Sie unter [Amazon Redshift – Preise](https://aws.amazon.com/redshift/pricing/).
+ **Zwischenspeichern von Metadaten** – Beim Zwischenspeichern von Metadaten wird davon ausgegangen, dass Metadatendateien unveränderlich sind, basierend auf der [Iceberg-Spezifikation](https://iceberg.apache.org/spec/#file-system-operations). Die Unveränderlichkeit von Metadatendateien ist eine Voraussetzung für die Datenintegrität in Amazon Redshift.
+ **Föderierte Identität — Föderierte Identität wird** beim Schreiben in Apache Iceberg-Tabellen nicht unterstützt. Dazu gehört die Verwendung des Schlüsselworts SESSION für den Parameter IAM\$1ROLE beim Erstellen externer Schemas. [Weitere Informationen zu IAM\$1ROLE-Parametern finden Sie unter CREATE EXTERNAL SCHEMA.](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html)
# Mit Apache-Iceberg-Tabellen unterstützte Datentypen
In diesem Thema werden die unterstützten Datentypen beschrieben, die Redshift Spectrum aus Tabellen im Apache Iceberg-Format lesen kann.
Amazon Redshift kann Iceberg-Tabellen abfragen, welche die folgenden Datentypen enthalten:
```
binary
boolean
date
decimal
double
float
int
list
long
map
string
struct
timestamp without time zone
```
Wenn Sie eine Iceberg-Tabelle erstellen und definieren, verwenden Sie die Amazon Redshift Redshift-Datentypnamen in der SQL-Anweisung. Redshift ordnet sie automatisch den entsprechenden Eisbergtypen zu. Weitere Informationen zu Iceberg-Datentypen finden Sie unter [Schemata für Iceberg](https://iceberg.apache.org/docs/latest/schemas/) in der Apache-Iceberg-Dokumentation.
Beim Lesen aus Iceberg-Tabellen werden Iceberg-Datentypen Redshift-Datentypen zugeordnet, wie in der folgenden Tabelle dargestellt:
****
| Iceberg-Typ | Amazon-Redshift-Typ | Hinweise |
| --- | --- | --- |
| boolean | boolean | - |
| - | tinyint | Nicht unterstützt für Iceberg-Tabellen. |
| - | smallint | Nicht unterstützt für Iceberg-Tabellen. |
| int | int | - |
| long | bigint | - |
| double | double precision | - |
| float | real | - |
| decimal(P, S) | decimal(P, S) | P ist Präzision, S ist Skalierung. |
| - | char | Nicht unterstützt für Iceberg-Tabellen. |
| string | varchar(16384) | Zeichenfolgen, die größer als 16384 sind, werden auf 16384 gekürzt. |
| binary | varbyte(64000) | - |
| date | date | - |
| time | - | - |
| timestamp | timestamp | - |
| timestamptz | timestampz | - |
| list | SUPER | - |
| map | SUPER | - |
| struct<...> | SUPER | - |
| fixed(L) | - | Der Typ fixed(L) wird derzeit in Redshift Spectrum nicht unterstützt. |
| uuid | - | Der Typ uuid wird derzeit in Redshift Spectrum nicht unterstützt. |
| variant | - | Amazon Redshift unterstützt Iceberg V3 nicht. |
| geometry | - | Amazon Redshift unterstützt Iceberg V3 nicht. |
| geography | - | Amazon Redshift unterstützt Iceberg V3 nicht. |
| timestamp\$1ns | - | Amazon Redshift unterstützt Iceberg V3 nicht. |
| timestamptz\$1ns | - | Amazon Redshift unterstützt Iceberg V3 nicht. |
| Unknown | - | Amazon Redshift unterstützt Iceberg V3 nicht. |
Die folgenden Datentypen werden bei der Erstellung von Iceberg-Tabellen aus Redshift unterstützt. Redshift-Datentypen werden Iceberg-Datentypen zugeordnet, wie in der folgenden Tabelle dargestellt.
****
| Amazon-Redshift-Typ | Amazon Redshift Redshift-Aliasname | Iceberg-Typ | Hinweise |
| --- | --- | --- | --- |
| integer | int, int4 | int | - |
| bigint | int8 | long | - |
| decimal | numeric | decimal(p,S) | - |
| real | float4 | float | - |
| double precision | float8, float | double | - |
| varchar | charactter varying,nvarchar, text | string | Der varchar(n) Datentyp wird beim Erstellen einer Iceberg-Tabelle nicht unterstützt. |
| date | - | date | - |
| timestamp | - | timestamp | - |
| timestamptz | - | timestamptz | - |
| boolean | - | boolean | - |
Beim Schreiben in Iceberg-Tabellen werden zusätzlich zu den in der vorherigen Tabelle genannten Datentypen einige Quelldatentypen auf ihre kompatiblen Iceberg-Typen heraufgestuft, wie in der folgenden Tabelle dargestellt.
| Amazon-Redshift-Typ | Iceberg-Typ |
| --- | --- |
| `tinyint` | `int` |
| `smallint` | `int` |
| `varchar(n)` | `string` |
Der Versuch, Datentypen zu verwenden, die nicht unterstützt werden, führt zu Syntaxfehlern. Wenn Sie eine Iceberg-Tabelle mit `CREATE TABLE AS SELECT` Klausel erstellen, können Sie eine explizite Umwandlung hinzufügen, um den Typunterschied zu umgehen.
Nehmen wir zum Beispiel an, Sie haben eine Redshift RMS-Tabelle mit dem folgenden Schema:
```
CREATE TABLE rms_t (c1 int, c2 char(20));
```
Wenn Sie eine Iceberg-Tabelle `rms_t` als Quelle erstellen möchten, benötigen Sie eine explizite Umwandlung für die `c2` Spalte, da der `varchar(n)` Typ nicht unterstützt wird:
```
CREATE TABLE ext_schema.iceberg_t AS SELECT c1, c2::varchar FROM rms_t;
```
Weitere Informationen zu Datentypen in Amazon Redshift finden Sie unter [Datentypen](c_Supported_data_types.md).
# Verweisen auf Iceberg-Tabellen in Amazon Redshift
Amazon Redshift bietet mehrere Möglichkeiten, auf Apache Iceberg-Tabellen zu verweisen, die in Ihrem Data Lake gespeichert sind. Sie können externe Schemas verwenden, um Verweise auf Datenkatalogdatenbanken zu erstellen, die Iceberg-Tabellen enthalten, oder die dreiteilige Notation für den direkten Zugriff auf automatisch gemountete Kataloge verwenden.
## Verwenden externer Schemas zum Verweisen auf Iceberg-Tabellen
Externe Schemas bieten eine Möglichkeit, von Amazon Redshift aus auf Tabellen in Ihrem Datenkatalog zu verweisen. Wenn Sie ein externes Schema erstellen, stellen Sie eine Verbindung zwischen Ihrer Amazon Redshift Redshift-Datenbank und einer bestimmten Datenkatalogdatenbank her, die Ihre Iceberg-Tabellen enthält.
Um ein externes Schema für Iceberg-Tabellen zu erstellen:
```
CREATE EXTERNAL SCHEMA schema_name
FROM DATA CATALOG
DATABASE 'glue_database_name'
IAM_ROLE 'arn:aws:iam::account-id:role/role-name';
```
Nachdem Sie das externe Schema erstellt haben, können Sie Iceberg-Tabellen mithilfe der zweiteiligen Notation abfragen:
```
SELECT * FROM schema_name.iceberg_table_name;
```
Sie können Iceberg-Tabellen auch mit lokalen Amazon Redshift Redshift-Tabellen verbinden:
```
SELECT r.customer_id, i.order_date, r.customer_name
FROM local_customers r
JOIN schema_name.iceberg_orders i
ON r.customer_id = i.customer_id;
```
## Verwendung der dreiteiligen Notation mit automatisch eingehängten Katalogen
Die dreiteilige Notation ermöglicht es Ihnen, direkt auf Tabellen in automatisch bereitgestellten Katalogen zu verweisen, ohne externe Schemas zu erstellen. Diese Methode ist besonders nützlich, wenn Sie mit Amazon S3 S3-Tabellen-Buckets arbeiten, mit denen sie verbunden sind. AWS Lake Formation Informationen zum Einrichten der automatischen Bereitstellung des Datenkatalogs finden Sie unter [Vereinfachen des Zugriffs auf externe Objekte in Amazon Redshift mithilfe der AWS Glue Data Catalog automatischen Bereitstellung von](https://aws.amazon.com/blogs/big-data/simplify-external-object-access-in-amazon-redshift-using-automatic-mounting-of-the-aws-glue-data-catalog/).
Die Syntax für die dreiteilige Notation lautet:
```
"catalog_name".database_name.table_name
```
Um beispielsweise eine Iceberg-Tabelle in einem automatisch bereitgestellten Amazon S3 S3-Tabellenkatalog abzufragen:
```
SELECT * FROM "my_table_bucket@s3tablescatalog".my_database.my_iceberg_table;
```
Weitere Informationen zur Integration von Amazon S3 S3-Tabellen-Buckets mit Amazon Redshift finden Sie unter [Integrieren von S3-Tabellen mit Amazon Redshift](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-integrating-redshift.html) im *Amazon S3 S3-Benutzerhandbuch*.
Sie können die `USE` Anweisung auch verwenden, um einen Standardkatalog und eine Standarddatenbank festzulegen:
```
USE "my_table_bucket@s3tablescatalog".my_database;
SELECT * FROM my_iceberg_table;
```
So legen Sie einen Suchpfad für die Schemaauflösung fest:
```
USE "my_table_bucket@s3tablescatalog";
SET search_path TO my_database;
SELECT * FROM my_iceberg_table;
```
## Bewährte Methoden für die Referenzierung von Iceberg-Tabellen
Beachten Sie beim Verweisen auf Iceberg-Tabellen in Amazon Redshift die folgenden bewährten Methoden:
+ **Verwenden Sie beschreibende Schemanamen** — Verwenden Sie beim Erstellen externer Schemas Namen, die eindeutig auf die Quelle und den Zweck der Daten hinweisen, z. B. oder. `sales_data_lake` `customer_analytics`
+ **Nutzen Sie Tabellenstatistiken** — Stellen Sie sicher, dass Spaltenstatistiken für Ihre Iceberg-Tabellen generiert werden, um die Abfrageleistung AWS Glue zu optimieren. Amazon Redshift verwendet diese Statistiken für die Planung und Optimierung von Abfragen.
+ **Denken Sie an die Aktualität der Daten** — Iceberg-Tabellen werden möglicherweise von anderen Diensten aktualisiert, während Sie sie abfragen. Amazon Redshift bietet Transaktionskonsistenz und stellt sicher, dass Sie während Ihrer Abfrageausführung einen konsistenten Snapshot der Daten sehen.
+ **Verwenden Sie die entsprechenden IAM-Berechtigungen** — Stellen Sie sicher, dass Ihr Amazon Redshift Redshift-Cluster oder Ihre Arbeitsgruppe über die erforderlichen IAM-Berechtigungen für den Zugriff auf die Amazon S3 S3-Standorte verfügt, an denen Ihre Iceberg-Tabellen gespeichert sind, sowie auf die Data Catalog-Metadaten.
+ **Abfrageleistung überwachen** — Verwenden Sie die Abfrageüberwachungsfunktionen von Amazon Redshift, um die Leistung von Abfragen anhand von Iceberg-Tabellen zu verfolgen und bei Bedarf zu optimieren.
## Allgemeine Referenzierungsmuster
Die folgenden Beispiele zeigen gängige Muster für die Referenzierung von Iceberg-Tabellen:
**Aggregieren von Daten aus mehreren Iceberg-Tabellen:**
```
SELECT
region,
SUM(sales_amount) as total_sales,
COUNT(*) as transaction_count
FROM data_lake.sales_transactions
WHERE transaction_date >= '2024-01-01'
GROUP BY region
ORDER BY total_sales DESC;
```
**Iceberg-Tabellen mit lokalen Amazon Redshift Redshift-Tabellen verbinden:**
```
SELECT
c.customer_name,
c.customer_tier,
SUM(o.order_amount) as total_orders
FROM customers c
JOIN data_lake.order_history o ON c.customer_id = o.customer_id
WHERE o.order_date >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY c.customer_name, c.customer_tier;
```
**Verwendung der dreiteiligen Notation bei komplexen Abfragen:**
```
WITH recent_orders AS (
SELECT customer_id, order_date, order_amount
FROM "analytics_bucket@s3tablescatalog".ecommerce.orders
WHERE order_date >= CURRENT_DATE - INTERVAL '7 days'
)
SELECT
customer_id,
COUNT(*) as order_count,
AVG(order_amount) as avg_order_value
FROM recent_orders
GROUP BY customer_id
HAVING COUNT(*) > 1;
```
# In Apache Iceberg-Tabellen schreiben
Mit Amazon Redshift können Sie Apache Iceberg-Tabellen erstellen und in diese schreiben, die in Amazon S3- und Amazon S3 S3-Tabellen-Buckets gespeichert sind. Das direkte Schreiben von Iceberg-Daten aus Amazon Redshift optimiert Ihr Datenmanagement, da zusätzliche Tools wegfallen. Iceberg-Tabellen müssen bei registriert sein. AWS Glue Data Catalog
Sie können die Lakehouse-Architektur mit Apache Iceberg-Tabellen verwenden und gleichzeitig die leistungsstarken SQL-Analysen von Amazon Redshift sowohl für Warehouses als auch für Lakes nutzen. Sie erhalten außerdem sofortigen Zugriff auf erweiterte Amazon Redshift Redshift-Funktionen wie materialisierte Ansichten Ihrer Iceberg-Tabellen, wodurch Ihre Analysemöglichkeiten erheblich verbessert werden, ohne die Komplexität zu erhöhen.
Iceberg Writes wird sowohl auf von Amazon Redshift bereitgestellten Clustern als auch auf Amazon Redshift Serverless Instances unterstützt.
**Topics**
+ [SQL-Befehle](iceberg-writes-sql-syntax.md)
+ [Semantik von Transaktionen](iceberg-writes-transaction-semantics.md)
+ [Best Practices](iceberg-writes-best-practices.md)
# SQL-Befehle
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.
Alle anderen SQL-Anweisungen, wie,`DELETE`, und `UPDATE` `MERGE``ALTER TABLE`, werden in Iceberg-Tabellen noch nicht unterstützt.
In den folgenden Abschnitten wird die SQL-Syntax für das Erstellen, Einfügen 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)
+ [DROP TABLE](#iceberg-writes-drop-table)
## CREATE TABLE
```
CREATE TABLE [IF NOT EXISTS] . (
column_name data_type [, ...]
)
USING ICEBERG
[LOCATION 's3://your-bucket-name/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='')]
```
Sie können auch die dreiteilige Notation für S3-Tabellen-Buckets verwenden:
```
CREATE TABLE "@s3tablescatalog".. (
column_name data_type [, ...]
)
USING ICEBERG
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='')]
```
Beachten Sie, dass dies ein vorhandener externer Schemaname sein `` 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
```
CREATE TABLE . [(
column_name[, ...]
)]
USING ICEBERG
[LOCATION 's3://your-bucket-name/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='')]
AS
SELECT query
```
Sie können auch die dreiteilige Notation verwenden, um Tabellen in automatisch bereitgestellten Katalogen zu erstellen:
```
CREATE TABLE "".. [(
column_name[, ...]
)]
USING ICEBERG
[LOCATION 's3://your-bucket-name/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='')]
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
```
SHOW TABLE .
```
Sie können auch die dreiteilige Notation für automatisch gemountete Kataloge verwenden:
```
SHOW TABLE ""..
```
`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
```
INSERT INTO . [(column_name [, ...])] VALUES (...)
INSERT INTO . [(column_name [, ...])] (SELECT query)
-- Using three-part notation for S3 table buckets:
INSERT INTO "@s3tablescatalog".. [(column_name [, ...])] VALUES (...)
INSERT INTO "@s3tablescatalog".. [(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.
Es ist möglich, dass Sie zu `INSERT INTO` einer Iceberg-Tabelle wechseln, 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).
Verwenden Sie den `DROP TABLE` folgenden Befehl, um eine Iceberg-Tabelle aus dem Katalog zu entfernen:
## DROP TABLE
```
DROP TABLE .
```
Sie können auch die dreiteilige Notation für automatisch gemountete Kataloge verwenden:
```
DROP TABLE "..
```
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).
# Semantik von Transaktionen
Redshift Iceberg-Schreibabfragen unterstützen ACID und Snapshot-Isolation. Schreibtransaktionen haben garantierte Atomarität und führen nicht zu teilweisen Aktualisierungen, wenn eine Abfrage unerwartet fehlschlägt.
Es können mehrere Iceberg-Transaktionen gleichzeitig ausgeführt werden. Wenn zwei Transaktionen versuchen, dieselbe Tabelle oder Partition gleichzeitig zu ändern, schlägt der Transaktions-Commit fehl. Dadurch wird die Datenintegrität gewährleistet. In diesem Fall müssen Sie die Konflikte manuell lösen und die fehlgeschlagenen Abfragen erneut ausführen. Amazon Redshift versucht nicht automatisch erneut, die Konflikte zu lösen.
Eine einzelne Iceberg-Schreibabfrage wird immer als eine einzelne Auto-Commit-Transaktion behandelt. Wenn eine Iceberg-Schreibabfrage, wie z. B. eine CREATE- oder INSERT-Abfrage, in einem expliziten Transaktionsblock enthalten ist, können keine anderen Abfragen innerhalb desselben Transaktionsblocks ausgeführt werden. Die Transaktion wird fehlschlagen.
Im Folgenden sind einige Beispiele aufgeführt. Das erste Beispiel zeigt, dass eine Abfrage mit einer einzelnen Anweisung immer automatisch festgeschrieben wird, nachdem die Abfrage beendet wurde. In diesem Szenario erstellen Sie eine neue Tabelle mit Verkaufsaufträgen:
```
CREATE TABLE sales_schema.orders (
order_id int,
customer_id int,
order_date date,
total_amount decimal(10,2)
) USING ICEBERG LOCATION 's3://my-data-lake/sales/orders/';
```
Dieses Beispiel ist ein expliziter Transaktionsblock zum Einfügen einer Kundenbestellung in dreiteiliger Notation für einen S3-Tabellen-Bucket. Die Transaktion führt nach der INSERT-Abfrage kein automatisches Commit durch, sondern schreibt die Bestelldaten mit dem COMMIT-Befehl fest und fügt sie ein:
```
BEGIN;
INSERT INTO "analytics_bucket@s3tablescatalog".sales_db.orders VALUES (12345, 9876, '2024-10-30', 299.99);
COMMIT;
```
Bei diesem Beispiel handelt es sich um ein explizites Rollback-Szenario für Transaktionsblöcke, in dem Sie eine Auftragserteilung testen, diese aber stornieren möchten. Die Transaktion wird nach der INSERT-Abfrage nicht automatisch festgeschrieben, sondern stattdessen mit dem ROLLBACK-Befehl zurückgesetzt, ohne die Testreihenfolge einzufügen.
```
BEGIN;
INSERT INTO sales_schema.orders VALUES (12346, 5432, '2024-10-30', 150.75);
ROLLBACK;
```
Dieses letzte Beispiel zeigt, dass, wenn Sie versuchen, eine weitere Anweisung innerhalb desselben Transaktionsblocks wie die INSERT-Abfrage auszuführen, die Transaktion fehlschlägt, ohne dass die Bestelldaten eingefügt werden. In diesem Szenario versuchen Sie, eine Bestellung einzufügen und sofort die Tabelle abzufragen:
```
BEGIN;
INSERT INTO sales_schema.orders VALUES (12347, 7890, '2024-10-30', 425.50);
SELECT * FROM sales_schema.orders WHERE order_id = 12347;
```
Die einzige Ausnahme ist die `DROP TABLE` Anweisung, die sich immer wie eine Auto-Commit-Anweisung verhält und nicht innerhalb eines expliziten Transaktionsblocks ausgeführt werden kann. Damit soll das gleiche Verhalten wie bei einer externen Tabelle `DROP TABLE` beibehalten werden. Weitere Informationen finden Sie unter [DROP TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_TABLE.html).
**Anmerkung**
Iceberg Write SQLs kann nicht innerhalb einer gespeicherten Prozedur ausgeführt werden.
# Best Practices
Beachten Sie beim Schreiben in eine Apache Iceberg-Tabelle die folgenden bewährten Methoden:
+ Bei kleinen, häufigen Schreib- oder Streaming-Workloads sollten Sie die von Amazon S3 S3-Tabellen bereitgestellten AWS Glue Data Catalog Komprimierungsfunktionen verwenden, um die Dateigrößen für Lesevorgänge zu optimieren.
+ Der `DROP TABLE` Befehl entfernt die Registrierung der Tabelle aus dem AWS Glue Data Catalog oder dem Amazon S3-Tabellenkatalog, Ihre Dateien bleiben jedoch erhalten. 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).
# Abfrageleistung von Amazon Redshift Spectrum
In diesem Thema wird beschrieben, wie Sie die Abfrageleistung von Redshift Spectrum verbessern können.
Sehen Sie sich den Abfrageplan an, um zu ermitteln, welche Schritte auf die Amazon-Redshift-Spectrum-Ebene übertragen wurden.
Die folgenden Schritte beziehen sich auf die Redshift Spectrum-Abfrage:
+ S3 Seq Scan
+ S3 HashAggregate
+ S3 Query Scan
+ Seq Scan PartitionInfo
+ Partition Loop
Das folgende Beispiel zeigt den Abfrageplan für eine Abfrage, die eine externe mit einer lokalen Tabelle verbindet. Beachten Sie die HashAggregate Schritte S3 Seq Scan und S3, die für die Daten auf Amazon S3 ausgeführt wurden.
```
explain
select top 10 spectrum.sales.eventid, sum(spectrum.sales.pricepaid)
from spectrum.sales, event
where spectrum.sales.eventid = event.eventid
and spectrum.sales.pricepaid > 30
group by spectrum.sales.eventid
order by 2 desc;
```
```
QUERY PLAN
-----------------------------------------------------------------------------
XN Limit (cost=1001055770628.63..1001055770628.65 rows=10 width=31)
-> XN Merge (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Merge Key: sum(sales.derived_col2)
-> XN Network (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Send to leader
-> XN Sort (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Sort Key: sum(sales.derived_col2)
-> XN HashAggregate (cost=1055770620.49..1055770620.99 rows=200 width=31)
-> XN Hash Join DS_BCAST_INNER (cost=3119.97..1055769620.49 rows=200000 width=31)
Hash Cond: ("outer".derived_col1 = "inner".eventid)
-> XN S3 Query Scan sales (cost=3010.00..5010.50 rows=200000 width=31)
-> S3 HashAggregate (cost=3010.00..3010.50 rows=200000 width=16)
-> S3 Seq Scan spectrum.sales location:"s3://redshift-downloads/tickit/spectrum/sales" format:TEXT (cost=0.00..2150.00 rows=172000 width=16)
Filter: (pricepaid > 30.00)
-> XN Hash (cost=87.98..87.98 rows=8798 width=4)
-> XN Seq Scan on event (cost=0.00..87.98 rows=8798 width=4)
```
Beachten Sie die folgenden Elemente in dem Abfrageplan:
+ Der Knoten `S3 Seq Scan` zeigt, dass der Filter `pricepaid > 30.00` auf der Redshift Spectrum-Ebene verarbeitet wurde.
Ein Filterknoten unter dem Knoten `XN S3 Query Scan` zeigt die Prädikatverarbeitung in Amazon Redshift auf den von der Redshift-Spectrum-Ebene zurückgegebenen Daten an.
+ Der Knoten `S3 HashAggregate` verweist auf die Aggregierung auf der Redshift Spectrum-Ebene für die Group By-Klausel (`group by spectrum.sales.eventid`).
Nachfolgend finden Sie einige Möglichkeiten zur Verbesserung der Leistung von Redshift Spectrum:
+ Verwenden Sie im Apache Parquet-Format formatierte Datendateien. Parquet speichert Daten im Spaltenformat, so dass Redshift Spectrum nicht benötigte Spalten aus dem Scan ausschließen kann. Wenn die Daten das Textfile-Format aufweisen, muss Redshift Spectrum die gesamte Datei scannen.
+ Verwenden Sie mehrere Dateien zur Optimierung für die parallele Verarbeitung. Halten Sie die Größe Ihrer Dateien größer als 64 MB. Vermeiden Sie Datenverzerrungen, indem Sie die Dateien annähernd gleich groß halten. Informationen zu Apache Parquet-Dateien und Konfigurationsempfehlungen finden Sie in der *Apache Parquet-Dokumentation* unter [File Format: Configurations](https://parquet.apache.org/docs/file-format/configurations/).
+ Verwenden Sie in Ihren Abfragen so wenig Spalten wie möglich.
+ Speichern Sie Ihre großen Faktentabellen in Amazon S3 und Ihre häufig verwendeten und kleineren Dimensionstabellen in Ihrer lokalen Amazon-Redshift-Datenbank.
+ Aktualisieren Sie die Statistiken für externe Tabellen durch Einstellung des TABLE PROPERTIES-numRows-Parameters. Verwenden Sie [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md) oder [ALTER TABLE](r_ALTER_TABLE.md), um den numRows-Parameter TABLE PROPERTIES so einzustellen, dass er die Anzahl der Zeilen in der Tabelle widerspiegelt. Amazon Redshift analysiert keine externen Tabellen, um die Tabellenstatistiken zu generieren, die der Abfrageoptimierer verwendet, um einen Abfrageplan zu erstellen. Wenn für eine externe Tabelle keine Tabellenstatistiken festgelegt sind, generiert Amazon Redshift einen Abfrageausführungsplan. Amazon Redshift generiert diesen Plan unter der Annahme, dass externe Tabellen die größeren Tabellen und lokale Tabellen die kleineren Tabellen sind.
+ Der Amazon-Redshift-Abfrageplaner pusht Prädikate und Aggregationen nach Möglichkeit auf die Redshift-Spectrum-Abfrageebene. Wenn große Mengen von Daten von Amazon S3 zurückgegeben werden, ist die Verarbeitung durch die Ressourcen Ihres Clusters begrenzt. Redshift Spectrum wird für die Verarbeitung sehr großer Anfragen automatisch skaliert. Daher steigt Ihre allgemeine Leistung, wenn Sie die Verarbeitung auf die Redshift Spectrum-Ebene verschieben können.
+ Schreiben Sie Ihre Abfragen so, dass sie Filter und Aggregierungen verwenden, die die Verschiebung auf die Redshift Spectrum-Ebene ermöglichen.
Nachfolgend finden Sie einige Beispiele für Operationen, die auf die Redshift Spectrum-Ebene verschoben werden können:
+ GROUP BY-Klauseln
+ Vergleichsbedingungen und Musterabgleichbedingungen, wie etwa LIKE.
+ Aggregierungsfunktionen, wie etwa COUNT, SUM, AVG, MIN und MAX.
+ Zeichenfolgefunktionen.
Operationen, die nicht auf die Redshift Spectrum-Ebene verschoben werden können, sind etwa DISTINCT und ORDER BY.
+ Verwenden Sie Partitionen, um die Menge der gescannten Daten zu begrenzen. Partitionieren Sie Ihre Daten auf der Grundlage der häufigsten Abfrageprädikate, und verkürzen Sie dann die Partitionen durch die Filterung auf Partitionierungsspalten. Weitere Informationen finden Sie unter [Partitionierung externer Redshift-Spectrum-Tabellen](c-spectrum-external-tables.md#c-spectrum-external-tables-partitioning).
Fragen Sie [SVL\$1S3PARTITION](r_SVL_S3PARTITION.md) ab, um alle Partitionen und qualifizierte Partitionen anzuzeigen.
+ Verwenden Sie AWS Glue den Statistikgenerator, um Statistiken auf Spaltenebene für Tabellen zu berechnen. AWS Glue Data Catalog Sobald Statistiken für Tabellen im Datenkatalog AWS Glue generiert wurden, verwendet Amazon Redshift Spectrum diese Statistiken automatisch, um den Abfrageplan zu optimieren. *Weitere Informationen zur Berechnung von Statistiken auf Spaltenebene mithilfe von AWS Glue finden Sie unter [Arbeiten mit Spaltenstatistiken im AWS Glue Entwicklerhandbuch](https://docs.aws.amazon.com/glue/latest/dg/column-statistics.html).*
# Optionen für die Fehlerbehandlung
In diesem Thema wird beschrieben, wie Redshift Spectrum Daten in unerwarteten Formaten verarbeitet.
Sie können Tabellenparameter einstellen, wenn Sie externe Tabellen erstellen, um die in externen Tabellen abgefragten Daten anzupassen. Andernfalls können Scanfehler auftreten. Weitere Informationen finden Sie unter TABLE PROPERTIES in [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Beispiele finden Sie unter [Beispiele für die Datenverarbeitung](r_CREATE_EXTERNAL_TABLE_examples.md#r_CREATE_EXTERNAL_TABLE_examples-data-handling). Eine Liste von Fehlern finden Sie unter [SVL\$1SPECTRUM\$1SCAN\$1ERROR](r_SVL_SPECTRUM_SCAN_ERROR.md).
Sie können die folgenden TABLE PROPERTIES einstellen, wenn Sie externe Tabellen erstellen, um die Eingabebehandlung für Daten anzugeben, die in externen Tabellen abgefragt werden.
+ `column_count_mismatch_handling`, um festzustellen, ob die Datei weniger oder mehr Werte für eine Zeile enthält als die in der externen Tabellendefinition angegebene Anzahl von Spalten.
+ `invalid_char_handling`, um die Eingabebehandlung für ungültige Zeichen in Spalten anzugeben, die VARCHAR-, CHAR- und String-Daten enthalten. Wenn Sie REPLACE für `invalid_char_handling` angeben, können Sie das zu verwendende Ersatzzeichen angeben.
+ `numeric_overflow_handling`, um die Verarbeitung von Umwandlungsüberläufen in Spalten anzugeben, die Ganzzahl- und Dezimaldaten enthalten.
+ `surplus_bytes_handling`, um die Eingabebehandlung für überschüssige Byte in Spalten anzugeben, die VARBYTE-Daten enthalten.
+ `surplus_char_handling`, um die Eingabebehandlung für überschüssige Zeichen in Spalten anzugeben, die VARCHAR-, CHAR- und String-Daten enthalten.
Sie können eine Konfigurationsoption festlegen, um Abfragen abzubrechen, die eine maximale Anzahl von Fehlern überschreiten. Weitere Informationen finden Sie unter [spectrum\$1query\$1maxerror](r_spectrum_query_maxerror.md).
# Beispiel: Durchführen korrelierter Unterabfragen in Redshift Spectrum
In diesem Thema wird beschrieben, wie Sie korrelierte Unterabfragen in Redshift Spectrum ausführen können. Eine korrelierte Unterabfrage ist eine Abfrage, die Werte aus der äußeren Abfrage verwendet.
Sie können korrelierte Unterabfragen in Redshift Spectrum durchführen. Die Pseudospalte `$spectrum_oid` bietet die Möglichkeit, korrelierte Abfragen mit Redshift Spectrum durchzuführen. Um eine korrelierte Unterabfrage durchzuführen, muss die Pseudospalte `$spectrum_oid` aktiviert sein, wird aber nicht in der SQL-Anweisung angezeigt. Weitere Informationen finden Sie unter [Pseudospalten](c-spectrum-external-tables.md#c-spectrum-external-tables-pseudocolumns).
Informationen zum Erstellen des externen Schemas und der externen Tabellen für dieses Beispiel finden Sie unter [Erste Schritte mit Amazon Redshift Spectrum](c-getting-started-using-spectrum.md).
Im Folgenden sehen Sie ein Beispiel für eine korrelierte Unterabfrage in Redshift Spectrum.
```
select *
from myspectrum_schema.sales s
where exists
( select *
from myspectrum_schema.listing l
where l.listid = s.listid )
order by salesid
limit 5;
```
```
salesid listid sellerid buyerid eventid dateid qtysold pricepaid commission saletime
1 1 36861 21191 7872 1875 4 728 109.2 2008-02-18 02:36:48
2 4 8117 11498 4337 1983 2 76 11.4 2008-06-06 05:00:16
3 5 1616 17433 8647 1983 2 350 52.5 2008-06-06 08:26:17
4 5 1616 19715 8647 1986 1 175 26.25 2008-06-09 08:38:52
5 6 47402 14115 8240 2069 2 154 23.1 2008-08-31 09:17:02
```
# Metriken in Amazon Redshift Spectrum
In diesem Thema werden Systemansichten beschrieben, mit denen Sie Redshift-Spectrum-Abfragen überwachen können.
Sie können die Amazon-Redshift-Spectrum-Abfragen mithilfe der folgenden Systemansichten überwachen:
+ [SVL\$1S3QUERY](r_SVL_S3QUERY.md)
Verwenden Sie die Ansicht SVL\$1S3QUERY um Details zu Redshift Spectrum-Abfragen (S3-Abfragen) auf Segment- und Knotenslice-Ebene zu erhalten.
+ [SVL\$1S3QUERY\$1SUMMARY](r_SVL_S3QUERY_SUMMARY.md)
Verwenden Sie die Ansicht SVL\$1S3QUERY\$1SUMMARY zum Erhalt einer Zusammenfassung aller Amazon-Redshift-Spectrum-Abfragen (S3-Abfragen), die auf dem System ausgeführt wurden.
Nachfolgend finden Sie einige Aspekte, auf die Sie in SVL\$1S3QUERY\$1SUMMARY achten sollten:
+ Die Anzahl der Dateien, die von der Redshift Spectrum-Abfrage verarbeitet wurden.
+ Die Anzahl der von Amazon S3 gescannten Bytes. Die Kosten für eine Redshift-Spectrum-Abfrage richten sich nach der Menge der von Amazon S3 gescannten Daten.
+ Die Anzahl der von der Redshift Spectrum-Ebene an den Cluster zurückgegebenen Bytes. Eine große Menge zurückgegebener Daten kann sich auf die Systemleistung auswirken.
+ Die maximale und die durchschnittliche Dauer von Redshift Spectrum-Anfragen. Länger dauernde Anfragen können Anzeichen für einen Engpass sein.
# Fehlerbehebung für Abfragen in Amazon Redshift Spectrum
Dieses Thema ist eine Referenz für häufige Probleme, die bei Abfragen von Amazon Redshift Spectrum auftreten können.
Fragen Sie zur Anzeige der von Redshift Spectrum generierten Fehler die Systemtabelle [SVL\$1S3LOG](r_SVL_S3LOG.md) ab.
**Topics**
+ [Überschreitung der Anzahl erneuter Versuche](#spectrum-troubleshooting-retries-exceeded)
+ [Zugriff gedrosselt](#spectrum-troubleshooting-access-throttled)
+ [Ressourcenlimit überschritten](#spectrum-troubleshooting-resource-limit-exceeded)
+ [Für eine partitionierte Tabelle werden keine Zeilen ausgegeben.](#spectrum-troubleshooting-no-rows-partitioned-table)
+ [„Nicht autorisiert“-Fehler](#spectrum-troubleshooting-not-authorized-error)
+ [Inkompatible Datenformate](#spectrum-troubleshooting-incompatible-data-format)
+ [Syntaxfehler bei der Verwendung von Hive-DDL in Amazon Redshift](#spectrum-troubleshooting-syntax-error-using-hive-ddl)
+ [Berechtigungen zum Erstellen temporärer Tabellen](#spectrum-troubleshooting-permission-to-create-temp-tables)
+ [Ungültiger Bereich](#spectrum-troubleshooting-invalid-range)
+ [Ungültige Parquet-Versionsnummer](#spectrum-troubleshooting-invalid-parquet-version)
+ [Erforderliches Feld in Informationen zu externen Partitionen fehlend](#spectrum-troubleshooting-required-field-missing)
## Überschreitung der Anzahl erneuter Versuche
Wenn bei einer Amazon-Redshift-Spectrum-Anfrage eine Zeitüberschreitung auftritt, wird die Anfrage abgebrochen und erneut übermittelt. Nach fünf fehlgeschlagenen erneuten Versuchen schlägt die Abfrage mit dem folgenden Fehler fehl.
```
error: Spectrum Scan Error: Retries exceeded
```
Dafür gibt es die folgenden möglichen Ursachen:
+ Große Dateien (über 1 GB). Prüfen Sie die Größe Ihrer Dateien in Amazon S3, und suchen Sie nach großen Dateien und Dateigrößenverzerrungen. Teilen Sie große Dateien in kleinere auf, zwischen 100 MB und 1 GB. Versuchen Sie, die Dateien etwa gleich groß zu halten.
+ Langsamer Netzwerkdurchsatz. Versuchen Sie Ihre Abfrage später erneut.
## Zugriff gedrosselt
Amazon Redshift Spectrum unterliegt den Servicekontingenten anderer AWS Services. Bei hoher Auslastung müssen Redshift-Spectrum-Anforderungen möglicherweise verlangsamt werden, was zum folgenden Fehler führt.
```
error: Spectrum Scan Error: Access throttled
```
Es können zwei Arten der Drosselung auftreten:
+ Zugriff gedrosselt von Amazon S3.
+ Der Zugriff wurde gedrosselt von. AWS KMS
Der Fehlerkontext enthält weitere Details zum Typ der Drosselung. Nachfolgend können Sie Ursachen und mögliche Lösungen für diese Drosselung finden.
### Zugriff gedrosselt von Amazon S3
Amazon S3 drosselt möglicherweise eine Redshift-Spectrum-Anforderung, wenn die Leseanforderungsrate für ein [Präfix](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html#keyprefix) zu hoch ist. Informationen zur GET/HEAD Anforderungsrate, die Sie in Amazon S3 erreichen können, finden Sie unter [Optimieren der Amazon S3 S3-Leistung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html) im *Amazon Simple Storage Service-Benutzerhandbuch.* Die Amazon S3 GET/HEAD S3-Anforderungsrate berücksichtigt alle GET/HEAD Anfragen mit einem Präfix, sodass sich verschiedene Anwendungen, die auf dasselbe Präfix zugreifen, die Gesamtanzahl der Anfragen teilen.
Wenn Ihre Redshift Spectrum-Anfragen häufig von Amazon S3 gedrosselt werden, reduzieren Sie die Anzahl der Amazon GET/HEAD S3-Anfragen, die Redshift Spectrum an Amazon S3 stellt. Versuchen Sie dazu, kleine Dateien zu größeren Dateien zusammenzufassen. Wir empfehlen, Dateigrößen von mindestens 64 MB zu verwenden.
Ziehen Sie auch die Partitionierung Ihrer Redshift-Spectrum-Tabellen in Betracht, um von einer frühen Filterung zu profitieren und die Anzahl der Dateien zu reduzieren, auf die in Amazon S3 zugegriffen wird. Weitere Informationen finden Sie unter [Partitionierung externer Redshift-Spectrum-Tabellen](c-spectrum-external-tables.md#c-spectrum-external-tables-partitioning).
### Der Zugriff wird gedrosselt durch AWS KMS
Wenn Sie Ihre Daten mit serverseitiger Verschlüsselung (SSE-S3 oder SSE-KMS) in Amazon S3 speichern, ruft Amazon S3 AWS KMS für jede Datei, auf die Redshift Spectrum zugreift, eine API-Operation auf. Diese Anforderungen zählen für Ihr kryptografisches Operationskontingent. Weitere Informationen finden Sie unter [AWS KMS -Anforderungskontingente](https://docs.aws.amazon.com/kms/latest/developerguide/requests-per-second.html). Weitere Informationen zu SSE-S3 und SSE-KMS finden Sie unter [Schutz von Daten mit serverseitiger Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html) und [Schutz von Daten mit serverseitiger Verschlüsselung mit in AWS KMS gespeicherten KMS-Schlüsseln](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) im *Amazon-Simple-Storage-Service-Benutzerhandbuch.*
Ein erster Schritt zur Reduzierung der Anzahl der Anfragen, an die Redshift Spectrum stellt, AWS KMS besteht darin, die Anzahl der abgerufenen Dateien zu reduzieren. Versuchen Sie dazu, kleine Dateien zu größeren Dateien zusammenzufassen. Wir empfehlen, Dateigrößen von mindestens 64 MB zu verwenden.
Wenn Ihre Redshift Spectrum-Anfragen häufig gedrosselt werden, sollten Sie erwägen AWS KMS, eine Erhöhung des Kontingents für Ihre Anforderungsrate für AWS KMS kryptografische Operationen zu beantragen. Informationen zum Anfordern einer Kontingenterhöhung finden Sie unter [AWS -Service Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) im *Allgemeine Amazon Web Services-Referenz*.
## Ressourcenlimit überschritten
Redshift Spectrum erzwingt eine Obergrenze für die Speichermenge, die eine Anforderung verwenden kann. Eine Redshift-Spectrum-Anforderung, die mehr Speicher benötigt, schlägt fehl, was zu dem folgenden Fehler führt.
```
error: Spectrum Scan Error: Resource limit exceeded
```
Es gibt zwei häufige Gründe, die dazu führen können, dass eine Redshift-Spectrum-Anforderung ihr Speicherkontingent überschreitet:
+ Redshift Spectrum verarbeitet einen großen Datenblock, der nicht in kleinere Datenblöcke aufgeteilt werden kann.
+ Ein großer Aggregationsschritt wird von Redshift Spectrum verarbeitet.
Es wird empfohlen, ein Dateiformat zu verwenden, das parallele Lesevorgänge mit geteilten Größen von 128 MB oder weniger unterstützt. Unterstützte Dateiformate und allgemeine Richtlinien für die Erstellung von Datendateien finden Sie unter [Datendateien für Abfragen in Amazon Redshift Spectrum](c-spectrum-data-files.md). Bei Verwendung von Dateiformaten oder Komprimierungsalgorithmen, die keine parallelen Lesevorgänge unterstützen, empfehlen wir, die Dateigrößen zwischen 64 MB und 128 MB zu halten.
## Für eine partitionierte Tabelle werden keine Zeilen ausgegeben.
Wenn Ihre Abfrage von einer partitionierten externen Tabelle null Zeilen ausgibt, prüfen Sie, ob für diese externe Tabelle eine Partition hinzugefügt wurde. Redshift Spectrum scannt nur Dateien an einem Amazon-S3-Speicherort, der ausdrücklich mit hinzugefügt wurde `ALTER TABLE … ADD PARTITION`. Fragen Sie die Ansicht [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md) ab, um die vorhandenen Partitionen zu finden. Führen Sie für jede fehlende Partition `ALTER TABLE … ADD PARTITION` aus.
## „Nicht autorisiert“-Fehler
Prüfen Sie, ob die IAM-Rolle für den Cluster den Zugriff auf die Amazon-S3-Dateiobjekte erlaubt. Wenn sich Ihre externe Datenbank auf Amazon Athena befindet, prüfen Sie, ob die IAM-Rolle den Zugriff auf Athena-Ressourcen erlaubt. Weitere Informationen finden Sie unter [IAM-Richtlinien für Amazon Redshift Spectrum](c-spectrum-iam-policies.md).
## Inkompatible Datenformate
Bei einem Spaltenformat wie Apache Parquet ist der Spaltentyp mit den Daten eingebettet. Der Spaltentyp in der CREATE EXTERNAL TABLE-Definition muss dem Spaltentyp der Datendatei entsprechen. Wenn dies nicht der Fall ist, erhalten Sie eine Fehlermeldung wie die folgende:
```
File 'https://s3bucket/location/file has an incompatible Parquet schema
for column ‘s3://s3bucket/location.col1'. Column type: VARCHAR, Par
```
Die Fehlermeldung kann aus Längengründen verkürzt angezeigt werden. Um die gesamte Fehlermeldung, einschließlich Spaltenname und Spaltentyp, abzurufen, fragen Sie die Systemansicht [SVL\$1S3LOG](r_SVL_S3LOG.md) ab.
Im folgenden Beispiel wird SVL\$1S3LOG nach der letzten abgeschlossene Abfrage abgefragt.
```
select message
from svl_s3log
where query = pg_last_query_id()
order by query,segment,slice;
```
nachfolgend sehen Sie ein Beispiel für ein Ergebnis mit der vollständigen Fehlermeldung.
```
message
–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––-
Spectrum Scan Error. File 'https://s3bucket/location/file has an incompatible
Parquet schema for column ' s3bucket/location.col1'.
Column type: VARCHAR, Parquet schema:\noptional int64 l_orderkey [i:0 d:1 r:0]\n
```
Um den Fehler zu korrigieren, ändern Sie die externe Tabelle so, dass sie dem Spaltentyp der Parquet-Datei entspricht.
## Syntaxfehler bei der Verwendung von Hive-DDL in Amazon Redshift
Amazon Redshift unterstützt die Data Definition Language (DDL) für CREATE EXTERNAL TABLE, die ähnlich der Hive-DDL ist. Die beiden DDL-Typen sind aber nicht überall gleich. Wenn Sie Hive-DDL zur Erstellung oder Änderung externer Amazon-Redshift-Tabellen kopieren, können Syntaxfehler auftreten. Nachfolgend sehen Sie einige Beispiele für Unterschiede zwischen Amazon Redshift und Hive-DDL:
+ Amazon Redshift erfordert einfache Anführungszeichen ('), während Hive-DDL doppelte Anführungszeichen unterstützt (").
+ Amazon Redshift unterstützt nicht den Datentyp STRING. Verwenden Sie stattdessen VARCHAR.
## Berechtigungen zum Erstellen temporärer Tabellen
Um Redshift Spectrum-Abfragen auszuführen, benötigt der Datenbankbenutzer die Berechtigung, temporäre Tabellen in der Datenbank zu erstellen. Das folgende Beispiel erteilt der Benutzergruppe `spectrumdb` temporäre Berechtigungen für die Datenbank `spectrumusers`.
```
grant temp on database spectrumdb to group spectrumusers;
```
Weitere Informationen finden Sie unter [GRANT](r_GRANT.md).
## Ungültiger Bereich
Redshift Spectrum erwartet, dass Dateien in Amazon S3, die zu einer externen Tabelle gehören, bei einer Abfrage nicht überschrieben werden. Sollte dies doch geschehen, kann der folgende Fehler auftreten.
```
Error: HTTP response error code: 416 Message: InvalidRange The requested range is not satisfiable
```
Um den Fehler zu vermeiden, stellen Sie sicher, dass Amazon S3-Dateien nicht überschrieben werden, während sie mit Redshift Spectrum abgefragt werden.
## Ungültige Parquet-Versionsnummer
Redshift Spectrum überprüft die Metadaten jeder Apache Parquet-Datei, auf die zugegriffen wird. Wenn die Prüfung fehlschlägt, kann dies zu einem Fehler wie dem folgenden führen:
```
File 'https://s3.region.amazonaws.com/s3bucket/location/file has an invalid version number
```
Es gibt zwei häufige Gründe, die dazu führen können, dass die Überprüfung fehlschlägt:
+ Die Parquet-Datei wurde bei der Abfrage überschrieben (siehe [Ungültiger Bereich](#spectrum-troubleshooting-invalid-range)).
+ Die Parquett-Datei ist beschädigt.
## Erforderliches Feld in Informationen zu externen Partitionen fehlend
Wenn Sie versuchen, einer externen Tabelle in einem externen Katalog eine Partition hinzuzufügen, wird möglicherweise der folgende Fehler angezeigt:
```
Error: The required field () is missing from the external partition information. Add missing field in partition and retry. Partition location:
```
Dieser Fehler bedeutet, dass auf einer der Partitionen in der externen Tabelle, die in Ihrer Abfrage verwendet wurde, Informationen zu Partitionsmetadaten fehlen. Dies ist in den folgenden Fällen möglich:
+ Sie haben einer externen Tabelle in einem externen Katalog, z. B. der, eine Partition mit unvollständigen Informationen AWS Glue Data Catalog hinzugefügt.
+ Sie haben eine partitionierte Tabelle in Amazon Redshift abgefragt, während Sie Partitionen für die entsprechende Tabelle in einem externen Katalog hinzugefügt oder aktualisiert haben, z. B. AWS Glue Data Catalog.
Im Folgenden werden die Felder aufgeführt, die beim Abrufen einer Partition aus AWS Glue Data Catalog ausgefüllt werden müssen.
+ StorageDescriptor
+ InputFormat
+ OutputFormat
+ SerDeInfo
+ Werte
Sie können [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md) abfragen, um nach vorhandenen Partitionen zu suchen und sich Details zu ihren Feldern anzeigen lassen.
Eine vollständige Liste der AWS Glue Data Catalog Partitionsfelder finden Sie unter [Partition](https://docs.aws.amazon.com/glue/latest/webapi/API_Partition.html) in der *AWS Glue Web-API-Referenz*.
# Tutorial: Abfragen verschachtelter Daten mit Amazon Redshift Spectrum
Dieses Tutorial zeigt, wie Sie verschachtelte Daten mit Redshift Spectrum abfragen. Verschachtelte Daten sind Daten, die verschachtelte Felder enthalten. Verschachtelte Felder sind Felder, die zu einer einzelnen Einheit zusammengefügt sind, z. B. Arrays, Strukturen oder Objekte.
**Topics**
+ [-Übersicht](#tutorial-nested-data-overview)
+ [Schritt 1: Erstellen einer externen Tabelle mit verschachtelten Daten](#tutorial-nested-data-create-table)
+ [Schritt 2: Abfragen Ihrer verschachtelten Daten in Amazon S3 mit SQL-Erweiterungen](#tutorial-query-nested-data-sqlextensions)
+ [Anwendungsfälle für verschachtelte Daten](nested-data-use-cases.md)
+ [Einschränkungen bei verschachtelten Daten (Vorschau)](nested-data-restrictions.md)
+ [Serialisieren komplexer verschachtelter JSON-Datentypen](serializing-complex-JSON.md)
## -Übersicht
Amazon Redshift Spectrum unterstützt das Abfragen verschachtelter Daten in den Dateiformaten ORC, JSON und Ion. Redshift Spectrum greift mittels externer Tabellen auf die Daten zu. Sie können externe Tabellen erstellen, die die komplexen Datentypen `struct`, `array` und `map` verwenden.
Angenommen, Ihre Datendatei enthält die folgenden Daten in Amazon S3 in einem Ordner mit dem Namen `customers`. Obwohl kein einziges Stammelement vorhanden ist, stellt jedes JSON-Objekt in diesen Stichprobendaten eine Zeile in einer Tabelle dar.
```
{"id": 1,
"name": {"given": "John", "family": "Smith"},
"phones": ["123-457789"],
"orders": [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50},
{"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}]
}
{"id": 2,
"name": {"given": "Jenny", "family": "Doe"},
"phones": ["858-8675309", "415-9876543"],
"orders": []
}
{"id": 3,
"name": {"given": "Andy", "family": "Jones"},
"phones": [],
"orders": [{"shipdate": "2018-03-02T08:02:15.000Z", "price": 13.50}]
}
```
Sie können mithilfe von Amazon Redshift Spectrum verschachtelte Daten in Dateien abfragen. Das folgende Tutorial veranschaulicht die Vorgehensweise hierfür mit Apache-Parquet-Daten.
### Voraussetzungen
Wenn Sie noch nicht mit Redshift Spectrum vertraut sind, befolgen Sie die Schritte unter [Erste Schritte mit Amazon Redshift Spectrum](c-getting-started-using-spectrum.md), bevor Sie fortfahren.
Um ein externes Schema zu erstellen, ersetzen Sie den ARN der IAM-Rolle im folgenden Befehl durch den Rollen-ARN, den Sie im Abschnitt [Erstellen einer IAM-Rolle](c-getting-started-using-spectrum.md#c-getting-started-using-spectrum-create-role) festgelegt haben. Führen Sie dann den Befehl in Ihrem SQL-Client aus.
```
create external schema spectrum
from data catalog
database 'myspectrum_db'
iam_role 'arn:aws:iam::123456789012:role/myspectrum_role'
create external database if not exists;
```
## Schritt 1: Erstellen einer externen Tabelle mit verschachtelten Daten
Sie können die [Quelldaten](https://s3.amazonaws.com/redshift-downloads/tickit/spectrum/customers/customer_file1) anzeigen, indem Sie sie von Amazon S3 herunterladen.
Um die externe Tabelle für dieses Tutorial zu erstellen, führen Sie den folgenden Befehl aus.
```
CREATE EXTERNAL TABLE spectrum.customers (
id int,
name struct,
phones array,
orders array>
)
STORED AS PARQUET
LOCATION 's3://redshift-downloads/tickit/spectrum/customers/';
```
Im voranstehenden Beispiel verwendet die externe Tabelle `spectrum.customers` die Datentypen `struct` und `array`, um Spalten mit verschachtelten Daten zu definieren. Amazon Redshift Spectrum unterstützt das Abfragen verschachtelter Daten in den Dateiformaten ORC, JSON und Ion. Der Parameter `STORED AS` für Apache-Parquet-Dateien lautet `PARQUET`. Der Parameter `LOCATION` muss auf den Amazon S3-Ordner verweisen, der die verschachtelten Daten oder Dateien enthält. Weitere Informationen finden Sie unter [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
Sie können die Typen `array` und `struct` auf jeder beliebigen Ebene verschachteln. So können Sie z. B. eine Spalte mit dem Namen `toparray` definieren; siehe folgendes Beispiel.
```
toparray array>>>>
```
Außerdem können Sie wie für Spalte `struct` im folgenden Beispiel veranschaulicht auch `x`-Typen verschachteln.
```
x struct
>
>
```
## Schritt 2: Abfragen Ihrer verschachtelten Daten in Amazon S3 mit SQL-Erweiterungen
Redshift Spectrum unterstützt das Abfragen komplexer `array`-, `map`- und `struct`-Typen durch Erweiterungen der Amazon-Redshift-SQL-Syntax.
### Erweiterung 1: Zugriff auf Structs-Spalten
Sie können Daten aus `struct`-Spalten extrahieren. Dazu verwenden Sie eine punktierte Schreibweise, die Feldnamen in Pfade verkettet. Die folgende Abfrage gibt z. B. Vor- und Nachnamen von Kunden zurück. Auf den Vornamen wird über den langen Pfad `c.name.given` zugegriffen. Auf den Nachnamen wird über den langen Pfad `c.name.family` zugegriffen.
```
SELECT c.id, c.name.given, c.name.family
FROM spectrum.customers c;
```
Die vorhergehende Abfrage gibt die folgenden Daten zurück.
```
id | given | family
---|-------|-------
1 | John | Smith
2 | Jenny | Doe
3 | Andy | Jones
(3 rows)
```
Ein `struct`-Element kann eine Spalte eines anderen `struct`-Elements sein, das wiederum auf einer beliebigen anderen Ebene eine Spalte eines anderen `struct`-Elements sein kann. Die Pfade, die auf Spalten in solchen tief verschachtelten `struct`-Elementen zugreifen können willkürlich lang sein. Betrachten Sie sich z. B. die Definition der Spalte `x` im folgenden Beispiel.
```
x struct
>
>
```
Sie können auf die Daten in `e` als `x.b.d.e` zugreifen.
### Erweiterung 2: Übergreifende Arrays in einer FROM-Klausel
Sie können Daten aus `array`-Spalten (und damit auch aus `map`-Spalten) extrahieren, indem Sie die `array`-Spalten in einer `FROM`-Klausel anstelle von Tabellennamen angeben. Die Erweiterung gilt für die `FROM`-Klausel der Hauptabfrage sowie auch für die `FROM`-Klauseln von Unterabfragen.
Sie können auf `array`-Elemente nach Position verweisen, also beispielsweise `c.orders[0]` angeben (Vorschau).
Durch das Kombinieren von übergreifenden `arrays` mit Joins können Sie die Verschachtelung auf verschiedene Weise aufheben, wie in den folgenden Anwendungsfällen beschrieben.
#### Aufheben der Verschachtelung mit Inner Joins
Die folgende Abfrage wählt Kunden IDs - und Auftragsversanddaten für Kunden aus, die Bestellungen haben. Die SQL-Erweiterung in der FROM-Klausel `c.orders o` ist vom Alias `c` abhängig.
```
SELECT c.id, o.shipdate
FROM spectrum.customers c, c.orders o
```
Für jeden Kunden `c`, für den Aufträge vorhanden sind, gibt die `FROM`-Klausel für jeden Auftrag `o` des Kunden `c` eine Zeile zurück. Diese Zeile kombiniert die Kundenzeile `c` und die Auftragszeile `o`. Die `SELECT`-Klausel behält dann nur `c.id` und `o.shipdate` bei. Dies führt zu folgendem Ergebnis.
```
id| shipdate
--|----------------------
1 |2018-03-01 11:59:59
1 |2018-03-01 09:10:00
3 |2018-03-02 08:02:15
(3 rows)
```
Der Alias `c` bietet Zugriff auf die Kundenfelder, und der Alias `o` bietet Zugriff auf die Auftragsfelder.
Die Semantik ist mit Standard-SQL vergleichbar. Sie können sich die `FROM`-Klausel so vorstellen, als würde die folgende verschachtelte Schleife ausgeführt werden, gefolgt von `SELECT` zur Auswahl der auszugebenden Felder.
```
for each customer c in spectrum.customers
for each order o in c.orders
output c.id and o.shipdate
```
Daher erscheinen Kunden, für die keine Aufträge vorhanden sind, nicht im Ergebnis.
Sie können sich das auch so vorstellen, als ob die `FROM`-Klausel einen `JOIN` mit der `customers`-Tabelle und dem `orders`-Array durchführen wurde. Sie können die Abfrage daher auch wie im folgenden Beispiel veranschaulicht schreiben.
```
SELECT c.id, o.shipdate
FROM spectrum.customers c INNER JOIN c.orders o ON true
```
**Anmerkung**
Wenn ein Schema mit dem Namen `c` mit einer Tabelle mit dem Namen `orders` vorhanden ist, dann bezieht sich `c.orders` auf die Tabelle `orders` und nicht auf die Array-Spalte von `customers`.
#### Aufheben der Verschachtelung mit Left Joins
Die folgende Abfrage gibt alle Kundennamen und deren Aufträge aus. Für Kunden, die keinen Auftrag erteilt haben, wird dennoch der Kundenname zurückgegeben. In diesem Fall ist der Wert der Auftragsspalten jedoch NULL, wie im folgenden Beispiel für Jenny Doe veranschaulicht.
```
SELECT c.id, c.name.given, c.name.family, o.shipdate, o.price
FROM spectrum.customers c LEFT JOIN c.orders o ON true
```
Die vorhergehende Abfrage gibt die folgenden Daten zurück.
```
id | given | family | shipdate | price
----|---------|---------|----------------------|--------
1 | John | Smith | 2018-03-01 11:59:59 | 100.5
1 | John | Smith | 2018-03-01 09:10:00 | 99.12
2 | Jenny | Doe | |
3 | Andy | Jones | 2018-03-02 08:02:15 | 13.5
(4 rows)
```
### Erweiterung 3: Direkter Zugriff auf ein Array von Skalaren über einen Alias
Wenn sich der Alias `p` in einer `FROM`-Klausel über ein Array von Skalaren erstreckt, bezeichnet die Abfrage die `p`-Werte als `p`. Die folgende Abfrage ergibt z. B. Paare aus Kundennamen und Telefonnummern.
```
SELECT c.name.given, c.name.family, p AS phone
FROM spectrum.customers c LEFT JOIN c.phones p ON true
```
Die vorhergehende Abfrage gibt die folgenden Daten zurück.
```
given | family | phone
-------|----------|-----------
John | Smith | 123-4577891
Jenny | Doe | 858-8675309
Jenny | Doe | 415-9876543
Andy | Jones |
(4 rows)
```
### Erweiterung 4: Zugriff auf Zuordnungselemente
Redshift Spectrum verarbeitet den `map`-Datentyp als einen `array`-Typ, der `struct`-Typen mit einer `key`-Spalte und einer `value`-Spalte enthält. `key` muss vom Typ `scalar` sein; der Wert kann ein beliebiger Datentyp sein.
Der folgende Code erstellt z. B. eine externe Tabelle mit einem `map`-Element zum Speichern von Telefonnummern.
```
CREATE EXTERNAL TABLE spectrum.customers2 (
id int,
name struct,
phones map,
orders array>
)
STORED AS PARQUET
LOCATION 's3://redshift-downloads/tickit/spectrum/customers/';
```
Da sich ein `map`-Typ wie ein `array`-Typ mit den Spalten `key` und `value` verhält, können Sie sich die vorhergehenden Schemen so vorstellen, als wären sie die folgenden Schemen.
```
CREATE EXTERNAL TABLE spectrum.customers3 (
id int,
name struct,
phones array>,
orders array>
)
STORED AS PARQUET
LOCATION 's3://redshift-downloads/tickit/spectrum/customers/';
```
Die folgende Abfrage gibt die Namen von Kunden mit Mobiltelefonnummer und die Nummer für jeden Namen zurück. Die Zuordnungsabfrage wird genauso wie die Abfrage eines verschachtelten `array` aus `struct`-Typen verarbeitet. Die folgende Abfrage gibt nur Daten zurück, wenn Sie die externe Tabelle wie zuvor beschrieben erstellt haben.
```
SELECT c.name.given, c.name.family, p.value
FROM spectrum.customers c, c.phones p
WHERE p.key = 'mobile';
```
**Anmerkung**
Der `key`-Wert für ein `map`-Element ist bei den Dateitypen Ion und JSON vom Typ `string`.
# Anwendungsfälle für verschachtelte Daten
In diesem Thema werden Anwendungsfälle für verschachtelte Daten beschrieben. Verschachtelte Daten sind Daten, die verschachtelte Felder enthalten. Verschachtelte Felder sind Felder, die zu einer einzelnen Einheit zusammengefügt sind, z. B. Arrays, Strukturen oder Objekte.
Sie können die zuvor beschriebenen Erweiterungen mit den gewöhnlichen SQL-Funktionen kombinieren. Die folgenden Anwendungsfälle veranschaulichen einige häufige Kombinationen. Anhand dieser Beispiele soll demonstriert werden, wie Sie verschachtelte Daten anwenden können. Sie sind nicht Teil des Tutorials.
**Topics**
+ [Aufnehmen verschachtelter Daten](#ingesting-nested-data)
+ [Aggregieren verschachtelter Daten mit Unterabfragen](#aggregating-with-subquery)
+ [Verknüpfen von Amazon Redshift und verschachtelten Daten](#joining-redshift-data)
## Aufnehmen verschachtelter Daten
Sie können eine `CREATE TABLE AS`-Anweisung verwenden, um Daten aus einer externen Tabelle mit komplexen Datentypen aufzunehmen. Die folgende Abfrage extrahiert alle Kunden und ihre Telefonnummern aus der externen Tabelle mithilfe von `LEFT JOIN` und speichert sie in der Amazon-Redshift-Tabelle `CustomerPhones`.
```
CREATE TABLE CustomerPhones AS
SELECT c.name.given, c.name.family, p AS phone
FROM spectrum.customers c LEFT JOIN c.phones p ON true;
```
## Aggregieren verschachtelter Daten mit Unterabfragen
Sie können eine Unterabfrage zum Aggregieren von verschachtelten Daten verwenden. Die folgende Abbildung veranschaulicht dieses Konzept.
```
SELECT c.name.given, c.name.family, (SELECT COUNT(*) FROM c.orders o) AS ordercount
FROM spectrum.customers c;
```
Die folgenden Daten werden zurückgegeben.
```
given | family | ordercount
--------|----------|--------------
Jenny | Doe | 0
John | Smith | 2
Andy | Jones | 1
(3 rows)
```
**Anmerkung**
Wenn Sie verschachtelte Daten durch Gruppieren nach der übergeordneten Zeile aggregieren, ist die effizienteste Methode dafür die, die im vorherigen Beispiel veranschaulicht wird. Im diesem Beispiel werden die verschachtelten `c.orders`-Zeilen nach der ihnen übergeordneten Zeile `c` gruppiert. Wenn Ihnen bekannt ist, dass `id` für jeden `customer`-Eintrag eindeutig und jeder `o.shipdate`-Eintrag niemals null ist, können Sie alternativ dazu wie im folgenden Beispiel gezeigt aggregieren. Dieser Ansatz ist in der Regel jedoch nicht so effizient wie das vorherige Beispiel.
```
SELECT c.name.given, c.name.family, COUNT(o.shipdate) AS ordercount
FROM spectrum.customers c LEFT JOIN c.orders o ON true
GROUP BY c.id, c.name.given, c.name.family;
```
Sie können die Abfrage auch mit einer Unterabfrage in der `FROM`-Klausel schreiben, die sich auf einen Alias (`c`) der Vorgängerabfrage bezieht und Array-Daten extrahiert. Das folgende Beispiel illustriert diese Herangehensweise.
```
SELECT c.name.given, c.name.family, s.count AS ordercount
FROM spectrum.customers c, (SELECT count(*) AS count FROM c.orders o) s;
```
## Verknüpfen von Amazon Redshift und verschachtelten Daten
Sie können Amazon-Redshift-Daten auch mit verschachtelten Daten in einer externen Tabelle verknüpfen. Angenommen, Sie haben die folgenden verschachtelten Daten in Amazon S3.
```
CREATE EXTERNAL TABLE spectrum.customers2 (
id int,
name struct,
phones array,
orders array>
);
```
Nehmen wir außerdem an, Sie haben die folgende Tabelle in Amazon Redshift.
```
CREATE TABLE prices (
id int,
price double precision
);
```
Die folgende Abfrage findet basierend auf dem Vorangehenden die Gesamtzahl und Gesamtmenge der Käufe eines jeden Kundens. Das folgende Beispiel dient nur zur Veranschaulichung. Es gibt nur Daten zurück, wenn Sie die Tabellen wie zuvor beschrieben erstellt haben.
```
SELECT c.name.given, c.name.family, COUNT(o.date) AS ordercount, SUM(p.price) AS ordersum
FROM spectrum.customers2 c, c.orders o, prices p ON o.item = p.id
GROUP BY c.id, c.name.given, c.name.family;
```
# Einschränkungen bei verschachtelten Daten (Vorschau)
In diesem Thema werden Einschränkungen beim Lesen verschachtelter Daten mit Redshift Spectrum beschrieben. Verschachtelte Daten sind Daten, die verschachtelte Felder enthalten. Verschachtelte Felder sind Felder, die zu einer einzelnen Einheit zusammengefügt sind, z. B. Arrays, Strukturen oder Objekte.
**Anmerkung**
Die in der folgenden Liste mit (Vorschau) gekennzeichneten Einschränkungen gelten nur für Vorschau-Cluster, die in den folgenden Regionen erstellt wurden.
USA Ost (Ohio): (us-east-2)
USA Ost (Nord-Virginia): (us-east-1)
USA West (Nordkalifornien) (us-west-1)
Asien-Pazifik (Tokyo) (ap-northeast-1)
Europa (Irland) (eu-west-1)
Europa (Stockholm) (eu-north-1)
Weitere Informationen zum Einrichten von Vorschau-Clustern finden Sie unter [Erstellen eines Vorschau-Clusters](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#cluster-preview) im *Amazon-Redshift-Verwaltungshandbuch*.
Die folgenden Einschränkungen gelten für verschachtelte Daten:
+ Ein `array`- oder `map`-Typ kann andere `array`- oder `map`-Typen enthalten, sofern Abfragen für die verschachtelten `arrays` oder `maps` keine `scalar`-Werte zurückgeben. (Vorschau)
+ Amazon Redshift Spectrum unterstützt komplexe Datentypen nur als externe Tabellen.
+ Die Ergebnisspalten der Unterabfrage müssen sich auf oberster Ebene befinden. (Vorschau)
+ Wenn sich ein `OUTER JOIN`-Ausdruck auf eine verschachtelte Tabelle bezieht, darf er sich nur auf die betreffende Tabelle und ihre verschachtelten Arrays (und Zuordnungen) beziehen. Wenn sich ein `OUTER JOIN`-Ausdruck nicht auf eine verschachtelte Tabelle bezieht, kann er sich auf eine beliebige Anzahl nicht verschachtelter Tabellen beziehen.
+ Wenn sich eine `FROM`-Klausel in einer Unterabfrage auf eine verschachtelte Tabelle bezieht, darf sie sich auf keine andere Tabelle beziehen.
+ Wenn eine Unterabfrage von einer verschachtelten Tabelle abhängig ist, die sich auf eine übergeordnete Tabelle bezieht, kann die Unterabfrage die übergeordnete Tabelle nur in der `FROM`-Klausel verwenden. Sie können die übergeordnete Tabelle in keiner anderen Klausel, wie z. B. einer `SELECT`- oder `WHERE`-Klausel, verwenden. Die folgende Abfrage wird beispielsweise nicht ausgeführt, da sich die `SELECT`-Klausel der Unterabfrage auf die übergeordnete Tabelle `c` bezieht.
```
SELECT c.name.given
FROM spectrum.customers c
WHERE (SELECT COUNT(c.id) FROM c.phones p WHERE p LIKE '858%') > 1;
```
Die folgende Abfrage funktioniert, da die übergeordnete Tabelle `c` nur in der `FROM`-Klausel der Unterabfrage verwendet wird.
```
SELECT c.name.given
FROM spectrum.customers c
WHERE (SELECT COUNT(*) FROM c.phones p WHERE p LIKE '858%') > 1;
```
+ Eine Unterabfrage, die an anderer Stelle als die `FROM`-Klausel auf verschachtelte Daten zugreift, muss einen einzelnen Wert zurückgeben. Die einzigen Ausnahmen sind `(NOT) EXISTS`-Operatoren in einer `WHERE`-Klausel.
+ `(NOT) IN` wird nicht unterstützt.
+ Die maximale Verschachtelungstiefe aller verschachtelter Typen ist 100. Diese Einschränkung gilt für alle Dateiformate (Parquet, ORC, Ion und JSON).
+ Aggregations-Unterabfragen, die auf verschachtelte Daten zugreifen, dürfen nur auf `arrays` und `maps` in ihrer `FROM`-Klausel verweisen, nicht auf eine externe Tabelle.
+ Das Abfragen der Pseudospalten verschachtelter Daten in einer Redshift-Spectrum-Tabelle wird nicht unterstützt. Weitere Informationen finden Sie unter [Pseudospalten](c-spectrum-external-tables.md#c-spectrum-external-tables-pseudocolumns).
+ Wenn Sie Daten aus Array- oder Map-Spalten extrahieren, indem Sie diese in einer `FROM`-Klausel angeben, können Sie nur Werte aus diesen Spalten auswählen, wenn es sich um `scalar`-Werte handelt. Die folgenden Abfragen versuchen beispielsweise beide, Elemente aus einem Array auszuwählen (`SELECT`). Die Abfrage, die `arr.a` auswählt, funktioniert, da es sich bei `arr.a` um einen `scalar`-Wert handelt. Die zweite Abfrage funktioniert nicht, da `array` ein Array ist, das in der `FROM`-Klausel aus `s3.nested table` extrahiert wurde. (Vorschau)
```
SELECT array_column FROM s3.nested_table;
array_column
-----------------
[{"a":1},{"b":2}]
SELECT arr.a FROM s3.nested_table t, t.array_column arr;
arr.a
-----
1
--This query fails to run.
SELECT array FROM s3.nested_table tab, tab.array_column array;
```
Sie können in der `FROM`-Klausel keine Arrays oder Maps verwenden, die selbst aus anderen Arrays oder Maps stammen. Um Arrays oder andere komplexe Strukturen auszuwählen, die in anderen Arrays verschachtelt sind, könnten Sie Indizes in der `SELECT`-Anweisung verwenden.
# Serialisieren komplexer verschachtelter JSON-Datentypen
In diesem Thema wird gezeigt, wie verschachtelte Daten im JSON-Format serialisiert werden. Verschachtelte Daten sind Daten, die verschachtelte Felder enthalten. Verschachtelte Felder sind Felder, die zu einer einzelnen Einheit zusammengefügt sind, z. B. Arrays, Strukturen oder Objekte.
Eine Alternative zu den in diesem Tutorial demonstrierten Methoden besteht darin, verschachtelte Sammlungsspalten der obersten Ebene als serialisierten JSON-Datentyp abzufragen. Sie können die Serialisierung verwenden, um verschachtelte Daten als JSON mit Redshift Spectrum zu untersuchen, zu konvertieren und aufzunehmen. Diese Methode wird für ORC-, JSON-, Ion- und Parquet-Formate unterstützt. Verwenden Sie den Sitzungskonfigurationsparameter `json_serialization_enable`, um das Serialisierungsverhalten zu konfigurieren. Wenn diese Einstellung festgelegt ist, werden komplexe JSON-Datentypen in VARCHAR(65535) serialisiert. Auf den verschachtelten JSON-Datentyp kann mit [JSON-Funktionen](json-functions.md) zugegriffen werden. Weitere Informationen finden Sie unter [json\$1serialization\$1enable](r_json_serialization_enable.md).
Beispiel: Ohne die Einstellung von `json_serialization_enable` schlagen die folgenden Abfragen, die auf verschachtelte Spalten direkt zugreifen, fehl.
```
SELECT * FROM spectrum.customers LIMIT 1;
=> ERROR: Nested tables do not support '*' in the SELECT clause.
SELECT name FROM spectrum.customers LIMIT 1;
=> ERROR: column "name" does not exist in customers
```
Das Einstellen von `json_serialization_enable` ermöglicht das direkte Abfragen von Sammlungen der obersten Ebene.
```
SET json_serialization_enable TO true;
SELECT * FROM spectrum.customers order by id LIMIT 1;
id | name | phones | orders
---+--------------------------------------+----------------+----------------------------------------------------------------------------------------------------------------------
1 | {"given": "John", "family": "Smith"} | ["123-457789"] | [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50}, {"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}]
SELECT name FROM spectrum.customers order by id LIMIT 1;
name
---------
{"given": "John", "family": "Smith"}
```
Beachten Sie die folgenden Elemente, wenn Sie verschachtelte JSON-Datentypen serialisieren.
+ Wenn Sammlungsspalten als VARCHAR(65535) serialisiert werden, kann auf ihre verschachtelten Unterfelder nicht direkt als Teil der Abfragesyntax zugegriffen werden (z. B. in der Filter-Klausel). JSON-Funktionen können jedoch für den Zugriff auf verschachtelte JSON-Datentypen verwendet werden.
+ Die folgenden spezialisierten Darstellungen werden nicht unterstützt:
+ ORC-Vereinigungen
+ ORC-Zuordnungen mit komplexen Typenschlüsseln
+ Ion-Datagramme
+ Ion SEXP
+ Zeitstempel werden als serialisierte ISO-Zeichenfolgen zurückgegeben.
+ Primitive Zuordnungsschlüssel werden zu einer Zeichenfolge heraufgestuft (z. B. `1` zu `"1"`).
+ Nullwerte der obersten Ebene werden als serialisiert. NULLs
+ Wenn die Serialisierung die maximale VARCHAR-Größe von 65535 übersteigt, wird die Zelle auf NULL gesetzt.
## Serialisieren komplexer Typen, die JSON-Zeichenfolgen enthalten
Standardmäßig werden Zeichenfolgenwerte, die in verschachtelten Sammlungen enthalten sind, als Escape-JSON-Zeichenfolgen serialisiert. Escaping kann unerwünscht sein, wenn die Zeichenfolgen gültige JSON-Ausdrücke sind. Stattdessen sollten Sie verschachtelte VARCHAR-serialisierte Unterelemente oder Felder direkt als JSON schreiben. Aktivieren Sie dieses Verhalten mit der Konfiguration `json_serialization_parse_nested_strings` auf Sitzungsebene. Wenn `json_serialization_enable` und `json_serialization_parse_nested_strings` eingestellt sind, werden gültige JSON-Werte inline ohne Escape-Zeichen serialisiert. Wenn der Wert kein gültiger JSON-Ausdruck ist, wird er escaped, als ob der `json_serialization_parse_nested_strings`-Konfigurationswert nicht festgelegt wäre. Weitere Informationen finden Sie unter [json\$1serialization\$1parse\$1nested\$1strings](r_json_serialization_parse_nested_strings.md).
Angenommen, die Daten aus dem vorherigen Beispiel enthielten JSON als komplexen `structs`-Typ in im VARCHAR(20)-Feld `name`:
```
name
---------
{"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"}
```
Wenn `json_serialization_parse_nested_strings` eingestellt ist, wird die Spalte `name` wie folgt serialisiert:
```
SET json_serialization_enable TO true;
SET json_serialization_parse_nested_strings TO true;
SELECT name FROM spectrum.customers order by id LIMIT 1;
name
---------
{"given": {"first":"John","middle":"James"}, "family": "Smith"}
```
Anstatt wie folgt escaped zu werden:
```
SET json_serialization_enable TO true;
SELECT name FROM spectrum.customers order by id LIMIT 1;
name
---------
{"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"}
```