Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# SQL-Befehle
Die SQL-Sprache besteht aus Befehlen, die Sie zum Erstellen und Bearbeiten von Datenbankobjekten, zum Ausführen von Abfragen, zum Laden von Tabellen und zum Ändern von Daten in Tabellen verwenden.
Amazon Redshift basiert auf PostgreSQL. Zwischen Amazon Redshift und PostgreSQL gibt es eine Reihe wichtiger Unterschiede, die Sie berücksichtigen müssen, wenn Sie Ihre Data-Warehouse-Anwendungen entwerfen und entwickeln. Weitere Informationen zu den Unterschieden zwischen Amazon-Redshift-SQL und PostgreSQL finden Sie unter [Amazon Redshift und PostgreSQL](c_redshift-and-postgres-sql.md).
**Anmerkung**
Die maximal zulässige Größe für eine einzelne SQL-Anweisung ist 16 MB.
**Topics**
+ [ABORT](r_ABORT.md)
+ [ALTER DATABASE](r_ALTER_DATABASE.md)
+ [ALTER DATASHARE](r_ALTER_DATASHARE.md)
+ [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md)
+ [ALTER EXTERNAL SCHEMA](r_ALTER_EXTERNAL_SCHEMA.md)
+ [ALTER EXTERNAL VIEW](r_ALTER_EXTERNAL_VIEW.md)
+ [ALTER FUNCTION](r_ALTER_FUNCTION.md)
+ [ALTER GROUP](r_ALTER_GROUP.md)
+ [ALTER IDENTITY PROVIDER](r_ALTER_IDENTITY_PROVIDER.md)
+ [ALTER MASKING POLICY](r_ALTER_MASKING_POLICY.md)
+ [ALTER MATERIALIZED VIEW](r_ALTER_MATERIALIZED_VIEW.md)
+ [ALTER RLS POLICY](r_ALTER_RLS_POLICY.md)
+ [ALTER ROLE](r_ALTER_ROLE.md)
+ [ALTER PROCEDURE](r_ALTER_PROCEDURE.md)
+ [ALTER SCHEMA](r_ALTER_SCHEMA.md)
+ [ALTER SYSTEM](r_ALTER_SYSTEM.md)
+ [ALTER TABLE](r_ALTER_TABLE.md)
+ [ALTER TABLE APPEND](r_ALTER_TABLE_APPEND.md)
+ [VORLAGE ÄNDERN](r_ALTER_TEMPLATE.md)
+ [ALTER USER](r_ALTER_USER.md)
+ [ANALYZE](r_ANALYZE.md)
+ [ANALYZE COMPRESSION](r_ANALYZE_COMPRESSION.md)
+ [ANFÜGEN EINER MASKIERUNGSRICHTLINIE](r_ATTACH_MASKING_POLICY.md)
+ [ATTACH RLS POLICY](r_ATTACH_RLS_POLICY.md)
+ [BEGIN](r_BEGIN.md)
+ [CALL](r_CALL_procedure.md)
+ [CANCEL](r_CANCEL.md)
+ [CLOSE](close.md)
+ [COMMENT](r_COMMENT.md)
+ [COMMIT](r_COMMIT.md)
+ [COPY](r_COPY.md)
+ [CREATE DATABASE](r_CREATE_DATABASE.md)
+ [DATASHARE ERSTELLEN](r_CREATE_DATASHARE.md)
+ [CREATE EXTERNAL FUNCTION](r_CREATE_EXTERNAL_FUNCTION.md)
+ [ERSTELLEN EINES EXTERNEN MODELLS](r_create_external_model.md)
+ [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)
+ [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md)
+ [CREATE EXTERNAL VIEW](r_CREATE_EXTERNAL_VIEW.md)
+ [CREATE FUNCTION](r_CREATE_FUNCTION.md)
+ [CREATE GROUP](r_CREATE_GROUP.md)
+ [CREATE IDENTITY PROVIDER](r_CREATE_IDENTITY_PROVIDER.md)
+ [CREATE LIBRARY](r_CREATE_LIBRARY.md)
+ [ERSTELLEN EINER MASKIERUNGSRICHTLINIE](r_CREATE_MASKING_POLICY.md)
+ [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)
+ [CREATE MODEL](r_CREATE_MODEL.md)
+ [CREATE PROCEDURE](r_CREATE_PROCEDURE.md)
+ [CREATE RLS POLICY](r_CREATE_RLS_POLICY.md)
+ [CREATE ROLE](r_CREATE_ROLE.md)
+ [CREATE SCHEMA](r_CREATE_SCHEMA.md)
+ [CREATE TABLE](r_CREATE_TABLE_NEW.md)
+ [CREATE TABLE AS](r_CREATE_TABLE_AS.md)
+ [VORLAGE ERSTELLEN](r_CREATE_TEMPLATE.md)
+ [CREATE USER](r_CREATE_USER.md)
+ [CREATE VIEW](r_CREATE_VIEW.md)
+ [DEALLOCATE](r_DEALLOCATE.md)
+ [DECLARE](declare.md)
+ [DELETE](r_DELETE.md)
+ [DESC DATASHARE](r_DESC_DATASHARE.md)
+ [DESC IDENTITY PROVIDER](r_DESC_IDENTITY_PROVIDER.md)
+ [TRENNEN EINER MASKIERUNGSRICHTLINIE](r_DETACH_MASKING_POLICY.md)
+ [DETACH RLS POLICY](r_DETACH_RLS_POLICY.md)
+ [DROP DATABASE](r_DROP_DATABASE.md)
+ [DROP DATASHARE](r_DROP_DATASHARE.md)
+ [DROP EXTERNAL VIEW](r_DROP_EXTERNAL_VIEW.md)
+ [DROP FUNCTION](r_DROP_FUNCTION.md)
+ [DROP GROUP](r_DROP_GROUP.md)
+ [DROP IDENTITY PROVIDER](r_DROP_IDENTITY_PROVIDER.md)
+ [DROP LIBRARY](r_DROP_LIBRARY.md)
+ [ENTFERNEN EINER MASKIERUNGSRICHTLINIE](r_DROP_MASKING_POLICY.md)
+ [DROP MODEL](r_DROP_MODEL.md)
+ [DROP MATERIALIZED VIEW](materialized-view-drop-sql-command.md)
+ [DROP PROCEDURE](r_DROP_PROCEDURE.md)
+ [DROP RLS POLICY](r_DROP_RLS_POLICY.md)
+ [DROP ROLE](r_DROP_ROLE.md)
+ [DROP SCHEMA](r_DROP_SCHEMA.md)
+ [DROP TABLE](r_DROP_TABLE.md)
+ [VORLAGE LÖSCHEN](r_DROP_TEMPLATE.md)
+ [DROP USER](r_DROP_USER.md)
+ [DROP VIEW](r_DROP_VIEW.md)
+ [END](r_END.md)
+ [EXECUTE](r_EXECUTE.md)
+ [EXPLAIN](r_EXPLAIN.md)
+ [FETCH](fetch.md)
+ [GRANT](r_GRANT.md)
+ [INSERT](r_INSERT_30.md)
+ [INSERT (externe Tabelle)](r_INSERT_external_table.md)
+ [LOCK](r_LOCK.md)
+ [MERGE](r_MERGE.md)
+ [PREPARE](r_PREPARE.md)
+ [REFRESH MATERIALIZED VIEW](materialized-view-refresh-sql-command.md)
+ [RESET](r_RESET.md)
+ [REVOKE](r_REVOKE.md)
+ [ROLLBACK](r_ROLLBACK.md)
+ [SELECT](r_SELECT_synopsis.md)
+ [SELECT INTO](r_SELECT_INTO.md)
+ [SET](r_SET.md)
+ [SET SESSION AUTHORIZATION](r_SET_SESSION_AUTHORIZATION.md)
+ [SET SESSION CHARACTERISTICS](r_SET_SESSION_CHARACTERISTICS.md)
+ [ZEIGEN](r_SHOW.md)
+ [SPALTE „ZUSCHÜSSE“ ANZEIGEN](r_SHOW_COLUMN_GRANTS.md)
+ [SHOW\$1COLUMNS](r_SHOW_COLUMNS.md)
+ [EINSCHRÄNKUNGEN ANZEIGEN](r_SHOW_CONSTRAINTS.md)
+ [SHOW EXTERNAL TABLE](r_SHOW_EXTERNAL_TABLE.md)
+ [SHOW DATABASES](r_SHOW_DATABASES.md)
+ [FUNKTIONEN ANZEIGEN](r_SHOW_FUNCTIONS.md)
+ [SHOW GRANTS](r_SHOW_GRANTS.md)
+ [SHOW MODEL](r_SHOW_MODEL.md)
+ [SHOW DATASHARES](r_SHOW_DATASHARES.md)
+ [PARAMETER ANZEIGEN](r_SHOW_PARAMETERS.md)
+ [RICHTLINIEN ANZEIGEN](r_SHOW_POLICIES.md)
+ [SHOW PROCEDURE](r_SHOW_PROCEDURE.md)
+ [ZEIGT PROZEDUREN](r_SHOW_PROCEDURES.md)
+ [SHOW SCHEMAS](r_SHOW_SCHEMAS.md)
+ [SHOW TABLE](r_SHOW_TABLE.md)
+ [SHOW TABLES](r_SHOW_TABLES.md)
+ [VORLAGE ANZEIGEN](r_SHOW_TEMPLATE.md)
+ [VORLAGEN ANZEIGEN](r_SHOW_TEMPLATES.md)
+ [SHOW VIEW](r_SHOW_VIEW.md)
+ [START TRANSACTION](r_START_TRANSACTION.md)
+ [TRUNCATE](r_TRUNCATE.md)
+ [UNLOAD](r_UNLOAD.md)
+ [UPDATE](r_UPDATE.md)
+ [USE](r_USE_command.md)
+ [VACUUM](r_VACUUM_command.md)
# ABORT
Bricht die zurzeit ausgeführte Transaktion ab und verwirft alle Aktualisierungen, die durch diese Transaktion ausgeführt wurden. ABORT wirkt sich nicht auf bereits abgeschlossene Transaktionen aus.
Dieser Befehl hat die gleiche Funktion wie der Befehl ROLLBACK. Weitere Informationen finden Sie unter [ROLLBACK](r_ROLLBACK.md).
## Syntax
```
ABORT [ WORK | TRANSACTION ]
```
## Parameters
WORK
Optionales Schlüsselwort.
TRANSACTION
Optionales Schlüsselwort; WORK und TRANSACTION sind Synonyme.
## Beispiel
Im folgenden Beispiel werden eine Tabelle erstellt und eine Transaktion gestartet, bei der Daten in die Tabelle eingefügt werden. Anschließend wird mit dem Befehl ABORT die Dateieinfügung zurückgenommen, um die Tabelle leer zu lassen.
Mit dem folgenden Befehl wird eine Beispieltabelle namens MOVIE\$1GROSS erstellt:
```
create table movie_gross( name varchar(30), gross bigint );
```
Mit dem nächsten Satz von Befehlen wird eine Transaktion gestartet, die zwei Datenzeilen in die Tabelle einfügt:
```
begin;
insert into movie_gross values ( 'Raiders of the Lost Ark', 23400000);
insert into movie_gross values ( 'Star Wars', 10000000 );
```
Als Nächstes werden mit dem folgenden Befehl die Daten aus der Tabelle ausgewählt, um zu zeigen, dass sie erfolgreich eingefügt wurden:
```
select * from movie_gross;
```
Die Befehlsausgabe zeigt, dass beide Zeilen erfolgreich eingefügt wurden:
```
name | gross
------------------------+----------
Raiders of the Lost Ark | 23400000
Star Wars | 10000000
(2 rows)
```
Mit diesem Befehl werden nun die Datenänderungen auf den Zeitpunkt zurückgesetzt, an dem die Transaktion gestartet wurde:
```
abort;
```
Wenn nun Daten aus der Tabelle ausgewählt werden, wird eine leere Tabelle gezeigt:
```
select * from movie_gross;
name | gross
------+-------
(0 rows)
```
# ALTER DATABASE
Ändert die Attribute einer Datenbank.
## Erforderliche Berechtigungen
Um ALTER DATABASE zu benutzen, ist eine der folgenden Berechtigungen erforderlich.
+ Superuser
+ Benutzer mit der Berechtigung ALTER DATABASE.
+ Datenbankbesitzer
## Syntax
```
ALTER DATABASE database_name
{
RENAME TO new_name
| OWNER TO new_owner
| [ CONNECTION LIMIT { limit | UNLIMITED } ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ]
[ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ]
| INTEGRATION
{
REFRESH { { ALL | INERROR } TABLES [ IN SCHEMA schema [, ...] ] | TABLE schema.table [, ...] }
| SET
[ QUERY_ALL_STATES [=] { TRUE | FALSE } ]
[ ACCEPTINVCHARS [=] { TRUE | FALSE } ]
[ REFRESH_INTERVAL ]
[ TRUNCATECOLUMNS [=] { TRUE | FALSE } ]
[ HISTORY_MODE [=] {TRUE | FALSE} [ FOR { {ALL} TABLES [IN SCHEMA schema [, ...] ] | TABLE schema.table [, ...] } ] ]
}
}
```
## Parameters
*database\$1name*
Der Name der Datenbank, die geändert werden soll. In der Regel ändern Sie eine Datenbank, mit der Sie zurzeit nicht verbunden sind. In jedem Fall werden die Änderungen nur in folgenden Sitzungen wirksam. Sie können den Besitzer der aktuellen Datenbank ändern, sie jedoch nicht umbenennen:
```
alter database tickit rename to newtickit;
ERROR: current database may not be renamed
```
RENAME TO
Benennt die angegebene Datenbank um. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md). Sie können die Datenbanken dev, padb\$1harvest, template0 oder template1 oder sys:internal-Datenbanken nicht umbenennen. Nur der Datenbankbesitzer oder ein [superuser](r_superusers.md#def_superusers) können eine Datenbank umbenennen. Besitzer, die keine Superuser sind, benötigen ebenfalls das CREATEDB-Recht.
*new\$1name*
Neuer Datenbankname.
OWNER TO
Ändert den Besitzer der angegebenen Datenbank. Sie können den Besitzer der aktuellen Datenbank oder einer anderen Datenbank ändern. Nur ein Superuser kann den Besitzer ändern.
*new\$1owner*
Neuer Datenbankbesitzer. Der neue Besitzer muss ein vorhandener Datenbankbenutzer mit Schreibberechtigungen sein. Weitere Informationen zu Benutzerrechten finden Sie in [GRANT](r_GRANT.md).
CONNECTION LIMIT \$1 *Limit* \$1 UNLIMITED \$1
Redshift unterstützt das Schreiben von verschachteltem JSON-Code, wenn das Abfrageergebnis SUPER-Spalten enthält. Das Limit wird für Superuser nicht durchgesetzt. Mithilfe des Schlüsselworts UNLIMITED können Sie die maximale Zahl gleichzeitiger Verbindungen festlegen. Möglicherweise gilt auch ein Limit für die Zahl der Verbindungen für die einzelnen Benutzer. Weitere Informationen finden Sie unter [CREATE USER](r_CREATE_USER.md). Der Standardwert ist UNLIMITED. Um die aktuellen Verbindungen anzuzeigen, führen Sie eine Abfrage für die Systemansicht [STV\$1SESSIONS](r_STV_SESSIONS.md) aus.
Wenn sowohl für Benutzer- als auch für Datenbankverbindungen Limits gelten, muss ein ungenutzter Verbindungsplatz verfügbar sein, der sich innerhalb beider Grenzen befindet, wenn ein Benutzer versucht, eine Verbindung herzustellen.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Eine Klausel, die angibt, ob bei der Suche oder dem Vergleich von Zeichenfolgen zwischen Groß- und Kleinschreibung unterschieden wird oder nicht.
Sie können die Unterscheidung zwischen Groß- und Kleinschreibung in der aktuellen, Datenbank ändern, selbst wenn diese leer ist.
Sie müssen über ALTER-Berechtigung für die aktuelle Datenbank verfügen, um die Unterscheidung zwischen Groß-/Kleinschreibung zu ändern. Superuser oder Datenbankbesitzer mit der CREATE DATABASE-Berechtigung können ebenfalls die Unterscheidung zwischen Groß-/Kleinschreibung in der Datenbank ändern.
CASE\$1SENSITIVE und CS sind austauschbar und liefern dieselben Ergebnisse. Ebenso sind CASE\$1INSENSITIVE und CI austauschbar und führen zu denselben Ergebnissen.
ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1
Eine Klausel, die die verwendete Isolationsstufe bei Abfragen für eine Datenbank angibt. Weitere Informationen zu Isolationsstufen finden Sie unter [Isolierungsstufen in Amazon Redshift](c_serial_isolation.md).
+ SNAPSHOT-Isolation – bietet eine Isolationsstufe mit Schutz vor Aktualisierungs- und Löschkonflikten
+ SERIALIZABLE-Isolation (serialisierbare Isolation) – bietet volle Serialisierbarkeit für gleichzeitige Transaktionen.
Beachten Sie die folgenden Elemente, wenn Sie die Isolationsstufe einer Datenbank ändern:
+ Sie müssen über Superuser-Rechte oder über die Berechtigung CREATE DATABASE (Datenbank erstellen) für die aktuelle Datenbank verfügen, um die Isolationsstufe für die Datenbank zu ändern.
+ Sie können die Isolationsstufe der `dev`-Datenbank nicht ändern.
+ Sie können die Isolationsstufe innerhalb eines Transaktionsblocks nicht ändern.
+ Der Befehl zum Ändern der Isolationsstufe schlägt fehl, wenn andere Benutzer mit der Datenbank verbunden sind.
+ Mit dem Befehl zum Ändern der Isolationsstufe können die Isolationsstufen-Einstellungen der aktuellen Sitzung geändert werden.
INTEGRATION
Ändern einer Null-ETL-Integrationsdatenbank.
REFRESH \$1\$1 ALL \$1 INERROR \$1 TABLES [IN SCHEMA *schema* [, ...]] \$1 TABLE *schema.table* [, ...]\$1
Eine Klausel, die angibt, ob Amazon Redshift alle Tabellen oder Tabellen mit Fehlern im angegebenen Schema oder der Tabelle aktualisiert. Die Aktualisierung löst aus, dass die Tabellen im angegebenen Schema oder der angegebenen Tabelle vollständig aus der Quelldatenbank repliziert werden.
Weitere Informationen finden Sie unter [Null-ETL-Integrationen](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html) im *Managementleitfaden zu Amazon Redshift*. Weitere Informationen zu Integrationszuständen finden Sie unter [SVV\$1INTEGRATION\$1TABLE\$1STATE](r_SVV_INTEGRATION_TABLE_STATE.md) und [SVV\$1INTEGRATION](r_SVV_INTEGRATION.md).
QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1
Die QUERY\$1ALL\$1STATES-Klausel legt fest, ob Null-ETL-Integrationstabellen in allen Status (`Synced`, `Failed`, `ResyncRequired` und `ResyncInitiated`) abgefragt werden können. Standardmäßig kann eine Null-ETL-Integrationstabelle nur im Status `Synced` abgefragt werden.
ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1
Die ACCEPTINVCHARS-Klausel legt fest, ob Null-ETL-Integrationstabellen mit der Aufnahme fortfahren, wenn ungültige Zeichen für den VARCHAR-Datentyp erkannt werden. Wenn ungültige Zeichen gefunden werden, wird das ungültige Zeichen durch ein standardmäßiges `?`-Zeichen ersetzt.
REFRESH\$1INTERVAL
Die REFRESH\$1INTERVAL-Klausel legt das ungefähre Zeitintervall in Sekunden für die Aktualisierung von Daten aus der Zero-ETL-Quelle in der Zieldatenbank fest. Das `interval` kann für Null-ETL-Integrationen mit dem Quelltyp Aurora MySQL, Aurora PostgreSQL oder RDS for MySQL auf 0–432 000 Sekunden (5 Tage) gesetzt werden. Für Null-ETL-Integrationen von Amazon DynamoDB kann das `interval` auf 900–432 000 Sekunden (15 Minuten – 5 Tage) festgelegt werden.
Weitere Informationen zum Erstellen von Datenbanken mit Null-ETL-Integrationen finden Sie unter [Erstellen von Zieldatenbanken in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html) im *Managementleitfaden zu Amazon Redshift*.
TRUNCATECOLUMNS [=] \$1 TRUE \$1 FALSE \$1
Die TRUNCATECOLUMNS-Klausel legt fest, ob Null-ETL-Integrationstabellen mit der Aufnahme fortfahren, wenn die Werte für die VARCHAR-Spalten- oder SUPER-Spaltenattribute den Grenzwert überschreiten. Wenn `TRUE`, werden die Werte gekürzt, sodass sie in die Spalte passen, und die Werte von JSON-Attributen, die den verfügbaren Platz überschreiten, werden gekürzt, damit sie in die SUPER-Spalte passen.
HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1 [ FOR \$1 \$1ALL\$1 TABLES [IN SCHEMA schema [, ...]] \$1 TABLE schema.table [, ...]\$1 ]
Eine Klausel, die angibt, ob Amazon Redshift den Verlaufsmodus für alle Tabellen oder für Tabellen im angegebenen Schema festlegt, die an der Null-ETL-Integration teilnehmen. Diese Option gilt nur für Datenbanken, die für die Null-ETL-Integration erstellt wurden.
Die HISTORY\$1MODE-Klausel kann auf `TRUE` oder `FALSE` gesetzt werden. Der Standardwert ist `FALSE`. Das Ein- und Ausschalten des Verlaufsmodus gilt nur für Tabellen, die sich im `Synced`-Status befinden. Informationen zu HISTORY\$1MODE finden Sie unter [Verlaufsmodus](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html) im *Managementleitfaden zu Amazon Redshift*.
## Nutzungshinweise
ALTER DATABASE-Befehle gelten für folgende, nicht für aktuelle Sitzungen. Sie müssen die Verbindung mit der geänderten Datenbank erneut herstellen, um die Auswirkungen der Änderung anzuzeigen.
## Beispiele
Im folgenden Beispiel wird die Datenbank mit dem Namen TICKIT\$1SANDBOX in TICKIT\$1TEST umbenannt:
```
alter database tickit_sandbox rename to tickit_test;
```
Im folgenden Beispiel wird der Besitzer der TICKIT-Datenbank (der aktuellen Datenbank) in DWUSER umbenannt:
```
alter database tickit owner to dwuser;
```
Im folgenden Beispiel wird die Unterscheidung zwischen Groß-/Kleinschreibung in der Datenbank sampledb geändert:
```
ALTER DATABASE sampledb COLLATE CASE_INSENSITIVE;
```
Im folgenden Beispiel wird eine Datenbank namens **sampledb** mit der Isolationsstufe SNAPSHOT geändert.
```
ALTER DATABASE sampledb ISOLATION LEVEL SNAPSHOT;
```
Im folgenden Beispiel werden die Tabellen **schema1.sample\$1table1** und **schema2.sample\$1table2** in der Datenbank **sample\$1integration\$1db** in Ihrer Null-ETL-Integration aktualisiert.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH TABLE schema1.sample_table1, schema2.sample_table2;
```
Im folgenden Beispiel werden alle synchronisierten und fehlgeschlagenen Tabellen in Ihrer Null-ETL-Integration aktualisiert.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH ALL tables;
```
Im folgenden Beispiel wird das Aktualisierungsintervall für Null-ETL-Integrationen auf 600 Sekunden festgelegt.
```
ALTER DATABASE sample_integration_db INTEGRATION SET REFRESH_INTERVAL 600;
```
Im folgenden Beispiel werden alle Tabellen aktualisiert, die sich im `ErrorState` im Schema **sample\$1schema** befinden.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH INERROR TABLES in SCHEMA sample_schema;
```
Im folgenden Beispiel wird der Verlaufsmodus für die Tabelle `myschema.table1` aktiviert.
```
ALTER DATABASE sample_integration_db INTEGRATION SET HISTORY_MODE = true FOR TABLE myschema.table1
```
Im folgenden Beispiel wird der Verlaufsmodus für alle Tabellen in `myschema` aktiviert.
```
ALTER DATABASE sample_integration_db INTEGRATION SET HISTORY_MODE = true for ALL TABLES IN SCHEMA myschema
```
# ALTER DATASHARE
Ändert die Definition eines Datashares. Sie können mit ALTER DATASHARE Objekte hinzufügen oder entfernen. Sie können nur ein Datashare in der aktuellen Datenbank ändern. Fügen Sie Objekte aus der zugehörigen Datenbank einem Datashare hinzu oder entfernen Sie sie daraus. Der Besitzer des Datashares mit den erforderlichen Berechtigungen für die hinzuzufügenden oder zu entfernenden Datashare-Objekte kann das Datashare ändern.
## Erforderliche Berechtigungen
Für ALTER DATASHARE sind folgende Berechtigungen erforderlich:
+ Superuser.
+ Benutzer mit der Berechtigung ALTER DATASHARE.
+ Benutzer mit der Berechtigung ALTER oder ALL für das Datashare.
+ Um bestimmte Objekte zu einem Datashare hinzuzufügen, müssen diese Benutzer die Berechtigung für die Objekte haben. Für diesen Fall sollten Benutzer auch Besitzer der Objekte sein oder SELECT-, USAGE- oder ALL-Berechtigungen für die Objekte haben.
## Syntax
Die folgende Syntax veranschaulicht, wie Objekte zum Datashare hinzugefügt oder von diesem entfernt werden.
```
ALTER DATASHARE datashare_name { ADD | REMOVE } {
TABLE schema.table [, ...]
| SCHEMA schema [, ...]
| FUNCTION schema.sql_udf (argtype,...) [, ...]
| ALL TABLES IN SCHEMA schema [, ...]
| ALL FUNCTIONS IN SCHEMA schema [, ...] }
```
Die folgende Syntax veranschaulicht, wie die Eigenschaften eines Datashares konfiguriert werden.
```
ALTER DATASHARE datashare_name {
[ SET PUBLICACCESSIBLE [=] TRUE | FALSE ]
[ SET INCLUDENEW [=] TRUE | FALSE FOR SCHEMA schema ] }
```
## Parameters
*datashare\$1name*
Der Name der zu ändernden Datashares.
ADD \$1 REMOVE
Eine Klausel, die angibt, ob dem Datashare Objekte hinzugefügt oder daraus entfernt werden sollen.
TABLE *schema*.*table* [, ...]
Der Name der Tabelle oder Ansicht im angegebenen Schema, die dem Datashare hinzugefügt werden soll.
SCHEMA *schema* [, ...]
Der Name des Schemas, das dem Datashare hinzugefügt werden soll.
FUNCTION *schema*.*sql\$1udf* (argtype,...) [, ...]
Der Name der benutzerdefinierten SQL-Funktion mit Argumenttypen, die dem Datashare hinzugefügt werden soll.
ALL TABLES IN SCHEMA *schema* [, ...]
Eine Klausel, die angibt, ob alle Tabellen und Ansichten im angegebenen Schema zum Datashare hinzugefügt werden sollen.
ALL FUNCTIONS IN SCHEMA *schema* [, ...] \$1
Eine Klausel, die das Hinzufügen aller Funktionen im angegebenen Schema zum Datashare festlegt.
[ SET PUBLICACCESSIBLE [=] TRUE \$1 FALSE ]
Eine Klausel, die angibt, ob ein Datashare für öffentlich zugängliche Cluster freigegeben werden kann.
[ SET INCLUDENEW [=] TRUE \$1 FALSE FOR SCHEMA *schema* ]
Eine Klausel, die angibt, ob future Tabellen, Ansichten oder benutzerdefinierte SQL-Funktionen (UDFs), die im angegebenen Schema erstellt wurden, zur Datenfreigabe hinzugefügt werden sollen. Aktuelle Tabellen, Ansichten oder SQL UDFs im angegebenen Schema werden der Datenfreigabe nicht hinzugefügt. Nur Superuser können diese Eigenschaft für jedes Datashare-Schema-Paar ändern. Standardmäßig lautet die INCLUDENEW-Klausel „false“.
## Nutzungshinweise für ALTER DATASHARE
+ Die folgenden Benutzer können ein Datashare ändern:
+ Ein Superuser
+ Der Besitzer des Datashares
+ Benutzer mit ALTER- oder ALL-Privilegien für das Datashare
+ Um bestimmte Objekte zu einem Datashare hinzuzufügen, müssen Benutzer die richtigen Berechtigungen für die Objekte haben. Benutzer sollten auch Besitzer der Objekte sein oder SELECT, USAGE- oder ALL-Berechtigungen für die Objekte haben.
+ Sie können Schemas, Tabellen, reguläre Ansichten, Late-Binding-Ansichten, materialisierte Ansichten und benutzerdefinierte SQL-Funktionen () gemeinsam nutzen. UDFs Fügen Sie einem Datashare zuerst ein Schema hinzu, bevor Sie Objekte im Schema hinzufügen.
Wenn Sie ein Schema hinzufügen, fügt Amazon Redshift nicht alle untergeordneten Objekte hinzu. Sie müssen sie explizit hinzufügen.
+ Wir empfehlen, dass Sie AWS Data Exchange Datashares erstellen, bei denen die Einstellung „Öffentlich zugänglich“ aktiviert ist.
+ Im Allgemeinen empfehlen wir, eine AWS Data Exchange Datenfreigabe nicht mit der ALTER DATASHARE-Anweisung zu ändern, um den öffentlichen Zugriff zu deaktivieren. Wenn Sie dies tun, verlieren die AWS-Konten , die Zugriff auf das Datashare haben, den Zugriff, wenn ihre Cluster öffentlich zugänglich sind. Diese Art der Änderung kann außerdem zu einer Verletzung der Datenproduktbedingungen in AWS Data Exchange führen. Eine Ausnahme dieser Empfehlung wird im Folgenden erklärt.
Das folgende Beispiel zeigt einen Fehler, wenn ein AWS Data Exchange Datashare mit deaktivierter Einstellung erstellt wird.
```
ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE;
ERROR: Alter of ADX-managed datashare salesshare requires session variable datashare_break_glass_session_var to be set to value 'c670ba4db22f4b'
```
Um zu ermöglichen, dass durch das Ändern eines AWS Data Exchange Datashare die Einstellung für den öffentlichen Zugriff deaktiviert wird, legen Sie die folgende Variable fest und führen Sie die ALTER DATASHARE-Anweisung erneut aus.
```
SET datashare_break_glass_session_var to 'c670ba4db22f4b';
```
```
ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE;
```
In diesem Fall generiert Amazon Redshift einen zufälligen Einmalwert zur Festlegung der Sitzungsvariable, um ALTER DATASHARE SET PUBLICACCESSIBLE FALSE für ein AWS Data Exchange -Datashare zu erlauben.
## Beispiele
Im folgenden Beispiel wird das Schema `public` zum Datashare `salesshare` hinzugefügt.
```
ALTER DATASHARE salesshare ADD SCHEMA public;
```
Im folgenden Beispiel wird die Tabelle `public.tickit_sales_redshift` zum Datashare `salesshare` hinzugefügt.
```
ALTER DATASHARE salesshare ADD TABLE public.tickit_sales_redshift;
```
Im folgenden Beispiel werden alle Tabellen zum Datashare `salesshare` hinzugefügt.
```
ALTER DATASHARE salesshare ADD ALL TABLES IN SCHEMA PUBLIC;
```
Im folgenden Beispiel wird die Tabelle `public.tickit_sales_redshift` vom Datashare `salesshare` entfernt.
```
ALTER DATASHARE salesshare REMOVE TABLE public.tickit_sales_redshift;
```
# ALTER DEFAULT PRIVILEGES
Definiert den Standardsatz von Zugriffsberechtigungen, die auf Objekte angewendet werden sollen, die vom angegebenen Benutzer in der Zukunft erstellt werden. Standardmäßig können Benutzer nur ihre eigenen Standardzugriffsrechte ändern. Nur Superuser können Standardberechtigungen für andere Benutzer angeben.
Sie können Standardrechte auf Rollen, Benutzer oder Benutzergruppen anwenden. Sie können Standardberechtigungen global für alle Objekte festlegen, die in der aktuellen Datenbank erstellt werden, oder für Objekte, die nur in den angegebenen Schemas erstellt werden.
Standardberechtigungen gelten nur für neue Objekte. Die Ausführung von ALTER DEFAULT PRIVILEGES ändert die Berechtigungen in Bezug auf vorhandene Objekte nicht. Informationen zum Erteilen von Berechtigungen für alle aktuellen und zukünftigen Objekte, die von einem beliebigen Benutzer in einer Datenbank oder einem Schema erstellt wurden, finden Sie unter [Bereichsbeschränkte Berechtigungen](https://docs.aws.amazon.com/redshift/latest/dg/t_scoped-permissions.html).
Um Informationen zu den Standardrechten für Datenbankbenutzer anzuzeigen, führen Sie eine Abfrage für die Systemkatalogtabelle [PG\$1DEFAULT\$1ACL](r_PG_DEFAULT_ACL.md) aus.
Weitere Informationen zu Rechten finden Sie in [GRANT](r_GRANT.md).
## Erforderliche Berechtigungen
Im Folgenden sind die erforderlichen Berechtigungen für ALTER DEFAULT PRIVILEGES aufgeführt:
+ Superuser
+ Benutzer mit der Berechtigung ALTER DEFAULT PRIVILEGES
+ Benutzer, die ihre eigenen Standardzugriffsberechtigungen ändern
+ Benutzer, die Berechtigungen für Schemas festlegen, auf die sie Zugriffsberechtigungen haben
## Syntax
```
ALTER DEFAULT PRIVILEGES
[ FOR USER target_user [, ...] ]
[ IN SCHEMA schema_name [, ...] ]
grant_or_revoke_clause
where grant_or_revoke_clause is one of:
GRANT { { SELECT | INSERT | UPDATE | DELETE | DROP | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
REVOKE [ GRANT OPTION FOR ] { { SELECT | INSERT | UPDATE | DELETE | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
FROM user_name [, ...] [ RESTRICT ]
REVOKE { { SELECT | INSERT | UPDATE | DELETE | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
FROM user_name [, ...] [ RESTRICT ]
REVOKE { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
FROM user_name [, ...] [ RESTRICT ]
REVOKE { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
```
## Parameters
FOR USER *target\$1user*
Optional. Der Name des Benutzers, für den Standardrechte definiert sind. Nur Superuser können Standardrechte für andere Benutzer ändern. Der Standardwert ist der aktuelle Benutzer.
IN SCHEMA *schema\$1name*
Optional. Wenn eine IN SCHEMA-Klausel angezeigt wird, gelten die angegebenen Standardrechte für neue Objekte, die im angegebenen *schema\$1name* erstellt werden. In diesem Fall müssen der Benutzer oder die Benutzergruppe, die das Ziel von ALTER DEFAULT PRIVILEGES ist, das CREATE-Recht für das angegebene Schema besitzen. Standardrechte, die für ein Schema spezifisch sind, werden vorhandenen globalen Standardrechten hinzugefügt. Standardmäßig werden Standardrechte global auf die gesamte Datenbank angewendet.
GRANT
Der Satz von Rechten, der den angegebenen Benutzern oder Gruppen für alle neuen Tabellen und Ansichten, Funktionen oder gespeicherten Prozeduren gewährt werden soll, die vom angegebenen Benutzer erstellt werden. Sie können mit der GRANT-Klausel die gleichen Rechte und Optionen wie mit dem Befehl [GRANT](r_GRANT.md) festlegen.
WITH GRANT OPTION
Eine Klausel, die angibt, dass der Benutzer, der die Rechte erhält, anderen Benutzern die gleichen Rechte gewähren kann. Sie können einer Gruppe oder PUBLIC keine Rechte WITH GRANT OPTION gewähren.
TO *user\$1name* \$1 ROLE *role\$1name* \$1 GROUP *group\$1name*
Der Name des Benutzers, der Rolle oder der Benutzergruppe, auf die die angegebenen Standardrechte angewendet werden.
REVOKE
Der Satz von Rechten, der den angegebenen Benutzern oder Gruppen für alle neuen Tabellen, Funktionen oder gespeicherten Prozeduren entzogen werden soll, die vom angegebenen Benutzer erstellt werden. Sie können mit der REVOKE-Klausel die gleichen Rechte und Optionen wie mit dem Befehl [REVOKE](r_REVOKE.md) festlegen.
GRANT OPTION FOR
Eine Klausel, die nur die Option, anderen Benutzern ein spezifisches Recht zu gewähren, und nicht das Recht selbst widerruft. Sie können GRANT OPTION nicht für eine Gruppe oder PUBLIC widerrufen.
FROM *user\$1name* \$1 ROLE *role\$1name* \$1 GROUP *group\$1name*
Der Name des Benutzers, der Rolle oder der Benutzergruppe, für die die angegebenen Standardrechte standardmäßig widerrufen werden.
RESTRICT
Die Option RESTRICT widerruft nur die Berechtigungen, die der Benutzer direkt gewährt hat. Dies ist die Standardeinstellung.
## Beispiele
Angenommen, Sie möchten einem Benutzer in der Benutzergruppe `report_readers` das Recht gewähren, alle Tabellen und Ansichten anzuzeigen, die vom Benutzer `report_admin` erstellt wurden. In diesem Fall führen Sie den folgenden Befehl als Superuser aus.
```
alter default privileges for user report_admin grant select on tables to group report_readers;
```
Im folgenden Beispiel gewährt der erste Befehl SELECT-Rechte für alle neuen Tabellen, die Sie erstellen. Jedes Mal, wenn Sie eine neue Ansicht erstellen, müssen Sie der Ansicht explizit Rechte gewähren oder den Befehl `alter default privileges` erneut ausführen.
```
alter default privileges grant select on tables to public;
```
Im folgenden Beispiel wird der Benutzergruppe `sales_admin` das INSERT-Recht für alle neuen Tabellen und Ansichten gewährt, die Sie im Schema `sales` erstellen.
```
alter default privileges in schema sales grant insert on tables to group sales_admin;
```
Im folgenden Beispiel wird der Befehl ALTER DEFAULT PRIVILEGES im vorherigen Beispiel zurückgenommen.
```
alter default privileges in schema sales revoke insert on tables from group sales_admin;
```
Standardmäßig besitzt die Benutzergruppe PUBLIC die Ausführungsberechtigung für alle neuen, von Benutzern definierten Funktionen. Um die `public`-Ausführungsberechtigungen für Ihre neuen Funktionen zu widerrufen und dann die Ausführungsberechtigung nur der Benutzergruppe `dev_test` zu gewähren, führen Sie die folgenden Befehle aus.
```
alter default privileges revoke execute on functions from public;
alter default privileges grant execute on functions to group dev_test;
```
# ALTER EXTERNAL SCHEMA
Ändert ein vorhandenes externes Schema in der aktuellen Datenbank. Nur Schemabesitzer, Superuser oder Benutzer mit ALTER-Rechten für das Schema können es ändern. Nur externe Schemas, die aus DATA CATALOG, KAFKA oder MSK erstellt wurden, können geändert werden.
Der Besitzer dieses Schemas gibt den Befehl CREATE EXTERNAL SCHEMA aus. Mit dem Befehl ALTER SCHEMA können Sie den Besitzer eines externen Schemas ändern. Mit dem Befehl GRANT gewähren Sie anderen Benutzern oder Benutzergruppen Zugriff auf das Schema.
Sie können die Befehle GRANT oder REVOKE nicht für Berechtigungen in einer externen Tabelle verwenden. Gewähren oder widerrufen Sie stattdessen die Berechtigungen für das externe Schema.
Weitere Informationen finden Sie hier:
+ [ALTER SCHEMA](r_ALTER_SCHEMA.md)
+ [GRANT](r_GRANT.md)
+ [REVOKE](r_REVOKE.md)
+ [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)
+ [Aktivieren der mTLS-Authentifizierung für ein vorhandenes externes Schema](materialized-view-streaming-ingestion-mtls.md#materialized-view-streaming-ingestion-mtls-alter)
Um Details zu externen Schemata anzuzeigen, führen Sie eine Abfrage für die Systemansicht SVV\$1EXTERNAL\$1SCHEMAS aus. Weitere Informationen finden Sie unter [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md).
## Syntax
```
ALTER EXTERNAL SCHEMA schema_name
[ IAM_ROLE [ default | 'SESSION' | 'arn:aws:iam:::role/' ] ]
[ AUTHENTICATION [ none | iam | mtls] ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'asm-secret-arn' ]
[ URI 'Kafka bootstrap URL' ]
```
Wenn Sie über ein vorhandenes externes Schema verfügen, das Sie für die Streaming-Aufnahme verwenden, und Sie gegenseitiges TLS für die Authentifizierung implementieren möchten, können Sie einen Befehl wie den folgenden ausführen, der die mTLS-Authentifizierung und den ARN des ACM-Zertifikats in ACM spezifiziert.
```
ALTER EXTERNAL SCHEMA schema_name
AUTHENTICATION mtls
AUTHENTICATION_ARN 'arn:aws:acm:us-east-1:444455556666:certificate/certificate_ID';
```
Sie können auch die mTLS-Authentifizierung ändern, mit Verweis auf den geheimen ARN in Secrets Manager.
```
ALTER EXTERNAL SCHEMA schema_name
AUTHENTICATION mtls
SECRET_ARN 'arn:aws:secretsmanager:us-east-1:012345678910:secret:myMTLSSecret';
```
Das folgende Beispiel zeigt, wie der URI für ALTER EXTERNAL SCHEMA geändert wird:
```
ALTER EXTERNAL SCHEMA schema_name
URI 'lkc-ghidef-67890.centralus.azure.glb.confluent.cloud:9092';
```
Das folgende Beispiel zeigt, wie die IAM-Rolle für ALTER EXTERNAL SCHEMA geändert wird:
```
ALTER EXTERNAL SCHEMA schema_name
IAM_ROLE 'arn:aws:iam::012345678901:role/testrole';
```
## Parameters
IAM\$1ROLE [Standard \$1 'SESSION' \$1 'arn:aws:iam: :< Account-ID>:role/ ']AWS
Verwenden Sie das Schlüsselwort `default`, damit Amazon Redshift die IAM-Rolle verwendet, die als Standard festgelegt ist.
Verwenden Sie `'SESSION'`, wenn Sie über eine Verbundidentität eine Verbindung zu Ihrem Amazon-Redshift-Cluster herstellen und über das mit diesem Befehl erstellte externe Schema auf die Tabellen zugreifen.
Weitere Informationen finden Sie unter [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
AUTHENTICATION
Der für die Streaming-Erfassung definierte Authentifizierungstyp. Die Streaming-Erfassung mit Authentifizierungstypen kann mit Apache Kafka, Confluent Cloud und Amazon Managed Streaming für Apache Kafka verwendet werden. Weitere Informationen finden Sie unter [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
AUTHENTICATION\$1ARN
Der ARN des AWS Certificate Manager Zertifikats, das von Amazon Redshift für die MTLS-Authentifizierung mit Apache Kafka, Confluent Cloud oder Amazon Managed Streaming for Apache Kafka (Amazon MSK) verwendet wird. Der ARN ist in der ACM-Konsole verfügbar, wenn Sie das ausgegebene Zertifikat auswählen.
SECRET\$1ARN
Der Amazon-Ressourcenname (ARN) eines unterstützten Geheimnisses, das mit erstellt wurde AWS Secrets Manager. Informationen zum Erstellen und Abrufen eines ARN für ein Secret finden Sie unter [Secrets mit AWS Secrets Manager verwalten](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) im *AWS Secrets Manager -Benutzerhandbuch* und [Abrufen des Amazon-Ressourcennamens (ARN) des Secrets in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration-retrieving-secret.html).
URI
Die Bootstrap-URL des Clusters in Apache Kafka, Confluent Cloud oder Amazon Managed Streaming für Apache Kafka (Amazon MSK). Der Endpunkt muss vom Amazon-Redshift-Cluster aus erreichbar (routingfähig) sein. Weitere Informationen finden Sie unter [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
# ALTER EXTERNAL VIEW
Verwenden Sie den Befehl ALTER EXTERNAL VIEW, um Ihre externe Ansicht zu aktualisieren. Je nachdem, welche Parameter Sie verwenden, können andere SQL-Engines wie Amazon Athena und Amazon EMR Spark, die ebenfalls auf diese Ansicht verweisen können, betroffen sein. Weitere Informationen zu Data-Catalog-Ansichten finden Sie unter [AWS Glue Data Catalog -Ansichten](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html).
## Syntax
```
ALTER EXTERNAL VIEW schema_name.view_name
{catalog_name.schema_name.view_name | awsdatacatalog.dbname.view_name | external_schema_name.view_name}
[FORCE] { AS (query_definition) | REMOVE DEFINITION }
```
## Parameters
*schema\$1name.view\$1name*
Das Schema, das an Ihre AWS Glue Datenbank angehängt ist, gefolgt vom Namen der Ansicht.
catalog\$1name.schema\$1name.view\$1name \$1 awsdatacatalog.dbname.view\$1name \$1 external\$1schema\$1name.view\$1name
Die Notation des Schemas, das beim Ändern der Ansicht verwendet werden soll. Sie können angeben AWS Glue Data Catalog, ob Sie eine von Ihnen erstellte Glue-Datenbank oder ein von Ihnen erstelltes externes Schema verwenden möchten. Weitere Informationen finden Sie unter [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) und [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
FORCE
Gibt an, ob die Definition der Ansicht aktualisiert werden AWS Lake Formation soll, auch wenn die in der Tabelle referenzierten Objekte nicht mit anderen SQL-Engines übereinstimmen. Wenn Lake Formation die Ansicht aktualisiert, gilt die Ansicht für die anderen SQL-Engines als veraltet, bis auch diese Engines aktualisiert werden.
*AS query\$1definition*
Die Definition der SQL-Abfrage, die Amazon Redshift ausführt, um die Ansicht zu ändern.
REMOVE DEFINITION
Ob die Ansichten gelöscht und neu erstellt werden sollen. Ansichten müssen gelöscht und neu erstellt werden, um sie als `PROTECTED` zu kennzeichnen.
## Beispiele
Im folgenden Beispiel wird eine Datenkatalog-Ansicht mit dem Namen sample\$1schema.glue\$1data\$1catalog\$1view geändert.
```
ALTER EXTERNAL VIEW sample_schema.glue_data_catalog_view
FORCE
REMOVE DEFINITION
```
# ALTER FUNCTION
Benennt eine Funktion um oder ändert den Besitzer. Erforderlich sind sowohl der Name der Funktion als auch die Datentypen. Nur der Besitzer oder ein Superuser kann eine Funktion umbenennen. Nur ein Superuser kann den Besitzer einer Funktion ändern.
## Syntax
```
ALTER FUNCTION function_name ( { [ py_arg_name py_arg_data_type | sql_arg_data_type } [ , ... ] ] )
RENAME TO new_name
```
```
ALTER FUNCTION function_name ( { [ py_arg_name py_arg_data_type | sql_arg_data_type } [ , ... ] ] )
OWNER TO { new_owner | CURRENT_USER | SESSION_USER }
```
## Parameters
*function\$1name*
Das Name der Funktion, die geändert werden soll. Geben Sie entweder den Namen der Funktion im aktuellen Suchpfad an oder verwenden Sie das Format `schema_name.function_name`, um ein spezifisches Schema zu verwenden.
*py\$1arg\$1name py\$1arg\$1data\$1type \$1 sql\$1arg\$1data\$1type*
Optional. Eine Liste der Namen von Eingabeargumenten und Datentypen für die benutzerdefinierte Python-Funktion oder eine Liste der Datentypen von Eingabeargumenten für die benutzerdefinierte SQL-Funktion.
*new\$1name*
Ein neuer Name für die benutzerdefinierte Funktion.
*new\$1owner* \$1 CURRENT\$1USER \$1 SESSION\$1USER
Ein neuer Besitzer für die benutzerdefinierte Funktion.
## Beispiele
Im folgenden Beispiel wird der Namen einer Funktion von `first_quarter_revenue` in `quarterly_revenue` geändert.
```
ALTER FUNCTION first_quarter_revenue(bigint, numeric, int)
RENAME TO quarterly_revenue;
```
Im folgenden Beispiel wird der Besitzer der Funktion `quarterly_revenue` in `etl_user` geändert.
```
ALTER FUNCTION quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
# ALTER GROUP
Ändert eine Benutzergruppe. Mit diesem Befehl können Sie der Gruppe Benutzer hinzufügen, Benutzer aus der Gruppe entfernen oder die Gruppe umbenennen.
## Syntax
```
ALTER GROUP group_name
{
ADD USER username [, ... ] |
DROP USER username [, ... ] |
RENAME TO new_name
}
```
## Parameters
*group\$1name*
Der Name der Benutzergruppe, die geändert werden soll.
ADD
Fügt einer Benutzergruppe einen Benutzer hinzu.
DROP
Entfernt einen Benutzer aus einer Benutzergruppe.
*username (Benutzername*
Der Name des Benutzers, der der Gruppe hinzugefügt oder aus der Gruppe entfernt werden soll.
RENAME TO
Benennt die Benutzergruppe um. Gruppennamen, die mit zwei Unterstrichen beginnen, sind für die interne Verwendung durch Amazon Redshift reserviert. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
*new\$1name*
Der neue Name der Benutzergruppe.
## Beispiele
Im folgenden Beispiel wird der Gruppe ADMIN\$1GROUP ein Benutzer mit dem Namen DWUSER hinzugefügt.
```
ALTER GROUP admin_group
ADD USER dwuser;
```
Im folgenden Beispiel wird die Gruppe ADMIN\$1GROUP in ADMINISTRATORS umbenannt.
```
ALTER GROUP admin_group
RENAME TO administrators;
```
Im folgenden Beispiel werden der Gruppe ADMIN\$1GROUP zwei Benutzer hinzugefügt.
```
ALTER GROUP admin_group
ADD USER u1, u2;
```
Im folgenden Beispiel werden aus der Gruppe ADMIN\$1GROUP zwei Benutzer entfernt.
```
ALTER GROUP admin_group
DROP USER u1, u2;
```
# ALTER IDENTITY PROVIDER
Ändert einen Identitätsanbieter, um neue Parameter und Werte zuzuweisen. Wenn Sie diesen Befehl ausführen, werden alle zuvor festgelegten Parameterwerte gelöscht, bevor die neuen Werte zugewiesen werden. Nur Superuser können Identitätsanbieter ändern.
## Syntax
```
ALTER IDENTITY PROVIDER identity_provider_name
[PARAMETERS parameter_string]
[NAMESPACE namespace]
[IAM_ROLE iam_role]
[AUTO_CREATE_ROLES
[ TRUE [ { INCLUDE | EXCLUDE } GROUPS LIKE filter_pattern] |
FALSE
]
[DISABLE | ENABLE]
```
## Parameters
*identity\$1provider\$1name*
Name des neuen Identitätsanbieters. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
*parameter\$1string*
Eine Zeichenfolge mit einem ordnungsgemäß formatierten JSON-Objekt, das die für den spezifischen Identitätsanbieter erforderlichen Parameter und Werte enthält.
*Namespace*
Der Namespace der Organisation.
*iam\$1role*
Die IAM-Rolle, die Berechtigungen für die Verbindung zum IAM Identity Center bereitstellt. Dieser Parameter ist nur anwendbar, wenn der Identitätsanbietertyp ist. AWSIDC
*auto\$1create\$1roles*
Aktiviert oder deaktiviert das Feature für das automatische Erstellen von Rollen. Wenn der Wert TRUE ist, aktiviert Amazon Redshift das Feature zum automatischen Erstellen von Rollen. Wenn der Wert FALSE ist, deaktiviert Amazon Redshift das Feature zum automatischen Erstellen von Rollen. Wenn der Wert für diesen Parameter nicht angegeben ist, bestimmt Amazon Redshift den Wert mithilfe der folgenden Logik:
+ Wenn `AUTO_CREATE_ROLES` bereitgestellt ist, der Wert jedoch nicht angegeben ist, wird der Wert auf TRUE festgelegt.
+ Wenn er `AUTO_CREATE_ROLES` nicht angegeben wird und der Identitätsanbieter schon AWSIDC, wird der Wert auf FALSE gesetzt.
+ Wenn `AUTO_CREATE_ROLES` nicht bereitgestellt ist und der Identitätsanbieter Azure ist, wird der Wert auf TRUE festgelegt.
Um Gruppen einzuschließen, geben Sie `INCLUDE` an. Die Standardeinstellung ist „leer“. Das bedeutet, dass alle Gruppen eingeschlossen werden, wenn `AUTO_CREATE_ROLES` aktiviert ist.
Um Gruppen auszuschließen, geben Sie `EXCLUDE` an. Die Standardeinstellung ist „leer“. Das bedeutet, dass keine Gruppen ausgeschlossen werden, wenn `AUTO_CREATE_ROLES` aktiviert ist.
*filter\$1pattern*
Ein gültiger UTF-8-Zeichenfolgenausdruck mit einem Muster zum Abgleichen von Gruppennamen. Die Option LIKE führt eine Suche durch, bei der zwischen Groß- und Kleinschreibung unterschieden wird und welche die folgenden Metazeichen für den Mustervergleich unterstützt:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_ALTER_IDENTITY_PROVIDER.html)
Wenn *filter-pattern* keine Metazeichen enthält, repräsentiert das Muster die Zeichenfolge selbst. In diesem Fall liefert LIKE dasselbe Ergebnis wie der Gleichheitsoperator.
*filter\$1pattern* unterstützt die folgenden Zeichen:
+ Groß- und Kleinbuchstaben (A–Z und a–z)
+ Ziffern (0–9)
+ Die folgenden Sonderzeichen.
```
_ % ^ * + ? { } , $
```
*DISABLE oder ENABLE*
Aktiviert oder deaktiviert einen Identitätsanbieter. Der Standard ist ENABLE.
## Beispiele
Im folgenden Beispiel wird ein Identitätsanbieter mit dem Namen *oauth\$1standard* geändert. Dies gilt insbesondere, wenn Microsoft Azure AD der Identitätsanbieter ist.
```
ALTER IDENTITY PROVIDER oauth_standard
PARAMETERS '{"issuer":"https://sts.windows.net/2sdfdsf-d475-420d-b5ac-667adad7c702/",
"client_id":"87f4aa26-78b7-410e-bf29-57b39929ef9a",
"client_secret":"BUAH~ewrqewrqwerUUY^%tHe1oNZShoiU7",
"audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift"]
}'
```
Das folgende Beispiel zeigt, wie der Namespace des Identitätsanbieters festgelegt wird. Dies kann für Microsoft Azure AD gelten, wenn es einer Anweisung wie im vorherigen Beispiel folgt, oder für einen anderen Identitätsanbieter. Dies kann auch für den Fall gelten, dass Sie einen vorhandenen, von Amazon Redshift bereitgestellten Cluster oder eine Arbeitsgruppe in Amazon Redshift Serverless mit IAM Identity Center verbinden, wenn Sie eine Verbindung über eine verwaltete Anwendung eingerichtet haben.
```
ALTER IDENTITY PROVIDER "my-redshift-idc-application"
NAMESPACE 'MYCO';
```
Das folgende Beispiel legt die IAM-Rolle fest und gilt für den Anwendungsfall der Konfiguration der Redshift-Integration mit IAM Identity Center.
```
ALTER IDENTITY PROVIDER "my-redshift-idc-application"
IAM_ROLE 'arn:aws:iam::123456789012:role/myadministratorrole';
```
Weitere Informationen zum Einrichten einer Verbindung mit IAM Identity Center aus Redshift finden Sie unter [Redshift mit IAM Identity Center verbinden, um Benutzern eine Single-Sign-On-Erfahrung zu bieten](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-idp-connect.html).
**Deaktivieren eines Identitätsanbieters**
Die folgende Beispielanweisung zeigt, wie ein Identitätsanbieter deaktiviert wird. Wenn er deaktiviert ist, können sich Verbundbenutzer des Identitätsanbieters erst wieder beim Cluster anmelden, wenn er wieder aktiviert ist.
```
ALTER IDENTITY PROVIDER "redshift-idc-app" DISABLE;
```
# ALTER MASKING POLICY
Ändert eine vorhandene Richtlinie für die dynamische Datenmaskierung. Weitere Informationen zur dynamischen Datenmaskierung finden Sie unter [Dynamische Datenmaskierung](t_ddm.md).
Superuser und Benutzer oder Rollen mit der Rolle sys:secadmin können eine Maskierungsrichtlinie ändern.
## Syntax
```
ALTER MASKING POLICY
{ policy_name | database_name.policy_name }
USING (masking_expression);
```
## Parameters
*policy\$1name*
Der Name der Maskierungsrichtlinie. Dies muss der Name einer Maskierungsrichtlinie sein, die bereits in der Datenbank vorhanden ist.
database\$1name
Der Name der Datenbank, aus der die Richtlinie erstellt wurde. Bei der Datenbank kann es sich um die verbundene Datenbank oder um eine Datenbank handeln, die Verbundberechtigungen von Amazon Redshift unterstützt.
*masking\$1expression*
Der SQL-Ausdruck, der zur Transformation der Zielspalten verwendet wird. Er kann mithilfe von Datenmanipulationsfunktionen wie z. B. Funktionen zur Zeichenkettenmanipulation oder in Verbindung mit benutzerdefinierten Funktionen geschrieben werden, die in SQL, Python oder mit AWS Lambda geschrieben wurden.
Der Ausdruck muss mit den Eingabespalten und Datentypen des ursprünglichen Ausdrucks übereinstimmen. Wenn die Eingabespalten der ursprünglichen Maskierungsrichtlinie beispielsweise `sample_1 FLOAT` und `sample_2 VARCHAR(10)` sind, können Sie die Maskierungsrichtlinie nicht so ändern, dass sie eine dritte Spalte oder FLOAT und BOOLEAN verwendet. Wenn Sie eine Konstante als Maskierungsausdruck verwenden, müssen Sie sie explizit in einen dem Eingabetyp entsprechenden Typ umwandeln.
Sie benötigen USAGE-Berechtigung für alle benutzerdefinierten Funktionen, die Sie im Maskierungsausdruck verwenden.
Informationen zur Verwendung von ALTER MASKING POLICY im Amazon Redshift Federated Permissions Catalog finden Sie unter [Verwaltung der Zugriffskontrolle mit Amazon Redshift Redshift-Verbundberechtigungen](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
# ALTER MATERIALIZED VIEW
Ändert die Attribute einer materialisierten Ansicht.
## Syntax
```
ALTER MATERIALIZED VIEW mv_name
{
AUTO REFRESH { YES | NO }
| ALTER DISTKEY column_name
| ALTER DISTSTYLE ALL
| ALTER DISTSTYLE EVEN
| ALTER DISTSTYLE KEY DISTKEY column_name
| ALTER DISTSTYLE AUTO
| ALTER [COMPOUND] SORTKEY ( column_name [,...] )
| ALTER SORTKEY AUTO
| ALTER SORTKEY NONE
| ROW LEVEL SECURITY { ON | OFF } [ CONJUNCTION TYPE { AND | OR } ] [FOR DATASHARES]
};
```
## Parameters
*mv\$1name*
Der Name der materialisierten Ansicht, der geändert werden soll.
AUTO REFRESH \$1 YES \$1 NO \$1
Eine Klausel, die das automatische Aktualisieren einer materialisierten Ansicht aktiviert oder deaktiviert. Weitere Informationen zur automatischen Aktualisierung von materialisierten Ansichten finden Sie unter [Aktualisieren einer materialisierten Ansicht](materialized-view-refresh.md).
ALTER DISTSTYLE ALL
Eine Klausel, die den vorhandenen Verteilungsstil einer Beziehung in `ALL` ändert. Berücksichtigen Sie dabei Folgendes:
+ ALTER DISTSTYLE, ALTER SORTKEY und VACUUM können nicht gleichzeitig für dieselbe Beziehung ausgeführt werden.
+ Wenn VACUUM derzeit ausgeführt wird, wird beim Ausführen von ALTER DISTSTYLE ALL ein Fehler zurückgegeben.
+ Wenn ALTER DISTSTYLE ALL ausgeführt wird, wird keine Hintergrundbereinigung für eine Beziehung gestartet.
+ Der Befehl ALTER DISTSTYLE ALL wird für Beziehungen mit verschachtelten Sortierschlüsseln und temporären Tabellen nicht unterstützt.
+ Wenn der Verteilungsstil zuvor als AUTO definiert war, ist die Beziehung kein Kandidat mehr für eine automatische Tabellenoptimierung.
Weitere Informationen zu DISTSTYLE ALL finden Sie unter [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTSTYLE EVEN
Eine Klausel, die den vorhandenen Verteilungsstil einer Beziehung in `EVEN` ändert. Berücksichtigen Sie dabei Folgendes:
+ ALTER DISTSTYLE, ALTER SORTKEY und VACUUM können nicht gleichzeitig für dieselbe Beziehung ausgeführt werden.
+ Wenn VACUUM gerade ausgeführt wird, wird beim Ausführen von ALTER DISTSTYLE EVEN ein Fehler zurückgegeben.
+ Wenn ALTER DISTSTYLE EVEN ausgeführt wird, wird keine Hintergrundbereinigung für eine Beziehung gestartet.
+ Der Befehl ALTER DISTSTYLE EVEN wird für Beziehungen mit verschachtelten Sortierschlüsseln und temporären Tabellen nicht unterstützt.
+ Wenn der Verteilungsstil zuvor als AUTO definiert war, ist die Beziehung kein Kandidat mehr für eine automatische Tabellenoptimierung.
Weitere Informationen zu DISTSTYLE EVEN finden Sie unter [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTKEY *column\$1name* oder ALTER DISTSTYLE KEY DISTKEY *column\$1name*
Eine Klausel, die die Spalte ändert, die als Verteilungsschlüssel einer Beziehung verwendet wird. Berücksichtigen Sie dabei Folgendes:
+ VACUUM und ALTER DISTKEY können nicht gleichzeitig für dieselbe Beziehung ausgeführt werden.
+ Wenn VACUUM bereits ausgeführt wird, gibt ALTER DISTKEY einen Fehler zurück.
+ Wenn ALTER DISTKEY ausgeführt wird, wird keine Hintergrundbereinigung für eine Beziehung gestartet.
+ Wenn ALTER DISTKEY ausgeführt wird, dann gibt die Vordergrundbereinigung einen Fehler zurück.
+ Sie können nur jeweils einen ALTER DISTKEY-Befehl für eine Beziehung ausführen.
+ Der Befehl ALTER DISTKEY wird für Beziehungen mit verschachtelten Sortierschlüsseln nicht unterstützt.
+ Wenn der Verteilungsstil zuvor als AUTO definiert war, ist die Beziehung kein Kandidat mehr für eine automatische Tabellenoptimierung.
Wenn Sie DISTSTYLE KEY angeben, werden die Daten nach den Werten in der DISTKEY-Spalte verteilt. Weitere Informationen zu DISTSTYLE finden Sie unter [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTSTYLE AUTO
Eine Klausel, die den vorhandenen Verteilungsstil einer Beziehung in AUTO ändert.
Wenn Sie einen Verteilungsstil auf AUTO ändern, wird der Verteilungsstil der Beziehung wie folgt festgelegt:
+ Eine kleine Beziehung mit DISTSTYLE ALL wird in AUTO(ALL) umgewandelt.
+ Eine kleine Beziehung mit DISTSTYLE EVEN wird in AUTO(ALL) umgewandelt.
+ Eine kleine Beziehung mit DISTSTYLE KEY wird in AUTO(ALL) umgewandelt.
+ Eine große Beziehung mit DISTSTYLE ALL wird in AUTO(EVEN) umgewandelt.
+ Eine große Beziehung mit DISTSTYLE EVEN wird in AUTO(EVEN) umgewandelt.
+ Eine große Beziehung mit DISTSTYLE KEY wird in AUTO(KEY) umgewandelt und der DISTKEY bleibt erhalten. In diesem Fall führt Amazon Redshift keine Änderungen für die Beziehung aus.
Wenn Amazon Redshift feststellt, dass ein neuer Verteilungsstil oder Schlüssel die Leistung von Abfragen verbessert, ändert Amazon Redshift den Verteilungsstil oder Schlüssel Ihrer Beziehung möglicherweise in der Zukunft. Beispielsweise könnte Amazon Redshift eine Beziehung mit dem DISTSTYLE-Wert AUTO(KEY) in AUTO(EVEN) konvertieren oder umgekehrt. Weitere Informationen zum Verhalten bei Änderungen von Verteilungsschlüsseln, einschließlich Datenneuverteilung und Sperren, finden Sie unter [Empfehlungen für Amazon Redshift Advisor](https://docs.aws.amazon.com/redshift/latest/dg/advisor-recommendations.html#alter-diststyle-distkey-recommendation).
Weitere Informationen zu DISTSTYLE AUTO finden Sie unter [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
Um den Verteilungsstil einer Beziehung anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1TABLE\$1INFO ab. Weitere Informationen finden Sie unter [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Um die Empfehlungen von Amazon Redshift Advisor für Beziehungen anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS ab. Weitere Informationen finden Sie unter [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Um die von Amazon Redshift durchgeführten Aktionen anzuzeigen, fragen Sie die Systemkatalogansicht SVL\$1AUTO\$1WORKER\$1ACTION ab. Weitere Informationen finden Sie unter [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER [COMPOUND] SORTKEY ( *column\$1name* [,...] )
Eine Klausel, die den für eine Beziehung verwendeten Sortierschlüssel ändert oder hinzufügt. ALTER SORTKEY wird für temporäre Tabellen nicht unterstützt.
Wenn Sie einen Sortierschlüssel ändern, kann sich die Kompressionskodierung von Spalten im neuen oder ursprünglichen Sortierschlüssel ändern. Wenn für die Beziehung keine Kodierung explizit definiert ist, weist Amazon Redshift automatisch Komprimierungskodierungen wie folgt zu:
+ Spalten, die als Sortierschlüssel definiert sind, wird die RAW-Kompression zugewiesen.
+ Spalten, die als die Datentypen BOOLEAN, REAL oder DOUBLE PRECISION definiert sind, wird die RAW-Kodierung zugewiesen.
+ Spalten, die als SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIME, TIMETZ, TIMESTAMP oder TIMESTAMPTZ definiert sind, wird Komprimierung zugewiesen. AZ64
+ Spalten, die als CHAR oder VARCHAR definiert sind, wird LZO-Komprimierung zugewiesen.
Berücksichtigen Sie dabei Folgendes:
+ Sie können maximal 400 Spalten für einen Sortierschlüssel pro Beziehung definieren.
+ Sie können einen überlappenden Sortierschlüssel in einen zusammengesetzten Sortierschlüssel oder in keinen Sortierschlüssel ändern. Es ist jedoch nicht möglich, einen zusammengesetzten Sortierschlüssel in einen überlappenden Sortierschlüssel zu ändern.
+ Wenn der Sortierschlüssel zuvor als AUTO definiert war, dann ist die Tabelle kein Kandidat mehr für die automatische Beziehungsoptimierung.
+ Amazon Redshift empfiehlt die Verwendung von RAW-Kodierung (keine Komprimierung) für Spalten, die als Sortierschlüssel definiert sind. Wenn Sie eine Spalte ändern, um sie als Sortierschlüssel zu wählen, wird die Komprimierung der Spalte auf RAW-Komprimierung (keine Komprimierung) geändert. Dies kann den Speicherbedarf der Beziehung erhöhen. Wie stark die Beziehungsgröße zunimmt, ist von der jeweiligen Beziehungsdefinition und dem Beziehungsinhalt abhängig. Weitere Informationen zur Komprimierung finden Sie unter [Kompressionskodierungen](c_Compression_encodings.md).
Beim Laden von Daten in eine Beziehung werden die Daten in der Reihenfolge des Sortierschlüssels geladen. Wenn Sie den Sortierschlüssel ändern, ordnet Amazon Redshift die Daten neu an. Weitere Informationen zu SORTKEY finden Sie unter [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER SORTKEY AUTO
Eine Klausel, die den Sortierschlüssel der Zielbeziehung in AUTO ändert oder hinzufügt. ALTER SORTKEY AUTO wird für temporäre Tabellen nicht unterstützt.
Wenn Sie einen Sortierschlüssel in AUTO ändern, behält Amazon Redshift den vorhandenen Sortierschlüssel der Beziehung bei.
Wenn Amazon Redshift feststellt, dass ein neuer Sortierschlüssel die Leistung von Abfragen verbessert, ändert Amazon Redshift den Sortierschlüssel Ihrer Beziehung möglicherweise in der Zukunft.
Weitere Informationen zu SORTKEY AUTO finden Sie im Abschnitt [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
Um den Sortierschlüssel einer Beziehung anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1TABLE\$1INFO ab. Weitere Informationen finden Sie unter [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Um die Empfehlungen von Amazon Redshift Advisor für Beziehungen anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS ab. Weitere Informationen finden Sie unter [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Um die von Amazon Redshift durchgeführten Aktionen anzuzeigen, fragen Sie die Systemkatalogansicht SVL\$1AUTO\$1WORKER\$1ACTION ab. Weitere Informationen finden Sie unter [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER SORTKEY NONE
Eine Klausel, die den Sortierschlüssel der Zielbeziehung entfernt.
Wenn der Sortierschlüssel zuvor als AUTO definiert war, dann ist die Tabelle kein Kandidat mehr für die automatische Beziehungsoptimierung.
ROW LEVEL SECURITY \$1 ON \$1 OFF \$1 [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ] [ FOR DATASHARES ]
Eine Klausel, die die Sicherheit auf Zeilenebene für eine Relation aktiviert oder deaktiviert.
Wenn die Sicherheit auf Zeilenebene für eine Relation aktiviert ist, können Sie nur die Zeilen lesen, für die Ihnen die Richtlinie auf Zeilenebene Zugriff gewährt. Wenn es keine Richtlinie gibt, die Ihnen Zugriff auf die Relation gewährt, können Sie keine Zeilen aus der Relation sehen. Nur Superuser und Benutzer oder Rollen, denen die `sys:secadmin`-Rolle zugewiesen ist, können die Klausel ROW LEVEL SECURITY festlegen. Weitere Informationen finden Sie unter [Sicherheit auf Zeilenebene](t_rls.md).
+ [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ]
Eine Klausel, mit der Sie den Verbindungstyp einer Sicherheitsrichtlinie auf Zeilenebene für eine Relation auswählen können. Wenn einer Relation mehrere Sicherheitsrichtlinien auf Zeilenebene zugeordnet sind, können Sie die Richtlinien mit der AND- oder OR-Klausel kombinieren. Standardmäßig kombiniert Amazon Redshift RLS-Richtlinien mit der AND-Klausel. Superuser, Benutzer oder Rollen, denen diese `sys:secadmin`-Rolle zugewiesen wurde, können diese Klausel verwenden, um den Verbindungstyp der Sicherheitsrichtlinie auf Zeilenebene für eine Relation zu definieren. Weitere Informationen finden Sie unter [Kombinieren mehrerer Richtlinien pro Benutzer](t_rls_combine_policies.md).
+ FOR DATASHARES
Eine Klausel, die festlegt, ob auf eine RLS-geschützte Relation über Datashares zugegriffen werden kann. Standardmäßig kann auf eine RLS-geschützte Relation nicht über ein Datashare zugegriffen werden. Ein ALTER MATERIALIZED VIEW ROW LEVEL SECURITY-Befehl, der mit dieser Klausel ausgeführt wird, wirkt sich nur auf die Zugänglichkeitseigenschaft des Datashares der Relation aus. Die Eigenschaft ROW LEVEL SECURITY wird nicht geändert.
Wenn Sie eine RLS-geschützte Relation über Datashares zugänglich machen, bietet die Relation in der Consumer-seitigen, gemeinsam genutzten Datenbank keine Sicherheit auf Zeilenebene. Die Relation behält ihre RLS-Eigenschaft auf der Produzentenseite.
## Beispiele
Im folgenden Beispiel wird die materialisierte Ansicht `tickets_mv` automatisch aktualisiert.
```
ALTER MATERIALIZED VIEW tickets_mv AUTO REFRESH YES
```
# Beispiele für DISTSTYLE und SORTKEY für ALTER MATERIALIZED VIEW
Die Beispiele in diesem Thema zeigen, wie Sie DISTSTYLE- und SORTKEY-Änderungen mithilfe von ALTER MATERIALIZED VIEW ausführen.
Die folgenden Beispielabfragen zeigen, wie Sie eine DISTSTYLE KEY DISTKEY-Spalte anhand einer Beispiel-Basistabelle ändern:
```
CREATE TABLE base_inventory(
inv_date_sk int4 NOT NULL,
inv_item_sk int4 NOT NULL,
inv_warehouse_sk int4 NOT NULL,
inv_quantity_on_hand int4
);
INSERT INTO base_inventory VALUES(1,1,1,1);
CREATE materialized VIEW inventory diststyle even AS SELECT * FROM base_inventory;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER diststyle KEY distkey inv_warehouse_sk;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER distkey inv_item_sk;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
Ändern einer materialisierten Ansicht in DISTSTYLE ALL:
```
CREATE TABLE base_inventory(
inv_date_sk int4 NOT NULL,
inv_item_sk int4 NOT NULL,
inv_warehouse_sk int4 NOT NULL,
inv_quantity_on_hand int4
);
INSERT INTO base_inventory VALUES(1,1,1,1);
CREATE materialized VIEW inventory diststyle even AS SELECT * FROM base_inventory;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER MATERIALIZED VIEW inventory ALTER diststyle ALL;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
Die folgenden Befehle zeigen SORTKEY-Beispiele für ALTER MATERIALIZED VIEW anhand einer Beispiel-Basistabelle:
```
CREATE TABLE base_inventory (c0 int, c1 int);
INSERT INTO base_inventory VALUES(1,1);
CREATE materialized VIEW inventory interleaved sortkey(c0, c1) AS SELECT * FROM base_inventory;
SELECT "table", sortkey1 FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey(c0, c1);
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey NONE;
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey(c0);
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
# ALTER RLS POLICY
Ändern Sie eine bestehende Sicherheitsrichtlinie auf Zeilenebene in einer Tabelle.
Superuser und Benutzer oder Rollen, denen die `sys:secadmin`-Rolle zugewiesen ist, können eine Richtlinie ändern.
## Syntax
```
ALTER RLS POLICY
{ policy_name | database_name.policy_name }
USING ( using_predicate_exp );
```
## Parameters
*policy\$1name*
Der Name der -Richtlinie.
database\$1name
Der Name der Datenbank, aus der die Richtlinie erstellt wurde. Bei der Datenbank kann es sich um die verbundene Datenbank oder um eine Datenbank handeln, die Verbundberechtigungen von Amazon Redshift unterstützt.
MITHILFE VON (* using\$1predicate\$1exp *)
Gibt einen Filter an, der auf die WHERE-Klausel der Abfrage angewendet wird. Amazon Redshift wendet ein Richtlinienprädikat vor den Benutzerprädikaten auf Abfrageebene an. Beispielsweise schränkt **current\$1user = ‘joe’ and price > 10** ein, dass Joe nur Datensätze mit einem Preis von mehr als 10 USD sehen kann.
Der Ausdruck hat Zugriff auf die Variablen, die in der WITH-Klausel der Anweisung CREATE RLS POLICY deklariert sind, mit der die Richtlinie mit dem Namen policy\$1name erstellt wurde.
Informationen zur Verwendung von ALTER RLS POLICY im Amazon Redshift Federated Permissions Catalog finden Sie unter [Verwaltung der Zugriffskontrolle mit Amazon Redshift Redshift-Verbundberechtigungen](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
## Beispiele
Im folgenden Beispiel wird eine RLS-Richtlinie geändert.
```
-- First create an RLS policy that limits access to rows where catgroup is 'concerts'.
CREATE RLS POLICY policy_concerts
WITH (catgroup VARCHAR(10))
USING (catgroup = 'concerts');
-- Then, alter the RLS policy to only show rows where catgroup is 'piano concerts'.
ALTER RLS POLICY policy_concerts
USING (catgroup = 'piano concerts');
```
# ALTER ROLE
Benennt eine Rolle um oder ändert den Besitzer. Eine Liste der systemdefinierten Amazon-Redshift-Rollen finden Sie unter [Systemdefinierte Amazon-Redshift-Rollen](r_roles-default.md).
## Erforderliche Berechtigungen
Für ALTER ROLE sind folgende Berechtigungen erforderlich:
+ Superuser
+ Benutzer mit der Berechtigung ALTER ROLE
## Syntax
```
ALTER ROLE role [ WITH ]
{ { RENAME TO role } | { OWNER TO user_name } }[, ...]
[ EXTERNALID TO external_id ]
```
## Parameters
*Rolle*
Der Name der zu ändernden Rolle.
RENAME TO
Ein neuer Name für die Rolle.
OWNER TO *benutzer\$1name*
Ein neuer Besitzer für die Rolle.
EXTERNALID TO *external\$1id*
Eine neue externe ID für die Rolle, die einem Identitätsanbieter zugeordnet ist. Weitere Informationen finden Sie unter [Nativer Identitätsanbieter(IdP)-Verbund für Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html).
## Beispiele
Das folgende Beispiel ändert den Namen einer Rolle von `sample_role1` in `sample_role2`.
```
ALTER ROLE sample_role1 RENAME TO sample_role2;
```
Das folgende Beispiel ändert den Besitzer der Rolle.
```
ALTER ROLE sample_role1 WITH OWNER TO user1
```
Die Syntax von ALTER ROLE ähnelt der von ALTER PROCEDURE.
```
ALTER PROCEDURE first_quarter_revenue(bigint, numeric) RENAME TO quarterly_revenue;
```
Das folgende Beispiel ändert den Besitzer einer Prozedur in `etl_user`.
```
ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
Im folgenden Beispiel wird eine Rolle `sample_role1` mit einer neuen externen ID aktualisiert, die einem Identitätsanbieter zugeordnet ist.
```
ALTER ROLE sample_role1 EXTERNALID TO "XYZ456";
```
# ALTER PROCEDURE
Benennt eine Prozedur um oder ändert den Besitzer. Erforderlich sind sowohl der Name der Prozedur als auch die Datentypen bzw. Signatur. Eine Prozedur kann nur vom Besitzer oder von einem Superuser umbenannt werden. Nur ein Superuser kann den Besitzer einer Prozedur ändern.
## Syntax
```
ALTER PROCEDURE sp_name [ ( [ [ argname ] [ argmode ] argtype [, ...] ] ) ]
RENAME TO new_name
```
```
ALTER PROCEDURE sp_name [ ( [ [ argname ] [ argmode ] argtype [, ...] ] ) ]
OWNER TO { new_owner | CURRENT_USER | SESSION_USER }
```
## Parameters
*sp\$1name*
Der Name der Prozedur, die geändert werden soll. Geben Sie einfach den Namen der Prozedur im aktuellen Suchpfad an oder verwenden Sie das Format `schema_name.sp_procedure_name`, um ein spezifisches Schema zu verwenden.
*[argname] [ argmode] argtype*
Eine Liste von Argumentnamen, Argumentmodi und Datentypen. Nur die Eingabedatentypen sind erforderlich. Diese werden zur Identifizierung der gespeicherten Prozedur verwendet. Alternativ können Sie auch die komplette Signatur angeben, die zum Erstellen der Prozedur verwendet wurde, einschließlich der Eingabe- und Ausgabeparameter mit ihren Modi.
*new\$1name*
Ein neuer Name für die gespeicherte Prozedur.
*new\$1owner* \$1 CURRENT\$1USER \$1 SESSION\$1USER
Ein neuer Besitzer für die gespeicherte Prozedur.
## Beispiele
Das folgende Beispiel ändert den Namen einer Prozedur von `first_quarter_revenue` in `quarterly_revenue`.
```
ALTER PROCEDURE first_quarter_revenue(volume INOUT bigint, at_price IN numeric,
result OUT int) RENAME TO quarterly_revenue;
```
Dieses Beispiel entspricht Folgendem.
```
ALTER PROCEDURE first_quarter_revenue(bigint, numeric) RENAME TO quarterly_revenue;
```
Das folgende Beispiel ändert den Besitzer einer Prozedur in `etl_user`.
```
ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
# ALTER SCHEMA
Ändert die Definition eines vorhandenen Schemas. Mit diesem Befehl können Sie ein Schema umbenennen oder den Besitzer eines Schemas ändern. Sie können beispielsweise ein vorhandenes Schema umbenennen, um eine Sicherungskopie dieses Schemas zu behalten, wenn Sie planen, eine neue Version dieses Schemas zu erstellen. Weitere Informationen zu Schemata finden Sie unter [CREATE SCHEMA](r_CREATE_SCHEMA.md).
Um die konfigurierten Schemakontingente anzuzeigen, siehe [SVV\$1SCHEMA\$1QUOTA\$1STATE](r_SVV_SCHEMA_QUOTA_STATE.md).
Um die Datensätze anzuzeigen, bei denen die Schemakontingente überschritten wurden, siehe [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md).
## Erforderliche Berechtigungen
Für ALTER SCHEMA sind folgende Berechtigungen erforderlich:
+ Superuser
+ Benutzer mit der Berechtigung ALTER SCHEMA
+ Schemabesitzer
Beachten Sie beim Ändern eines Schemanamens, dass Objekte, die den alten Namen verwenden, wie z. B. gespeicherte Prozeduren oder materialisierte Ansichten, aktualisiert werden müssen, um den neuen Namen zu verwenden.
## Syntax
```
ALTER SCHEMA schema_name
{
RENAME TO new_name |
OWNER TO new_owner |
QUOTA { quota [MB | GB | TB] | UNLIMITED }
}
```
## Parameters
*schema\$1name*
Der Name des Datenbankschemas, das geändert werden soll.
RENAME TO
Eine Klausel, die das Schema umbenennt.
*new\$1name*
Der neue Name des Schemas. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
OWNER TO
Eine Klausel, die den Besitzer des Schemas ändert.
*new\$1owner*
Der neue Besitzer des Schemas.
QUOTA
Die maximale Menge an Speicherplatz, die das angegebene Schema verwenden kann. Dieser Platz ist die Gesamtgröße aller Tabellen unter dem angegebenen Schema. Amazon Redshift konvertiert den ausgewählten Wert in Megabyte. Gigabyte ist die Standardmaßeinheit, wenn Sie keinen Wert angeben.
Weitere Informationen zur Konfiguration von Schemakontingenten finden Sie unter [CREATE SCHEMA](r_CREATE_SCHEMA.md).
## Beispiele
Im folgenden Beispiel wird das Schema SALES in US\$1SALES umbenannt.
```
alter schema sales
rename to us_sales;
```
Im folgenden Beispiel erhält der Benutzer DWUSER den Besitz des Schemas US\$1SALES.
```
alter schema us_sales
owner to dwuser;
```
Im folgenden Beispiel wird das Kontingent zu 300 GB geändert und das Kontingent entfernt.
```
alter schema us_sales QUOTA 300 GB;
alter schema us_sales QUOTA UNLIMITED;
```
# ALTER SYSTEM
Ändert eine Konfigurationsoption auf Systemebene für den Amazon-Redshift-Cluster oder die Redshift-Serverless-Arbeitsgruppe.
## Erforderliche Berechtigungen
Einer der folgenden Benutzertypen kann den Befehl ALTER SYSTEM ausführen:
+ Superuser
+ Admin-Benutzer
## Syntax
```
ALTER SYSTEM SET system-level-configuration = {true| t | on | false | f | off}
```
## Parameters
*system-level-configuration*
Eine Konfiguration auf Systemebene. Gültiger Wert: `data_catalog_auto_mount` und `metadata_security`.
\$1true\$1 t \$1 on \$1 false \$1 f \$1 off\$1
Ein Wert zum Aktivieren oder Deaktivieren der Konfiguration auf Systemebene. `true`, `t` oder `on` gibt an, die Konfiguration zu aktivieren. `false`, `f` oder `off` gibt an, die Konfiguration zu deaktivieren.
## Nutzungshinweise
Für einen bereitgestellten Cluster werden Änderungen an `data_catalog_auto_mount` beim nächsten Neustart des Clusters wirksam. Weitere Informationen finden Sie unter [Neustart eines Cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#reboot-cluster) im *Amazon-Redshift-Verwaltungshandbuch*.
Bei einer Serverless-Arbeitsgruppe werden die Änderungen an `data_catalog_auto_mount` nicht sofort wirksam.
## Beispiele
Im folgenden Beispiel wird das automatische Mounting von AWS Glue Data Catalog aktiviert.
```
ALTER SYSTEM SET data_catalog_auto_mount = true;
```
Im folgenden Beispiel wird die Metadatensicherheit aktiviert.
```
ALTER SYSTEM SET metadata_security = true;
```
### Festlegen eines standardmäßigen Identitäts-Namespace einrichten
Dieses Beispiel bezieht sich speziell auf die Arbeit mit einem Identitätsanbieter. Sie können Redshift mit IAM Identity Center und einem Identitätsanbieter integrieren, um das Identitätsmanagement für Redshift und andere Dienste zu zentralisieren. AWS
Das folgende Beispiel zeigt, wie der standardmäßige Identitäts-Namespace für das System festgelegt wird. Wenn Sie ihn anschließend ausführen, vereinfacht dies die Ausführung der Anweisungen GRANT und CREATE, da Sie den Namespace nicht als Präfix für jede Identität angeben müssen.
```
ALTER SYSTEM SET default_identity_namespace = 'MYCO';
```
Nach der Ausführung des Befehls können Sie Anweisungen wie die folgenden ausführen:
```
GRANT SELECT ON TABLE mytable TO alice;
GRANT UPDATE ON TABLE mytable TO salesrole;
CREATE USER bob password 'md50c983d1a624280812631c5389e60d48c';
```
Die Festlegung eines standardmäßigen Identitäts-Namespace bedeutet, dass er nicht für jede Identität als Präfix festgelegt werden muss. In diesem Beispiel wird `alice` durch `MYCO:alice` ersetzt. Das erfolgt für jede enthaltene Identität. Weitere Informationen zur Verwendung eines Identitätsanbieters mit Redshift finden Sie unter [Redshift mit IAM Identity Center verbinden, um Benutzern eine Single-Sign-On-Erfahrung zu bieten](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-idp-connect.html).
Weitere Informationen zu Einstellungen, die die Redshift-Konfiguration mit IAM Identity Center betreffen, finden Sie unter [SET](r_SET.md) und [ALTER IDENTITY PROVIDER](r_ALTER_IDENTITY_PROVIDER.md).
# ALTER TABLE
Dieser Befehl ändert die Definition einer Amazon-Redshift-Tabelle oder einer externen Amazon-Redshift-Spectrum-Tabelle. Dieser Befehl aktualisiert die von [CREATE TABLE](r_CREATE_TABLE_NEW.md) oder [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md) festgelegten Werte und Eigenschaften. Sie können ALTER TABLE für eine Ansicht verwenden, um Sicherheit auf Zeilenebene (RLS) zu erzielen.
Sie können ALTER TABLE nicht für eine externe Tabelle innerhalb eines Transaktionsblocks (BEGIN ... END) ausführen. Weitere Informationen zu Transaktionen finden Sie unter [Isolierungsstufen in Amazon Redshift](c_serial_isolation.md).
ALTER TABLE sperrt die Tabelle für Lese- und Schreibvorgänge, bis die die Operation ALTER TABLE umschließende Transaktion abgeschlossen ist, es sei denn, in der Dokumentation ist ausdrücklich angegeben, dass Sie Daten abfragen oder andere Operationen an der Tabelle ausführen können, während sie geändert wird.
## Erforderliche Berechtigungen
Der Benutzer, der eine Tabelle ändert, benötigt die entsprechenden Berechtigungen, damit der Befehl erfolgreich ausgeführt werden kann. Je nach verwendetem Befehl ALTER TABLE ist eine der folgenden Berechtigungen erforderlich.
+ Superuser
+ Benutzer mit der Berechtigung ALTER TABLE
+ Tabellenbesitzer mit dem USAGE-Recht für das Schema
## Syntax
```
ALTER TABLE table_name
{
ADD table_constraint
| DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
| OWNER TO new_owner
| RENAME TO new_name
| RENAME COLUMN column_name TO new_name
| ALTER COLUMN column_name TYPE updated_varchar_data_type_size
| ALTER COLUMN column_name ENCODE new_encode_type
| ALTER COLUMN column_name ENCODE encode_type,
| ALTER COLUMN column_name ENCODE encode_type, .....;
| ALTER DISTKEY column_name
| ALTER DISTSTYLE ALL
| ALTER DISTSTYLE EVEN
| ALTER DISTSTYLE KEY DISTKEY column_name
| ALTER DISTSTYLE AUTO
| ALTER [COMPOUND] SORTKEY ( column_name [,...] )
| ALTER SORTKEY AUTO
| ALTER SORTKEY NONE
| ALTER ENCODE AUTO
| ADD [ COLUMN ] column_name column_type
[ DEFAULT default_expr ]
[ ENCODE encoding ]
[ NOT NULL | NULL ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ] |
| DROP [ COLUMN ] column_name [ RESTRICT | CASCADE ]
| ROW LEVEL SECURITY { ON | OFF } [ CONJUNCTION TYPE { AND | OR } ] [ FOR DATASHARES ]
| MASKING { ON | OFF } FOR DATASHARES }
where table_constraint is:
[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [, ... ] )
| PRIMARY KEY ( column_name [, ... ] )
| FOREIGN KEY (column_name [, ... ] )
REFERENCES reftable [ ( refcolumn ) ]}
The following options apply only to external tables:
SET LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
| SET FILE FORMAT format |
| SET TABLE PROPERTIES ('property_name'='property_value')
| PARTITION ( partition_column=partition_value [, ...] )
SET LOCATION { 's3://bucket/folder' |'s3://bucket/manifest_file' }
| ADD [IF NOT EXISTS]
PARTITION ( partition_column=partition_value [, ...] ) LOCATION { 's3://bucket/folder' |'s3://bucket/manifest_file' }
[, ... ]
| DROP PARTITION ( partition_column=partition_value [, ...] )
```
Um die Zeit für die Ausführung des Befehls ALTER TABLE zu verkürzen, können Sie einige Klauseln des Befehls ALTER TABLE kombinieren.
Amazon Redshift unterstützt die folgenden Kombinationen der ALTER TABLE-Klauseln:
```
ALTER TABLE tablename ALTER SORTKEY (column_list), ALTER DISTKEY column_Id;
ALTER TABLE tablename ALTER DISTKEY column_Id, ALTER SORTKEY (column_list);
ALTER TABLE tablename ALTER SORTKEY (column_list), ALTER DISTSTYLE ALL;
ALTER TABLE tablename ALTER DISTSTYLE ALL, ALTER SORTKEY (column_list);
```
## Parameters
*table\$1name*
Der Name der Tabelle, die geändert werden soll. Geben Sie einfach den Namen der Tabelle an oder verwenden Sie das Format *schema\$1name.table\$1name*, um ein spezifisches Schema zu verwenden. Externe Tabellen müssen durch einen externen Schemanamen qualifiziert werden. Sie können auch einen Anzeigenamen angeben, wenn Sie die Anweisung ALTER TABLE verwenden, um eine Ansicht umzubenennen oder ihren Eigentümer zu ändern. Die maximale Länge des Tabellennamens beträgt 127 Bytes; längere Namen werden bei 127 Bytes abgeschnitten. Sie können UTF-8-Multibyte-Zeichen bis zu einer Länge von vier Bytes verwenden. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
ADD *table\$1constraint*
Eine Klausel, die der Tabelle die angegebene Einschränkung hinzufügt. Beschreibungen der gültigen Werte für *table\$1constraint* finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Sie können einer löschbaren Spalte keine Einschränkung „primary-key“ hinzufügen. Wenn die Spalte ursprünglich mit der Einschränkung NOT NULL erstellt wurde, können Sie die Einschränkung „primary-key“ hinzufügen.
DROP CONSTRAINT *constraint\$1name*
Eine Klausel, die die angegebene Einschränkung aus der Tabelle entfernt. Um eine Einschränkung zu entfernen, geben Sie den Namen der Einschränkung an, nicht den Typ der Einschränkung. Um Namen von Tabelleneinschränkungen anzuzeigen, führen Sie die folgende Abfrage aus.
```
select constraint_name, constraint_type
from information_schema.table_constraints;
```
RESTRICT
Eine Klausel, die nur die angegebene Einschränkung entfernt. RESTRICT ist eine Option für DROP CONSTRAINT. RESTRICT kann nicht mit CASCADE verwendet werden.
CASCADE
Eine Klausel, die die angegebene Einschränkung und alles, was von dieser Einschränkung abhängig ist, entfernt. CASCADE ist eine Option für DROP CONSTRAINT. CASCADE kann nicht mit RESTRICT verwendet werden.
OWNER TO *new\$1owner*
Eine Klausel, die den Besitzer der Tabelle (oder Ansicht) in den Wert *new\$1owner* ändert.
RENAME TO *new\$1name*
Eine Klausel, die die Tabelle (oder Ansicht) in den Wert ändert, der in *new\$1name* angegeben ist. Die maximale Länge des Tabellennamens beträgt 127 Bytes; längere Namen werden bei 127 Bytes abgeschnitten.
Sie können den Namen einer permanenten Tabelle nicht in einen Namen umbenennen, der mit „\$1“ beginnt. Ein Tabellenname, der mit „\$1“ beginnt, zeigt eine temporäre Tabelle an.
Sie können eine externe Tabelle nicht umbenennen.
ALTER COLUMN *column\$1name* TYPE *updated\$1varchar\$1data\$1type\$1size*
Eine Klausel, die die Größe einer Spalte ändert, die als VARCHAR-Datentyp definiert ist. Diese Klausel unterstützt nur eine Größenänderung für einen VARCHAR-Datentyp. Erwägen Sie die folgenden Einschränkungen:
+ Sie können eine Spalte mit den Komprimierungskodierungen BYTEDICT, RUNLENGTH oder K nicht ändern. TEXT255 TEXT32
+ Sie können die Größe nicht auf weniger als die maximale Größe vorhandener Daten reduzieren.
+ Spalten mit Standardwerten können nicht geändert werden.
+ Spalten mit UNIQUE, PRIMARY KEY oder FOREIGN KEY können nicht geändert werden.
+ Spalten innerhalb eines Transaktionsblocks (BEGIN ... END). Weitere Informationen Transaktionen finden Sie unter [Isolierungsstufen in Amazon Redshift](c_serial_isolation.md).
ALTER COLUMN *column\$1name* ENCODE *new\$1encode\$1type*
Eine Klausel, die die Komprimierungskodierung einer Spalte ändert. Wenn Sie die Komprimierungskodierung für eine Spalte angeben, wird die Tabelle nicht mehr auf ENCODE AUTO festgelegt. Weitere Informationen zur Komprimierungskodierung finden Sie unter [Spaltenkomprimierung zur Reduzierung der Größe der gespeicherten Daten](t_Compressing_data_on_disk.md).
Wenn Sie die Komprimierungskodierung für eine Spalte ändern, bleibt die Tabelle zur Abfrage verfügbar.
Erwägen Sie die folgenden Einschränkungen:
+ Sie können eine Spalte nicht in dieselbe Kodierung ändern, die derzeit für die Spalte definiert ist.
+ Sie können die Kodierung für eine Spalte in einer Tabelle mit einem überlappenden Sortierschlüssel nicht ändern.
ALTER COLUMN *column\$1name* ENCODE *encode\$1type*, ALTER COLUMN *column\$1name* ENCODE *encode\$1type*, .....;
Eine Klausel, die die Komprimierungskodierung mehrerer Spalten in einem einzigen Befehl ändert. Weitere Informationen zur Komprimierungskodierung finden Sie unter [Spaltenkomprimierung zur Reduzierung der Größe der gespeicherten Daten](t_Compressing_data_on_disk.md).
Wenn Sie die Komprimierungskodierung für eine Spalte ändern, bleibt die Tabelle zur Abfrage verfügbar.
Erwägen Sie die folgenden Einschränkungen:
+ Sie können eine Spalte nicht mehrmals mit einem einzigen Befehl in denselben oder einen anderen Kodierungstyp ändern.
+ Sie können eine Spalte nicht in dieselbe Kodierung ändern, die derzeit für die Spalte definiert ist.
+ Sie können die Kodierung für eine Spalte in einer Tabelle mit einem überlappenden Sortierschlüssel nicht ändern.
ALTER DISTSTYLE ALL
Eine Klausel, die den vorhandenen Verteilungsstil einer Tabelle in ändert `ALL`. Berücksichtigen Sie dabei Folgendes:
+ ALTER DISTSTYLE, ALTER SORTKEY und VACUUM können nicht gleichzeitig für dieselbe Tabelle ausgeführt werden.
+ Wenn VACUUM gerade ausgeführt wird, wird beim Ausführen von ALTER DISTSTYLE ALL ein Fehler zurückgegeben.
+ Wenn ALTER DISTSTYLE ALL ausgeführt wird, startet eine Hintergrundbereinigung nicht für eine Tabelle.
+ Der Befehl ALTER DISTSTYLE ALL wird für Tabellen mit verschachtelten Sortierschlüsseln und temporäre Tabellen nicht unterstützt.
+ Wenn der Verteilungsstil zuvor als AUTO definiert war, dann ist die Tabelle kein Kandidat mehr für die automatische Tabellenoptimierung.
Weitere Informationen zu DISTSTYLE ALL finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTSTYLE EVEN
Eine Klausel, die den vorhandenen Verteilungsstil einer Tabelle in ändert `EVEN`. Berücksichtigen Sie dabei Folgendes:
+ ALTER DISTSYTLE, ALTER SORTKEY und VACUUM können nicht gleichzeitig für dieselbe Tabelle ausgeführt werden.
+ Wenn VACUUM gerade ausgeführt wird, wird beim Ausführen von ALTER DISTSTYLE EVEN ein Fehler zurückgegeben.
+ Wenn ALTER DISTSTYLE EVEN ausgeführt wird, startet eine Hintergrundbereinigung nicht für eine Tabelle.
+ Der Befehl ALTER DISTSTYLE EVEN wird für Tabellen mit verschachtelten Sortierschlüsseln und temporäre Tabellen nicht unterstützt.
+ Wenn der Verteilungsstil zuvor als AUTO definiert war, dann ist die Tabelle kein Kandidat mehr für die automatische Tabellenoptimierung.
Weitere Informationen zu DISTSTYLE EVEN finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTKEY *column\$1name* oder ALTER DISTSTYLE KEY DISTKEY *column\$1name*
Eine Klausel, die die Spalte ändert, die als Verteilungsschlüssel einer Tabelle verwendet wird. Berücksichtigen Sie dabei Folgendes:
+ VACUUM und ALTER DISTKEY können nicht gleichzeitig für dieselbe Tabelle ausgeführt werden.
+ Wenn VACUUM bereits ausgeführt wird, gibt ALTER DISTKEY einen Fehler zurück.
+ Wenn ALTER DISTKEY ausgeführt wird, startet die Hintergrundbereinigung nicht für die Tabelle.
+ Wenn ALTER DISTKEY ausgeführt wird, dann gibt die Vordergrundbereinigung einen Fehler zurück.
+ Sie können nur jeweils einen ALTER DISTKEY-Befehl für eine Tabelle ausführen.
+ Der Befehl ALTER DISTKEY wird für Tabellen mit verschachtelten Sortierschlüsseln nicht unterstützt.
+ Wenn der Verteilungsstil zuvor als AUTO definiert war, dann ist die Tabelle kein Kandidat mehr für die automatische Tabellenoptimierung.
Wenn Sie DISTSTYLE KEY angeben, werden die Daten nach den Werten in der DISTKEY-Spalte verteilt. Weitere Informationen zu DISTSTYLE finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTSTYLE AUTO
Eine Klausel, die den vorhandenen Verteilungsstil einer Tabelle in AUTO ändert.
Wenn Sie einen Verteilungsstil auf AUTO ändern, wird der Verteilungsstil der Tabelle folgendermaßen festgelegt:
+ Eine kleine Tabelle mit DISTSTYLE ALL wird in AUTO(ALL) umgewandelt.
+ Eine kleine Tabelle mit DISTSTYLE EVEN wird in AUTO(ALL) umgewandelt.
+ Eine kleine Tabelle mit DISTSTYLE KEY wird in AUTO(ALL) umgewandelt.
+ Eine große Tabelle mit DISTSTYLE ALL wird in AUTO(EVEN) umgewandelt.
+ Eine große Tabelle mit DISTSTYLE EVEN wird in AUTO(EVEN) umgewandelt.
+ Eine große Tabelle mit DISTSTYLE KEY wird in AUTO(KEY) umgewandelt und der DISTKEY bleibt erhalten. In diesem Fall nimmt Amazon Redshift keine Änderungen an der Tabelle vor.
Wenn Amazon Redshift feststellt, dass ein neuer Verteilungsstil oder Schlüssel die Leistung von Abfragen verbessert, dann kann Amazon Redshift den Verteilungsstil oder Schlüssel Ihrer Tabelle in Zukunft ändern. Beispielsweise könnte Amazon Redshift eine Tabelle mit dem DISTSTYLE-Wert AUTO(KEY) in AUTO(EVEN) konvertieren oder umgekehrt. Weitere Informationen zum Verhalten bei Änderungen von Verteilungsschlüsseln, einschließlich Datenumverteilung und Sperren, finden Sie unter [Empfehlungen für Amazon Redshift Advisor](https://docs.aws.amazon.com/redshift/latest/dg/advisor-recommendations.html#alter-diststyle-distkey-recommendation).
Weitere Informationen zu DISTSTYLE AUTO finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Um den Verteilungsstil einer Tabelle anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1TABLE\$1INFO ab. Weitere Informationen finden Sie unter [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Um die Empfehlungen von Amazon Redshift Advisor für Tabellen anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS ab. Weitere Informationen finden Sie unter [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Um die von Amazon Redshift durchgeführten Aktionen anzuzeigen, fragen Sie die Systemkatalogansicht SVL\$1AUTO\$1WORKER\$1ACTION ab. Weitere Informationen finden Sie unter [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER [COMPOUND] SORTKEY ( *column\$1name* [,...] )
Eine Klausel, die den für eine Tabelle verwendeten Sortierschlüssel ändert oder hinzufügt. ALTER SORTKEY wird für temporäre Tabellen nicht unterstützt.
Wenn Sie einen Sortierschlüssel ändern, kann sich die Kompressionskodierung von Spalten im neuen oder ursprünglichen Sortierschlüssel ändern. Wenn für die Tabelle keine Kodierung explizit definiert ist, weist Amazon Redshift automatisch Komprimierungskodierungen wie folgt zu:
+ Spalten, die als Sortierschlüssel definiert sind, wird die RAW-Kompression zugewiesen.
+ Spalten, die als die Datentypen BOOLEAN, REAL oder DOUBLE PRECISION definiert sind, wird die RAW-Kodierung zugewiesen.
+ Spalten, die als SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIME, TIMETZ, TIMESTAMP oder TIMESTAMPTZ definiert sind, wird Komprimierung zugewiesen. AZ64
+ Spalten, die als CHAR oder VARCHAR definiert sind, wird LZO-Komprimierung zugewiesen.
Berücksichtigen Sie dabei Folgendes:
+ Sie können maximal 400 Spalten für einen Sortierschlüssel pro Tabelle definieren.
+ Sie können einen überlappenden Sortierschlüssel in einen zusammengesetzten Sortierschlüssel oder in keinen Sortierschlüssel ändern. Es ist jedoch nicht möglich, einen zusammengesetzten Sortierschlüssel in einen überlappenden Sortierschlüssel zu ändern.
+ Wenn der Sortierschlüssel zuvor als AUTO definiert war, dann ist die Tabelle kein Kandidat mehr für die automatische Tabellenoptimierung.
+ Amazon Redshift empfiehlt die Verwendung von RAW-Kodierung (keine Komprimierung) für Spalten, die als Sortierschlüssel definiert sind. Wenn Sie eine Spalte ändern, um sie als Sortierschlüssel zu wählen, wird die Komprimierung der Spalte auf RAW-Komprimierung (keine Komprimierung) geändert. Dadurch kann sich der Speicherbedarf der Tabelle erhöhen. Wie stark die Tabellengröße zunimmt, hängt von der jeweiligen Tabellendefinition und dem Tabelleninhalt ab. Weitere Informationen zur Komprimierung finden Sie unter . [Kompressionskodierungen](c_Compression_encodings.md)
Beim Laden von Daten in eine Tabelle werden die Daten in der Reihenfolge des Sortierschlüssels geladen. Wenn Sie den Sortierschlüssel ändern, ordnet Amazon Redshift die Daten neu an. Weitere Informationen zu SORTKEY finden Sie im Abschnitt [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER SORTKEY AUTO
Eine Klausel, die den Sortierschlüssel der Zieltabelle auf AUTO ändert oder hinzufügt. ALTER SORTKEY AUTO wird für temporäre Tabellen nicht unterstützt.
Wenn Sie einen Sortierschlüssel auf AUTO ändern, behält Amazon Redshift den bestehenden Sortierschlüssel der Tabelle bei.
Wenn Amazon Redshift feststellt, dass ein neuer Sortierschlüssel die Leistung von Abfragen verbessert, dann kann Amazon Redshift den Sortierschlüssel Ihrer Tabelle in Zukunft ändern.
Weitere Informationen zu SORTKEY AUTO finden Sie im Abschnitt [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Um den Sortierschlüssel einer Tabelle anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1TABLE\$1INFO ab. Weitere Informationen finden Sie unter [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Um die Empfehlungen von Amazon Redshift Advisor für Tabellen anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS ab. Weitere Informationen finden Sie unter [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Um die von Amazon Redshift durchgeführten Aktionen anzuzeigen, fragen Sie die Systemkatalogansicht SVL\$1AUTO\$1WORKER\$1ACTION ab. Weitere Informationen finden Sie unter [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER SORTKEY NONE
Eine Klausel, die den Sortierschlüssel der Zieltabelle entfernt.
Wenn der Sortierschlüssel zuvor als AUTO definiert war, dann ist die Tabelle kein Kandidat mehr für die automatische Tabellenoptimierung.
ALTER ENCODE AUTO
Eine Klausel, die den Kodierungstyp der Spalten in der Zieltabelle auf AUTO ändert. Wenn Sie die Kodierung auf AUTO ändern, behält Amazon Redshift den bestehenden Kodierungstyp der Spalten in der Tabelle bei. Wenn Amazon Redshift dann feststellt, dass ein neuer Kodierungstyp die Abfrageleistung verbessern kann, kann Amazon Redshift den Kodierungstyp der Tabellenspalten ändern.
Wenn Sie eine oder mehrere Spalten ändern, um eine Kodierung anzugeben, passt Amazon Redshift die Kodierung nicht mehr automatisch für alle Spalten in der Tabelle an. Die Spalten behalten die aktuellen Kodierungseinstellungen bei.
Die folgenden Aktionen haben keinen Einfluss auf die Einstellung ENCODE AUTO für die Tabelle:
+ Umbenennen der Tabelle.
+ Ändern der DISTSTYLE- oder SORTKEY-Einstellung für die Tabelle.
+ Hinzufügen oder Löschen einer Spalte mit einer ENCODE-Einstellung.
+ Verwendung der Option COMPUPDATE des Befehls COPY. Weitere Informationen finden Sie unter [Datenladeoperationen](copy-parameters-data-load.md).
Um die Kodierung einer Tabelle anzuzeigen, fragen Sie die Systemkatalogansicht SVV\$1TABLE\$1INFO ab. Weitere Informationen finden Sie unter [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md).
RENAME COLUMN *column\$1name* TO *new\$1name*
Eine Klausel, die eine Spalte in den Wert ändert, der in *new\$1name* angegeben ist. Die maximale Länge des Spaltennamens beträgt 127 Bytes; längere Namen werden bei 127 Bytes abgeschnitten. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
ADD [ COLUMN ] *column\$1name*
Eine Klausel, die der Tabelle eine Spalte mit dem angegebenen Namen hinzufügt. Sie können in jeder Anweisung ALTER TABLE nur eine Spalte hinzufügen.
Sie können keine Spalte hinzufügen, die der Verteilungsschlüssel (DISTKEY) oder ein Sortierschlüssel (SORTKEY) der Tabelle ist.
Sie können den Befehl ALTER TABLE ADD COLUMN nicht verwenden, um die folgenden Tabellen- und Spaltenattribute zu ändern:
+ UNIQUE
+ PRIMARY KEY
+ REFERENCES (Fremdschlüssel)
+ IDENTITY oder GENERATED BY DEFAULT AS IDENTITY
Die maximale Länge des Spaltennamens beträgt 127 Bytes; längere Namen werden bei 127 Bytes abgeschnitten. Die maximale Anzahl der Spalten, die Sie in einer einzelnen Tabelle definieren können, ist 1.600.
Beim Hinzufügen von Spalten zu einer externen Tabelle gelten die folgenden Beschränkungen:
+ Sie können keine Spalten zu einer externen Tabelle mit den Spaltenbeschränkungen DEFAULT, ENCODE; NOT NULL oder NULL hinzufügen.
+ Sie können keine Spalten zu einer externen Tabelle hinzufügen, die mit dem AVRO-Dateiformat definiert ist.
+ Falls Pseudospalten aktiviert sind, können Sie höchstens 1.598 Spalten in einer einzelnen externen Tabelle definieren. Falls Pseudospalten nicht aktiviert sind, können Sie höchstens 1.600 Spalten in einer einzelnen Tabelle definieren.
Weitere Informationen finden Sie unter [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
*column\$1type*
Der Datentyp der Spalte, die hinzugefügt wird. Im Fall der Spalten CHAR und VARCHAR können Sie das Schlüsselwort MAX verwenden, statt eine maximale Länge zu deklarieren. MAX legt die maximale Länge auf 4.096 Bytes für CHAR oder 65.535 Bytes für VARCHAR fest. Die maximale Größe eines GEOMETRY-Objekts beträgt 1.048.447 Byte..
Informationen zu den Datentypen, die Amazon Redshift unterstützt, finden Sie unter [Datentypen](c_Supported_data_types.md).
DEFAULT *default\$1expr*
Eine Klausel, die der Spalte einen Standarddatenwert zuweist. Der Datentyp von *default\$1expr* muss dem Datentyp der Spalte entsprechen. Der Wert DEFAULT muss ein variablenloser Ausdruck sein. Unterabfragen, Querreferenzen auf andere Spalten in der aktuellen Tabelle und benutzerdefinierte Funktionen sind nicht zulässig.
Der *default\$1expr* wird in jeder INSERT-Operation verwendet, die keinen Wert für die Spalte angibt. Wenn kein Standardwert angegeben ist, ist der Standardwert für die Spalte null.
Wenn eine COPY-Operation auf ein Null-Feld in einer Spalte mit dem Wert DEFAULT und der Einschränkung NOT NULL trifft, fügt der Befehl COPY den Wert von *default\$1expr* ein.
DEFAULT wird für externe Tabellen nicht unterstützt.
ENCODE *encoding*
Die Kompressionskodierung für eine Spalte. Standardmäßig verwaltet Amazon Redshift die Komprimierungskodierung für alle Spalten in einer Tabelle automatisch, wenn Sie keine Komprimierungskodierung für eine Spalte in der Tabelle angeben oder wenn Sie die Option ENCODE AUTO für die Tabelle verwenden.
Wenn Sie die Komprimierungskodierung für eine beliebige Spalte in der Tabelle angeben oder nicht die Option ENCODE AUTO für die Tabelle angeben, weist Amazon Redshift den Spalten, für die Sie keine Komprimierungskodierung angeben, automatisch die Komprimierungskodierung wie folgt zu:
+ Allen Spalten in temporären Tabellen wird standardmäßig die RAW-Kompression zugewiesen.
+ Spalten, die als Sortierschlüssel definiert sind, wird die RAW-Kompression zugewiesen.
+ Spalten, die als Datentyp BOOLEAN, REAL, DOUBLE PRECISION, GEOMETRY oder GEOGRAPHY definiert sind, wird die RAW-Kompression zugewiesen.
+ Spalten, die als SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIME, TIMETZ, TIMESTAMP oder TIMESTAMPTZ definiert sind, wird Komprimierung zugewiesen. AZ64
+ Spalten, die als CHAR, VARCHAR oder VARBYTE definiert sind, wird LZO-Komprimierung zugewiesen.
Wenn Sie nicht möchten, dass eine Spalte komprimiert wird, geben Sie die RAW-Kodierung explizit an.
Die folgenden [compression encodings](c_Compression_encodings.md#compression-encoding-list) werden unterstützt:
+ AZ64
+ BYTEDICT
+ DELTA
+ DELTA32K
+ LZO
+ MOSTLY8
+ MOSTLY16
+ MOSTLY32
+ RAW (keine Kompression)
+ RUNLENGTH
+ TEXT255
+ TEXT32K
+ ZSTD
ENCODE wird für externe Tabellen nicht unterstützt.
NOT NULL \$1 NULL
NOT NULL gibt an, dass die Spalte keine Null-Werte enthalten darf. Der Standardwert NULL gibt an, dass die Spalte Null-Werte akzeptiert.
NOT NULL und NULL werden für externe Tabellen nicht unterstützt.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Eine Klausel, die angibt, ob beim Suchen oder Vergleichen von Zeichenfolgen in der Spalte zwischen Groß- und Kleinschreibung unterschieden wird oder nicht. Der Standardwert entspricht der aktuellen Konfiguration für die Beachtung der Groß-/Kleinschreibung in der Datenbank.
Verwenden Sie den folgenden Befehl, um die Sortierinformationen der Datenbank zu ermitteln:
```
SELECT db_collation();
db_collation
----------------
case_sensitive
(1 row)
```
CASE\$1SENSITIVE und CS sind austauschbar und liefern dieselben Ergebnisse. Ebenso sind CASE\$1INSENSITIVE und CI austauschbar und führen zu denselben Ergebnissen.
DROP [ COLUMN ] *column\$1name*
Der Name der Spalte, die aus der Tabelle gelöscht werden soll.
Die letzte Tabellenspalte kann nicht gelöscht werden. Eine Tabelle muss mindestens eine Spalte enthalten.
Sie können keine Spalte entfernen, die der Verteilungsschlüssel (DISTKEY) oder ein Sortierschlüssel (SORTKEY) der Tabelle ist. Das Standardverhalten für DROP COLUMN ist RESTRICT, wenn die Spalte abhängige Objekte enthält, wie eine Ansicht, einen Primärschlüssel, einen Fremdschlüssel oder die Einschränkung UNIQUE.
Beim Hineinziehen aus einer externen Tabelle gelten die folgenden Beschränkungen:
+ Spalten, die als Partition verwendet werden, können nicht aus einer externen Tabelle entfernt werden.
+ Sie können keine Spalten aus einer externen Tabelle entfernen, die mit dem AVRO-Dateiformat definiert ist.
+ RESTRICT und CASCADE werden für externe Tabellen ignoriert.
+ Sie können die Spalten der Richtlinientabelle, auf die innerhalb der Richtliniendefinition verwiesen wird, nicht löschen, es sei denn, Sie löschen oder trennen die Richtlinie. Dies gilt auch, wenn die Option CASCADE angegeben ist. Sie können andere Spalten in der Richtlinientabelle löschen.
Weitere Informationen finden Sie unter [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
RESTRICT
Wenn RESTRICT mit DROP COLUMN verwendet wird, bedeutet das, dass die Spalte, die entfernt werden soll, in den folgenden Fällen nicht entfernt wird:
+ Wenn eine definierte Ansicht die Spalte referenziert, die entfernt werden soll
+ Wenn ein Fremdschlüssel die Spalte referenziert
+ Wenn die Spalte Teil eines mehrteiligen Schlüssels ist
RESTRICT kann nicht mit CASCADE verwendet werden.
RESTRICT und CASCADE werden für externe Tabellen ignoriert.
CASCADE
Bei Verwendung mit DROP COLUMN wird die angegebene Spalte und alles, was von dieser Spalte abhängig ist, entfernt. CASCADE kann nicht mit RESTRICT verwendet werden.
RESTRICT und CASCADE werden für externe Tabellen ignoriert.
Die folgenden Optionen gelten nur für externe Tabellen.
SET LOCATION \$1 's3://*bucket/folder*/' \$1 's3://*bucket/manifest\$1file*' \$1
Der Pfad zum Amazon S3-Ordner enthält die Datendateien oder eine Manifestdatei, die eine Liste der Amazon S3-Objektpfade enthält. Die Buckets müssen sich in derselben AWS -Region wie der Amazon-Redshift-Cluster befinden. Eine Liste der unterstützten Regionen finden Sie unter. AWS [Einschränkungen für Amazon Redshift Spectrum](c-spectrum-considerations.md) Weitere Informationen zur Verwendung einer Manifestdatei finden Sie unter LOCATION in der CREATE EXTERNAL TABLE-Referenz [Parameters](r_CREATE_EXTERNAL_TABLE.md#r_CREATE_EXTERNAL_TABLE-parameters).
SET FILE FORMAT *format*
Das Dateiformat für externe Datendateien.
Gültige Formate sind folgende:
+ AVRO
+ PARQUET
+ RCFILE
+ SEQUENCEFILE
+ TEXTFILE
SET TABLE PROPERTIES ( '*property\$1name*'='*property\$1value*')
Eine Klausel, die die Tabellendefinition für Tabelleneigenschaften für eine externe Tabelle festlegt.
Bei Tabelleneigenschaften muss die Groß-/Kleinschreibung beachtet werden.
'numRows'='*row\$1count*'
Eine Eigenschaft, die den Wert numRows für die Tabellendefinition festlegt. Um die Statistiken einer externen Tabelle explizit zu aktualisieren, legen Sie mit der Eigenschaft numRows die Größe der Tabelle fest. 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. Dieser Plan basiert auf der Annahme, dass externe Tabellen die größeren Tabellen und lokale Tabellen die kleineren Tabellen sind.
'skip.header.line.count'='*line\$1count*'
Eine Eigenschaft, die die Anzahl der Reihen festgelegt, die am Anfang jeder Quelldatei übersprungen wird.
PARTITION ( *partition\$1column*=*partition\$1value* [, ...] SET LOCATION \$1 's3://*bucket*/*folder*' \$1 's3://*bucket*/*manifest\$1file*' \$1
Eine Klausel, die einen neuen Speicherort für eine oder mehrere Partitionsspalten festlegt.
ADD [ IF NOT EXISTS ] PARTITION ( *partition\$1column*=*partition\$1value* [, ...] ) LOCATION \$1 's3://*bucket*/*folder*' \$1 's3://*bucket*/*manifest\$1file*' \$1 [, ... ]
Eine Klausel, die eine oder mehrere Partitionen hinzufügt. Sie können mehrere PARTITION-Klauseln mit einer einzelnen ALTER TABLE … ADD-Anweisung angeben.
Wenn Sie den AWS Glue Katalog verwenden, können Sie mit einer einzigen ALTER TABLE-Anweisung bis zu 100 Partitionen hinzufügen.
Die IF NOT EXISTS-Klausel gibt an, dass der Befehl keine Änderungen ausführen soll, wenn die angegebene Partition bereits vorhanden ist. Darüber hinaus gibt sie an, dass der Befehl eine Meldung zurückgeben sollte, dass die Partition vorhanden ist, anstatt mit einem Fehler beendet zu werden. Diese Klausel ist beim Scripting nützlich, damit das Skript nicht fehlschlägt, wenn ALTER TABLE versucht, eine Partition hinzuzufügen, die bereits vorhanden ist.
DROP PARTITION (*partition\$1column*=*partition\$1value* [, ...] )
Eine Klausel, die die angegebene Partition entfernt. Durch die Entfernung einer Partition werden nur die Metadaten der externen Tabelle geändert. Die Daten auf Amazon S3 sind nicht betroffen.
ROW LEVEL SECURITY \$1 ON \$1 OFF \$1 [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ] [ FOR DATASHARES ]
Eine Klausel, die die Sicherheit auf Zeilenebene für eine Relation aktiviert oder deaktiviert.
Wenn die Sicherheit auf Zeilenebene für eine Relation aktiviert ist, können Sie nur die Zeilen lesen, für die Ihnen die Richtlinie auf Zeilenebene Zugriff gewährt. Wenn es keine Richtlinie gibt, die Ihnen Zugriff auf die Relation gewährt, können Sie keine Zeilen aus der Relation sehen. Nur Superuser und Benutzer oder Rollen, denen die `sys:secadmin`-Rolle zugewiesen ist, können die Klausel ROW LEVEL SECURITY festlegen. Weitere Informationen finden Sie unter [Sicherheit auf Zeilenebene](t_rls.md). Diese Anweisung wird in der verbundenen Datenbank oder in einer Datenbank mit Amazon Redshift-Verbundberechtigungen unterstützt. Die FOR DATASHARES-Klausel wird in einer Datenbank mit Amazon Redshift Redshift-Verbundberechtigungen nicht unterstützt.
+ [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ]
Eine Klausel, mit der Sie den Verbindungstyp einer Sicherheitsrichtlinie auf Zeilenebene für eine Relation auswählen können. Wenn einer Relation mehrere Sicherheitsrichtlinien auf Zeilenebene zugeordnet sind, können Sie die Richtlinien mit der AND- oder OR-Klausel kombinieren. Standardmäßig kombiniert Amazon Redshift RLS-Richtlinien mit der AND-Klausel. Superuser, Benutzer oder Rollen, denen diese `sys:secadmin`-Rolle zugewiesen wurde, können diese Klausel verwenden, um den Verbindungstyp der Sicherheitsrichtlinie auf Zeilenebene für eine Relation zu definieren. Weitere Informationen finden Sie unter [Kombinieren mehrerer Richtlinien pro Benutzer](t_rls_combine_policies.md).
+ FOR DATASHARES
Eine Klausel, die festlegt, ob auf eine RLS-geschützte Relation über Datashares zugegriffen werden kann. Standardmäßig kann auf eine RLS-geschützte Relation nicht über ein Datashare zugegriffen werden. Ein ALTER TABLE ROW LEVEL SECURITY-Befehl, der mit dieser Klausel ausgeführt wird, wirkt sich nur auf die Zugänglichkeitseigenschaft des Datashares aus. Die Eigenschaft ROW LEVEL SECURITY wird nicht geändert.
Wenn Sie eine RLS-geschützte Relation über Datashares zugänglich machen, bietet die Relation in der Consumer-seitigen, gemeinsam genutzten Datenbank keine Sicherheit auf Zeilenebene. Die Relation behält ihre RLS-Eigenschaft auf der Produzentenseite.
MASKING \$1 ON \$1 OFF \$1 FOR DATASHARES
Eine Klausel, die festlegt, ob der Zugriff auf eine DDM-geschützte Beziehung über Datashares möglich ist oder nicht. Standardmäßig kann auf eine DDM-geschützte Beziehung nicht über ein Datashare zugegriffen werden. Wenn Sie eine DDM-geschützte Beziehung über Datashares zugänglich machen, bietet die Beziehung in der Consumer-seitigen, Datashare-Datenbank keinen Maskierungsschutz. Die Beziehung behält ihre Maskierungseigenschaft auf der Produzentenseite bei. Nur Superuser und Benutzer oder Rollen, denen die Rolle `sys:secadmin` zugewiesen ist, können die Klausel MASKING FOR DATASHARES festlegen. Weitere Informationen finden Sie unter [Dynamische Datenmaskierung](t_ddm.md).
## Beispiele
In den folgenden Abschnitten finden Sie Beispiele für die Verwendung des Befehls ALTER TABLE.
+ [Beispiele für ALTER TABLE](r_ALTER_TABLE_examples_basic.md)
+ [Beispiele für ALTER EXTERNAL TABLE](r_ALTER_TABLE_external-table.md)
+ [Beispiele für ALTER TABLE ADD und DROP COLUMN](r_ALTER_TABLE_COL_ex-add-drop.md)
# Beispiele für ALTER TABLE
Das folgende Beispiele zeigt die grundsätzliche Nutzung des Befehls ALTER TABLE.
## Umbenennen einer Tabelle oder Ansicht
Mit dem folgenden Befehl wird die Tabelle USERS in USERS\$1BKUP umbenannt:
```
alter table users
rename to users_bkup;
```
Sie können diese Art von Befehl auch verwenden, um eine Ansicht umzubenennen.
## Ändern des Besitzers einer Tabelle oder Ansicht
Mit dem folgenden Befehl wird der Besitzer der Tabelle VENUE in den Benutzer DWUSER geändert:
```
alter table venue
owner to dwuser;
```
Die folgenden Befehle erstellen eine Ansicht und ändern anschließend deren Besitzer:
```
create view vdate as select * from date;
alter table vdate owner to vuser;
```
## Umbenennen einer Spalte
Mit dem folgenden Befehl wird die Spalte VENUESEATS in der Tabelle VENUE in VENUESIZE geändert:
```
alter table venue
rename column venueseats to venuesize;
```
## Entfernen einer Tabelleneinschränkung
Um eine Tabelleneinschränkung zu entfernen, wie beispielsweise einen Primärschlüssel, einen Fremdschlüssel oder eine spezifische Einschränkung, suchen Sie zunächst den internen Namen der Einschränkung. Geben Sie anschließend den Namen der Einschränkung im Befehl ALTER TABLE ein. Im folgenden Beispiel werden die Einschränkungen für die Tabelle CATEGORY gesucht und anschließend der Primärschlüssel mit dem Namen entfernt `category_pkey`.
```
select constraint_name, constraint_type
from information_schema.table_constraints
where constraint_schema ='public'
and table_name = 'category';
constraint_name | constraint_type
----------------+----------------
category_pkey | PRIMARY KEY
alter table category
drop constraint category_pkey;
```
## Ändern einer VARCHAR-Spalte
Um Speicherplatz zu sparen, können Sie eine Tabelle zunächst mit VARCHAR-Spalten mit der Mindestgröße definieren, die für Ihre aktuellen Datenanforderungen erforderlich ist. Später können Sie längere Zeichenfolgen unterstützen, indem Sie die Spaltengröße in der Tabelle ändern.
Im folgenden Beispiel wird die Größe der EVENTNAME-Spalte auf VARCHAR(300) erhöht.
```
alter table event alter column eventname type varchar(300);
```
## Ändern einer VARBYTE-Spalte
Um Speicherplatz zu sparen, können Sie eine Tabelle zunächst mit VARBYTE-Spalten mit der Mindestgröße definieren, die für Ihre aktuellen Datenanforderungen erforderlich ist. Später können Sie längere Zeichenfolgen unterstützen, indem Sie die Spaltengröße in der Tabelle ändern.
Im folgenden Beispiel wird die Größe der Spalte EVENTNAME auf VARBYTE(300) erhöht.
```
alter table event alter column eventname type varbyte(300);
```
## Ändern der Komprimierungskodierung für eine Spalte
Sie können die Komprimierungskodierung einer Spalte ändern. Nachstehend finden Sie eine Reihe von Beispielen, die diesen Ansatz veranschaulichen. Die Tabellendefinition für diese Beispielen lautet wie folgt.
```
create table t1(c0 int encode lzo, c1 bigint encode zstd, c2 varchar(16) encode lzo, c3 varchar(32) encode zstd);
```
Die folgende Anweisung ändert die Komprimierungskodierung für Spalte c0 von der LZO-Kodierung zur Kodierung. AZ64
```
alter table t1 alter column c0 encode az64;
```
Die folgende Anweisung ändert die Komprimierungskodierung für Spalte c1 von der Z-Standardcodierung zur Kodierung. AZ64
```
alter table t1 alter column c1 encode az64;
```
Die folgende Anweisung ändert die Komprimierungskodierung für Spalte c2 von LZO-Kodierung in Byte-Verzeichnis-Kodierung.
```
alter table t1 alter column c2 encode bytedict;
```
Die folgende Anweisung ändert die Komprimierungskodierung für Spalte c3 von Zstandard-Kodierung in Runlength-Kodierung.
```
alter table t1 alter column c3 encode runlength;
```
## Ändern einer DISTSTYLE KEY DISTKEY-Spalte
Die folgenden Beispiele illustrieren das Ändern von DISTSTYLE und DISTKEY in einer Tabelle.
Erstellen Sie eine Tabelle mit der Verteilung EVEN. Die Ansicht SVV\$1TABLE\$1INFO zeigt für DISTSTYLE den Wert EVEN.
```
create table inventory(
inv_date_sk int4 not null ,
inv_item_sk int4 not null ,
inv_warehouse_sk int4 not null ,
inv_quantity_on_hand int4
) diststyle even;
Insert into inventory values(1,1,1,1);
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | EVEN
```
Ändern Sie die Tabelle DISTKEY in `inv_warehouse_sk`. Die Ansicht SVV\$1TABLE\$1INFO zeigt die Spalte `inv_warehouse_sk` als resultierenden Verteilerschlüssel an.
```
alter table inventory alter diststyle key distkey inv_warehouse_sk;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+-----------------------
inventory | KEY(inv_warehouse_sk)
```
Ändern Sie die Tabelle DISTKEY in `inv_item_sk`. Die Ansicht SVV\$1TABLE\$1INFO zeigt die Spalte `inv_item_sk` als resultierenden Verteilerschlüssel an.
```
alter table inventory alter distkey inv_item_sk;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+-----------------------
inventory | KEY(inv_item_sk)
```
## Ändern einer Tabelle in DISTSTYLE ALL
Die folgenden Beispiele zeigen, wie Sie eine Tabelle in DISTSTYLE ALL ändern.
Erstellen Sie eine Tabelle mit der Verteilung EVEN. Die Ansicht SVV\$1TABLE\$1INFO zeigt für DISTSTYLE den Wert EVEN.
```
create table inventory(
inv_date_sk int4 not null ,
inv_item_sk int4 not null ,
inv_warehouse_sk int4 not null ,
inv_quantity_on_hand int4
) diststyle even;
Insert into inventory values(1,1,1,1);
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | EVEN
```
Ändern Sie die Tabelle DISTSTYLE in ALL. Die Ansicht SVV\$1TABLE\$1INFO zeigt die geänderte DISTSYTLE an.
```
alter table inventory alter diststyle all;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | ALL
```
## Ändern des SORTKEY einer Tabelle
Sie können festlegen, ob eine Tabelle einen zusammengesetzten Sortierschlüssel oder keinen Sortierschlüssel haben soll.
In der folgenden Tabellendefinition ist die Tabelle `t1` mit einem überlappenden Sortierschlüssel definiert.
```
create table t1 (c0 int, c1 int) interleaved sortkey(c0, c1);
```
Der folgende Befehle ändert die Tabelle so, dass aus dem überlappenden Sortierschlüssel ein zusammengesetzter Sortierschlüssel wird.
```
alter table t1 alter sortkey(c0, c1);
```
Der folgende Befehl ändert die Tabelle so, dass der überlappende Sortierschlüssel entfernt wird.
```
alter table t1 alter sortkey none;
```
In der folgenden Tabellendefinition ist die Tabelle `t1` mit der Spalte `c0` als Sortierschlüssel definiert.
```
create table t1 (c0 int, c1 int) sortkey(c0);
```
Der folgende Befehle ändert die Tabelle `t1` in einen zusammengesetzten Sortierschlüssel.
```
alter table t1 alter sortkey(c0, c1);
```
## Ändern einer Tabelle in ENCODE AUTO
Das folgende Beispiel zeigt, wie Sie eine Tabelle in ENCODE AUTO ändern.
Die Tabellendefinition für dieses Beispiel lautet wie folgt. Die Spalte `c0` ist mit dem Kodierungstyp AZ64 und die Spalte `c1` mit dem Kodierungstyp LZO definiert.
```
create table t1(c0 int encode AZ64, c1 varchar encode LZO);
```
Die folgende Anweisung ändert die Kodierung dieser Tabelle auf AUTO.
```
alter table t1 alter encode auto;
```
Das folgende Beispiel zeigt, wie Sie eine Tabelle ändern, um die Einstellung ENCODE AUTO zu entfernen.
Die Tabellendefinition für dieses Beispiel lautet wie folgt. Die Tabellenspalten werden ohne Kodierung definiert. In diesem Fall ist die Kodierung standardmäßig auf ENCODE AUTO eingestellt.
```
create table t2(c0 int, c1 varchar);
```
Die folgende Anweisung ändert die Kodierung für Spalte c0 dieser Tabelle in LZO. Die Tabellenkodierung ist nicht mehr auf ENCODE AUTO eingestellt.
```
alter table t2 alter column c0 encode lzo;;
```
## Ändern einer Kontrolle der Sicherheit auf Zeilenebene
Der folgende Befehl schaltet RLS für die Tabelle aus:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY OFF;
```
Der folgende Befehl aktiviert RLS für die Tabelle:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
```
Der folgende Befehl aktiviert RLS für die Tabelle und macht es über Datashares zugänglich:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY FOR DATASHARES OFF;
```
Der folgende Befehl aktiviert RLS für die Tabelle und macht es über Datashares unzugänglich:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY FOR DATASHARES ON;
```
Der folgende Befehl aktiviert RLS und setzt den RLS-Verbindungstyp für die Tabelle auf OR:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON CONJUNCTION TYPE OR;
```
Der folgende Befehl aktiviert RLS und setzt den RLS-Verbindungstyp für die Tabelle auf AND:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON CONJUNCTION TYPE AND;
```
# Beispiele für ALTER EXTERNAL TABLE
Die folgenden Beispiele verwenden einen Amazon S3 S3-Bucket in der Region USA Ost (Nord-Virginia) (`us-east-1`) AWS-Region und die in [Beispiele](r_CREATE_EXTERNAL_TABLE_examples.md) für CREATE TABLE erstellten Beispieltabellen. Weitere Informationen zur Verwendung von Partitionen mit externen Tabellen finden Sie unter [Partitionierung externer Redshift-Spectrum-Tabellen](c-spectrum-external-tables.md#c-spectrum-external-tables-partitioning).
Im folgenden Beispiel wird die Tabelleneigenschaft numRows für die externe Tabelle SPECTRUM.SALES auf 170.000 Zeilen festgelegt.
```
alter table spectrum.sales
set table properties ('numRows'='170000');
```
Im folgenden Beispiel wird der Speicherort der externen Tabelle SPECTRUM.SALES geändert.
```
alter table spectrum.sales
set location 's3://redshift-downloads/tickit/spectrum/sales/';
```
Im folgenden Beispiel wird das Format der externen Tabelle SPECTRUM.SALES in Parquet geändert.
```
alter table spectrum.sales
set file format parquet;
```
Im folgenden Beispiel wird der externen Tabelle SPECTRUM.SALES\$1PART eine Partition hinzugefügt.
```
alter table spectrum.sales_part
add if not exists partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/';
```
Im folgenden Beispiel werden der Tabelle SPECTRUM.SALES\$1PART drei Partitionen hinzugefügt.
```
alter table spectrum.sales_part add if not exists
partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-02-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/'
partition(saledate='2008-03-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/';
```
Im folgenden Beispiel wird die externe Tabelle SPECTRUM.SALES\$1PART dahingehend geändert, dass die Partition entfernt wird `saledate='2008-01-01''`.
```
alter table spectrum.sales_part
drop partition(saledate='2008-01-01');
```
Im folgenden Beispiel wird ein neuer Amazon S3-Pfad für die Partition mit festgelegt `saledate='2008-01-01'`.
```
alter table spectrum.sales_part
partition(saledate='2008-01-01')
set location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01-01/';
```
Das folgende Beispiel ändert den Namen `sales_date` in `transaction_date`.
```
alter table spectrum.sales rename column sales_date to transaction_date;
```
Im folgenden Beispiel wird das Spalten-Mapping auf die Positionszuweisung zu einer externen Tabelle gesetzt, die das ORC (Optimized Row Columnar) Format verwendet.
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='position');
```
Im folgenden Beispiel wird das Spalten-Mapping auf die Namenszuweisung zu einer externen Tabelle gesetzt, die das ORC (Optimized Row Columnar) Format verwendet.
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='name');
```
# Beispiele für ALTER TABLE ADD und DROP COLUMN
In den folgenden Beispielen wird gezeigt, wie ALTER TABLE verwendet wird, um eine einfache Tabellenspalte hinzuzufügen und dann zu entfernen und eine Spalte mit einem abhängigen Objekt zu entfernen.
## Hinzufügen (ADD) und Entfernen (DROP) einer einfachen Spalte
Im folgenden Beispiel wird der Tabelle USERS die eigenständige Spalte FEEDBACK\$1SCORE hinzugefügt. Diese Spalte enthält einfach eine Ganzzahl und der Standardwert für diese Spalte ist NULL (kein Feedbackergebnis).
Führen Sie zunächst eine Abfrage für die Katalogtabelle PG\$1TABLE\$1DEF aus, um das Schema der Tabelle USERS anzuzeigen:
```
column | type | encoding | distkey | sortkey
--------------+------------------------+----------+---------+--------
userid | integer | delta | true | 1
username | character(8) | lzo | false | 0
firstname | character varying(30) | text32k | false | 0
lastname | character varying(30) | text32k | false | 0
city | character varying(30) | text32k | false | 0
state | character(2) | bytedict | false | 0
email | character varying(100) | lzo | false | 0
phone | character(14) | lzo | false | 0
likesports | boolean | none | false | 0
liketheatre | boolean | none | false | 0
likeconcerts | boolean | none | false | 0
likejazz | boolean | none | false | 0
likeclassical | boolean | none | false | 0
likeopera | boolean | none | false | 0
likerock | boolean | none | false | 0
likevegas | boolean | none | false | 0
likebroadway | boolean | none | false | 0
likemusicals | boolean | none | false | 0
```
Fügen Sie nun die Spalte feedback\$1score hinzu:
```
alter table users
add column feedback_score int
default NULL;
```
Wählen Sie die Spalte FEEDBACK\$1SCORE aus USERS aus, um zu überprüfen, ob sie hinzugefügt wurde:
```
select feedback_score from users limit 5;
feedback_score
----------------
NULL
NULL
NULL
NULL
NULL
```
Entfernen Sie die Spalte, um die ursprüngliche DDL wiederherzustellen:
```
alter table users drop column feedback_score;
```
## Entfernen einer Spalte mit einem abhängigen Objekt
In diesem Beispiel wird eine Spalte entfernt, die ein abhängiges Objekt enthält. Daher wird das abhängige Objekt ebenfalls entfernt.
Fügen Sie zunächst der Tabelle USERS erneut die Spalte FEEDBACK\$1SCORE hinzu:
```
alter table users
add column feedback_score int
default NULL;
```
Erstellen Sie als Nächstes eine Ansicht aus der Tabelle USERS mit dem Namen USERS\$1VIEW:
```
create view users_view as select * from users;
```
Versuchen Sie nun, die Spalte FEEDBACK\$1SCORE aus der Spalte USERS zu entfernen. Diese DROP-Anweisung verwendet das Standardverhalten (RESTRICT):
```
alter table users drop column feedback_score;
```
Amazon Redshift zeigt die Fehlermeldung an, dass die Spalte nicht entfernt werden kann, da ein anderes Objekt von ihr abhängig ist.
Versuchen Sie erneut, die Spalte FEEDBACK\$1SCORE zu entfernen. Geben Sie dieses Mal CASCADE an, um alle abhängigen Objekte zu entfernen:
```
alter table users
drop column feedback_score cascade;
```
# ALTER TABLE APPEND
Fügt einer Zieltabelle Zeilen hinzu, indem Daten aus einer vorhandenen Quelltabelle verschoben werden. Daten in der Quelltabelle werden zu entsprechenden Spalten in der Zieltabelle verschoben. Die Reihenfolge der Spalten spielt keine Rolle. Nachdem die Daten der Zieltabelle erfolgreich angefügt wurden, ist die Quelltabelle leer. ALTER TABLE APPEND ist in der Regel sehr viel schneller als die vergleichbaren Operationen [CREATE TABLE AS](r_CREATE_TABLE_AS.md) oder [INSERT](r_INSERT_30.md), da die Daten verschoben und nicht dupliziert werden.
**Anmerkung**
ALTER TABLE APPEND verschiebt Datenblöcke zwischen der Quelltabelle und der Zieltabelle. Um die Leistung zu verbessern, komprimiert ALTER TABLE APPEND als Teil der append-Operation keinen Speicher. Dies hat zur Folge, dass die Nutzung von Arbeitsspeicher vorübergehend zunimmt. Um den Speicherplatz wieder zurückzugewinnen, führen Sie eine [VACUUM](r_VACUUM_command.md)-Operation durch.
Spalten mit den gleichen Namen müssen identische Spaltenattribute besitzen. Wenn weder die Quelltabelle noch die Zieltabelle Spalten enthält, die in der jeweils anderen Tabelle nicht vorhanden sind, verwenden Sie die Parameter IGNOREEXTRA oder FILLTARGET, um anzugeben, wie zusätzliche Spalten verwaltet werden sollen.
Sie können keine Identitätsspalten anfügen. Wenn beide Tabellen eine Identitätsspalte enthalten, ist der Befehl nicht erfolgreich. Wenn nur eine Tabelle eine Identitätsspalte enthält, verwenden Sie die Parameter FILLTARGET oder IGNOREEXTRA. Weitere Informationen finden Sie unter [Nutzungshinweise für ALTER TABLE APPEND](#r_ALTER_TABLE_APPEND_usage).
Sie können eine GENERATED BY DEFAULT AS IDENTITY-Spalte anhängen. Sie können als GENERATED BY DEFAULT AS IDENTITY-Spalten mit von Ihnen angegebenen Werten aktualisieren. Weitere Informationen finden Sie unter [Nutzungshinweise für ALTER TABLE APPEND](#r_ALTER_TABLE_APPEND_usage).
Bei der Zieltabelle muss es sich um eine permanente Tabelle handeln. Die Quelle kann jedoch eine permanente Tabelle oder eine materialisierte Ansicht sein, die für die Streaming-Erfassung konfiguriert ist. Beide Objekte müssen den gleichen Verteilungsstil und Verteilungsschlüssel verwenden, wenn einer definiert wurde. Wenn die Objekte sortiert sind, müssen beide Objekte den gleichen Sortierstil verwenden und die gleichen Spalten als Sortierschlüssel definieren.
Der Befehl ALTER TABLE APPEND führt automatisch vor Abschluss der Operation einen Commit aus. Es kann kein Rollback ausgeführt werden. Sie können ALTER TABLE APPEND nicht innerhalb eines Transaktionsblocks (BEGIN ... END). Weitere Informationen Transaktionen finden Sie unter [Isolierungsstufen in Amazon Redshift](c_serial_isolation.md).
## Erforderliche Berechtigungen
Je nach verwendetem Befehl ALTER TABLE APPEND ist eine der folgenden Berechtigungen erforderlich:
+ Superuser
+ Benutzer mit der Systemberechtigung ALTER TABLE
+ Benutzer mit Berechtigungen DELETE und SELECT für die Quelltabelle und der Berechtigung INSERT für die Zieltabelle
## Syntax
```
ALTER TABLE target_table_name APPEND FROM [ source_table_name | source_materialized_view_name ]
[ IGNOREEXTRA | FILLTARGET ]
```
Das Anhängen aus einer materialisierten Ansicht funktioniert nur, wenn Ihre materialisierte Ansicht für [Streaming-Aufnahme in eine materialisierte Ansicht](materialized-view-streaming-ingestion.md) konfiguriert ist.
## Parameters
*target\$1table\$1name*
Der Name der Tabelle, an die die Zeilen angefügt werden. Geben Sie einfach den Namen der Tabelle an, oder verwenden Sie das Format *schema\$1name.table\$1name*, um ein spezifisches Schema zu verwenden. Bei der Zieltabelle muss es sich um eine vorhandene permanente Tabelle handeln.
FROM *source\$1table\$1name*
Der Name der Tabelle, die die Zeilen bereitstellt, die angefügt werden sollen. Geben Sie einfach den Namen der Tabelle an, oder verwenden Sie das Format *schema\$1name.table\$1name*, um ein spezifisches Schema zu verwenden. Bei der Quelltabelle muss es sich um eine vorhandene permanente Tabelle handeln.
FROM *source\$1materialized\$1view\$1name*
Der Name der materialisierten Ansicht, die die Zeilen bereitstellt, die angefügt werden sollen. Das Anhängen aus einer materialisierten Ansicht funktioniert nur, wenn Ihre materialisierte Ansicht für [Streaming-Aufnahme in eine materialisierte Ansicht](materialized-view-streaming-ingestion.md) konfiguriert ist. Die materialisierte Quellansicht muss bereits vorhanden sein.
IGNOREEXTRA
Ein Schlüsselwort, das angibt, dass Daten in den zusätzlichen Spalten verworfen werden sollen, wenn die Quelltabelle Spalten enthält, die nicht in der Zieltabelle vorhanden sind. Sie können IGNOREEXTRA nicht mit FILLTARGET verwenden.
FILLTARGET
Ein Schlüsselwort, das angibt, dass die Spalten mit dem Spaltenwert [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default), wenn definiert, oder NULL ausgefüllt werden sollen, wenn die Zieltabelle Spalten enthält, die nicht in der Quelltabelle vorhanden sind. Sie können IGNOREEXTRA nicht mit FILLTARGET verwenden.
## Nutzungshinweise für ALTER TABLE APPEND
+ ALTER TABLE APPEND verschiebt nur identische Spalten aus der Quelltabelle in die Zieltabelle. Die Reihenfolge der Spalten spielt keine Rolle.
+ Wenn weder die Quelltabelle noch die Zieltabelle zusätzliche Spalten enthält, verwenden Sie FILLTARGET oder IGNOREEXTRA entsprechend den folgenden Regeln:
+ Wenn die Quelltabelle Spalten enthält, die in der Zieltabelle nicht vorhanden sind, verwenden Sie IGNOREEXTRA. Durch diesen Befehl werden die zusätzlichen Spalten in der Quelltabelle ignoriert.
+ Wenn die Zieltabelle Spalten enthält, die in der Quelltabelle nicht vorhanden sind, verwenden Sie FILLTARGET. Der Befehl füllt die zusätzlichen Spalten in der Zieltabelle entweder mit dem Standardwert für die Spalte oder dem Wert IDENTITY aus, wenn definiert, oder NULL.
+ Wenn sowohl die Quelltabelle als auch die Zieltabelle zusätzliche Spalten enthalten, ist der Befehl nicht erfolgreich. Sie können nicht FILLTARGET und IGNOREEXTRA gleichzeitig verwenden.
+ Wenn in den beiden Tabellen eine Spalte mit dem gleichen Namen, jedoch unterschiedlichen Attributen vorhanden ist, ist der Befehl nicht erfolgreich. Gleich benannten Spalten müssen die folgenden Attribute gemeinsam sein:
+ Datentyp
+ Spaltengröße
+ Kompressionskodierung
+ Nicht null
+ Sortierstil
+ Sortierschlüsselspalten
+ Verteilungsstil
+ Verteilungschlüsselspalten
+ Sie können keine Identitätsspalten anfügen. Wenn sowohl die Quelltabelle als auch die Zieltabelle Identitätsspalten enthalten, ist der Befehl nicht erfolgreich. Wenn nur die Quelltabelle eine Identitätsspalte enthält, verwenden Sie den Parameter IGNOREXTRA, sodass die Identitätsspalte ignoriert wird. Wenn nur die Zieltabelle eine Identitätsspalte enthält, verwenden Sie den Parameter FILLTARGET, sodass die Identitätsspalte entsprechend der IDENTITY-Klausel ausgefüllt wird, die für die Tabelle definiert ist. Weitere Informationen finden Sie unter [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default).
+ Sie können eine Standard-Identity-Spalte mit der Anweisung ALTER TABLE APPEND anhängen. Weitere Informationen finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md).
+ Für ALTER TABLE APPEND-Operationen gelten exklusive Sperren, wenn sie auf materialisierten Streaming-Ansichten von Amazon Redshift ausgeführt werden, die mit einem der folgenden Objekte verbunden sind:
+ Einem Amazon-Kinesis-Datenstrom
+ Einem Thema in Amazon Managed Streaming für Apache Kafka
+ Einem unterstützten externen Stream, z. B. einem Thema in Confluent Cloud Kafka
Weitere Informationen finden Sie unter [Streaming-Aufnahme in eine materialisierte Ansicht](materialized-view-streaming-ingestion.md).
## Beispiele für ALTER TABLE APPEND
Nehmen Sie an, Ihre Organisation pflegt eine Tabelle namens SALES\$1MONTHLY, um aktuelle Verkaufstransaktionen zu erfassen. Sie möchten jeden Monat Daten aus der Transaktionstabelle in die Tabelle SALES verschieben.
Sie können die Befehle INSERT INTO und TRUNCATE verwenden, um die Aufgabe auszuführen.
```
insert into sales (select * from sales_monthly);
truncate sales_monthly;
```
Sie können diese Operation jedoch sehr viel effizienter ausführen, indem Sie den Befehl ALTER TABLE APPEND verwenden.
Führen Sie zunächst eine Abfrage für die Systemkatalogtabelle [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md) aus, um zu überprüfen, ob beide Tabellen gleiche Spalten mit identischen Spaltenattributen enthalten.
```
select trim(tablename) as table, "column", trim(type) as type,
encoding, distkey, sortkey, "notnull"
from pg_table_def where tablename like 'sales%';
table | column | type | encoding | distkey | sortkey | notnull
-----------+------------+-----------------------------+----------+---------+---------+--------
sales | salesid | integer | lzo | false | 0 | true
sales | listid | integer | none | true | 1 | true
sales | sellerid | integer | none | false | 2 | true
sales | buyerid | integer | lzo | false | 0 | true
sales | eventid | integer | mostly16 | false | 0 | true
sales | dateid | smallint | lzo | false | 0 | true
sales | qtysold | smallint | mostly8 | false | 0 | true
sales | pricepaid | numeric(8,2) | delta32k | false | 0 | false
sales | commission | numeric(8,2) | delta32k | false | 0 | false
sales | saletime | timestamp without time zone | lzo | false | 0 | false
salesmonth | salesid | integer | lzo | false | 0 | true
salesmonth | listid | integer | none | true | 1 | true
salesmonth | sellerid | integer | none | false | 2 | true
salesmonth | buyerid | integer | lzo | false | 0 | true
salesmonth | eventid | integer | mostly16 | false | 0 | true
salesmonth | dateid | smallint | lzo | false | 0 | true
salesmonth | qtysold | smallint | mostly8 | false | 0 | true
salesmonth | pricepaid | numeric(8,2) | delta32k | false | 0 | false
salesmonth | commission | numeric(8,2) | delta32k | false | 0 | false
salesmonth | saletime | timestamp without time zone | lzo | false | 0 | false
```
Betrachten Sie als Nächstes die Größe jeder Tabelle.
```
select count(*) from sales_monthly;
count
-------
2000
(1 row)
select count(*) from sales;
count
-------
412,214
(1 row)
```
Führen Sie nun den folgenden ALTER TABLE APPEND-Befehl aus.
```
alter table sales append from sales_monthly;
```
Betrachten Sie erneut die Größe jeder Tabelle. Die Spalte SALES\$1MONTHLY hat nun 0 Zeilen und die Spalte SALES ist um 2000 Zeilen größer geworden.
```
select count(*) from sales_monthly;
count
-------
0
(1 row)
select count(*) from sales;
count
-------
414214
(1 row)
```
Wenn die Quelltabelle mehr Spalten als die Zieltabelle enthält, geben Sie den Parameter IGNOREEXTRA an. Im folgenden Beispiel wird der Parameter IGNOREEXTRA verwendet, um beim Anfügen an die Tabelle SALES zusätzliche Spalten in der Tabelle SALES\$1LISTING zu ignorieren.
```
alter table sales append from sales_listing ignoreextra;
```
Wenn die Zieltabelle mehr Spalten als die Quelltabelle enthält, geben Sie den Parameter FILLTARGET an. Im folgenden Beispiel wird der Parameter FILLTARGET verwendet, um Spalten in der Tabelle SALES\$1REPORT auszufüllen, die in der Tabelle SALES\$1MONTH nicht vorhanden sind.
```
alter table sales_report append from sales_month filltarget;
```
Das folgende Beispiel zeigt ein Beispiel für die Verwendung von ALTER TABLE APPEND mit einer materialisierten Ansicht als Quelle.
```
ALTER TABLE target_tbl APPEND FROM my_streaming_materialized_view;
```
Die hier verwendeten Namen der Tabelle und der materialisierten Ansicht sind Beispiele. Das Anhängen aus einer materialisierten Ansicht funktioniert nur, wenn Ihre materialisierte Ansicht für [Streaming-Aufnahme in eine materialisierte Ansicht](materialized-view-streaming-ingestion.md) konfiguriert ist. Es werden alle Datensätze in der materialisierten Quellansicht in eine Zieltabelle mit demselben Schema wie die materialisierte Ansicht verschoben und die materialisierte Ansicht bleibt unverändert. Dies ist dasselbe Verhalten wie bei einer Tabelle als Datenquelle.
# VORLAGE ÄNDERN
Ändert die Definition einer vorhandenen Vorlage. Verwenden Sie diesen Befehl, um eine Vorlage umzubenennen, den Besitzer einer Vorlage zu ändern, Parameter zur Vorlagendefinition hinzuzufügen oder zu entfernen oder Parameterwerte festzulegen.
## Erforderliche Berechtigungen
Um eine Vorlage zu ändern, benötigen Sie eine der folgenden Voraussetzungen:
+ Superuser-Rechte
+ ALTER TEMPLATE-Privileg und USAGE-Privileg für das Schema, das die Vorlage enthält
## Syntax
```
ALTER TEMPLATE [database_name.][schema_name.]template_name
{
RENAME TO new_name
| OWNER TO new_owner
| ADD parameter [AS] [value]
| DROP parameter
| SET parameter TO value1 [, parameter2 TO value2 , ...]
};
```
## Parameters
*database\$1name*
(Optional) Der Name der Datenbank, in der die Vorlage erstellt wird. Wenn nicht angegeben, wird die aktuelle Datenbank verwendet.
*schema\$1name*
(Optional) Der Name des Schemas, in dem die Vorlage erstellt wird. Wenn nicht angegeben, wird im aktuellen Suchpfad nach der Vorlage gesucht.
*Vorlagenname*
Der Name der Vorlage, die geändert werden soll.
RENAME TO
Eine Klausel, die die Vorlage umbenennt.
*new\$1name*
Der neue Name der Vorlage. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
OWNER TO
Eine Klausel, die den Besitzer der Vorlage ändert.
*new\$1owner*
Der neue Besitzer der Vorlage.
*ADD-Parameter* [AS] [*Wert*]
Fügt der Vorlage einen neuen Parameter hinzu.
+ Geben Sie für Parameter, die nur aus Schlüsselwörtern bestehen (wie CSV oder GZIP), nur den Parameternamen an.
+ Geben Sie für Parameter, die Werte erfordern, den Parameternamen gefolgt vom Wert an. Sie können optional AS zwischen dem Parameter und dem Wert einfügen.
*DROP-Parameter*
Entfernt den angegebenen Parameter aus der Vorlage. Es können nicht mehrere Parameter mit einem einzigen DROP-Befehl gelöscht werden.
*SET-Parameter* AUF *Wert1* [, *Parameter2 AUF *Wert2**,...]
Aktualisiert die Werte vorhandener Vorlagenparameter. Nur für Parameter verwenden, die bereits Werte haben. In einem einzigen Befehl können mehrere Parameter aktualisiert werden.
## Beispiele
Im folgenden Beispiel wird die Vorlage test\$1template in demo\$1template umbenannt.
```
ALTER TEMPLATE test_template
RENAME TO demo_template;
```
Im folgenden Beispiel wird dem Benutzer bob der Besitz des Schemas demo\$1template übertragen.
```
ALTER TEMPLATE demo_template
OWNER TO bob;
```
Das folgende Beispiel fügt der Vorlage demo\$1template einen Parameter `CSV` hinzu
```
ALTER TEMPLATE demo_template
ADD CSV;
```
Das folgende Beispiel fügt der Vorlage demo\$1template einen Parameter `TIMEFORMAT 'auto'` hinzu
```
ALTER TEMPLATE demo_template
ADD TIMEFORMAT 'auto';
```
Im folgenden Beispiel wird der Parameter `ENCRYPTED` aus der Vorlage demo\$1template gelöscht
```
ALTER TEMPLATE demo_template
DROP ENCRYPTED;
```
Im folgenden Beispiel wird der `DELIMITER` Parameter auf `'|'` und der `TIMEFORMAT` Parameter auf gesetzt: `'epochsecs'`
```
ALTER TEMPLATE demo_template
SET DELIMITER TO '|', TIMEFORMAT TO 'epochsecs';
```
# ALTER USER
Ändert einen Datenbankbenutzer.
## Erforderliche Berechtigungen
Für ALTER USER sind folgende Berechtigungen erforderlich:
+ Superuser
+ Benutzer mit der Berechtigung ALTER USER
+ Aktueller Benutzer, der sein eigenes Passwort ändern möchte
## Syntax
```
ALTER USER username [ WITH ] option [, ... ]
where option is
CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| SYSLOG ACCESS { RESTRICTED | UNRESTRICTED }
| PASSWORD { 'password' | 'md5hash' | 'sha256hash' | DISABLE }
[ VALID UNTIL 'expiration_date' ]
| RENAME TO new_name |
| CONNECTION LIMIT { limit | UNLIMITED }
| SESSION TIMEOUT limit | RESET SESSION TIMEOUT
| SET parameter { TO | = } { value | DEFAULT }
| RESET parameter
| EXTERNALID external_id
```
## Parameters
*username (Benutzername*
Name des Benutzers.
WITH
Optionales Schlüsselwort.
CREATEDB \$1 NOCREATEDB
Mithilfe der Option CREATEDB kann der Benutzer neue Datenbanken erstellen. Der Standardwert ist NOCREATEDB.
CREATEUSER \$1 NOCREATEUSER
Die Option CREATEUSER erstellt einen Superuser mit allen Datenbankrechten einschließlich CREATE USER. Der Standardwert ist NOCREATEUSER. Weitere Informationen finden Sie unter [Superuser](r_superusers.md).
SYSLOG ACCESS \$1 RESTRICTED \$1 UNRESTRICTED \$1
Eine Klausel, über die die Zugriffsebene eines Benutzers auf die Amazon-Redshift-Systemtabellen und -Ansichten festgelegt wird.
Reguläre Benutzer mit der Berechtigung SYSLOG ACCESS RESTRICTED können nur die Zeilen anzeigen, die von den betreffenden Benutzern in für Benutzer sichtbaren Systemtabellen und Ansichten erstellt wurden. Die Standardeinstellung ist RESTRICTED.
Reguläre Benutzer mit der Berechtigung SYSLOG ACCESS UNRESTRICTED können alle Zeilen in für Benutzer sichtbaren Systemtabellen und Ansichten anzeigen, einschließlich Zeilen, die von anderen Benutzern erstellt wurden. Über die Option UNRESTRICTED erhält ein Benutzer keinen Zugriff auf für Superuser sichtbare Tabellen. Nur Superuser können auf solche Tabellen zugreifen.
Wenn Sie einem Benutzer uneingeschränkten Zugriff auf Systemtabellen gewähren, sieht der Benutzer auch Daten, die von anderen Benutzern generiert wurden. STL\$1QUERY und STL\$1QUERYTEXT enthalten beispielsweise den vollständigen Text von INSERT-, UPDATE- und DELETE-Anweisungen, die möglicherweise sensible von Benutzern generierte Daten enthalten.
Alle Zeilen in SVV\$1TRANSACTIONS sind für alle Benutzer sichtbar.
Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
PASSWORD \$1 '*password*' \$1 '*md5hash*' \$1 '*sha256hash*' \$1 DISABLE \$1
Legt das Benutzerpasswort fest.
Standardmäßig können Benutzer ihre eigenen Passwörter ändern, es sei denn, das Passwort ist deaktiviert. Legen Sie zum Deaktivieren des Passworts eines Benutzers DISABLE fest. Wenn das Passwort eines Benutzers deaktiviert ist, wird das Passwort aus dem System gelöscht und der Benutzer kann sich nur mit temporären Benutzeranmeldeinformationen AWS Identity and Access Management (IAM) anmelden. Weitere Informationen finden Sie unter [Verwenden der IAM-Authentifizierung zur Erstellung von Benutzeranmeldeinformationen für die Datenbank](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html). Nur ein Superuser kann Passwörter aktivieren oder deaktivieren. Sie können das Passwort eines Superusers nicht deaktivieren. Führen Sie zum Aktivieren eines Passworts ALTER USER aus und legen Sie ein Passwort fest.
Weitere Informationen zur Verwendung des PASSWORT-Parameters finden Sie unter [CREATE USER](r_CREATE_USER.md).
VALID UNTIL '*expiration\$1date*'
Gibt an, dass das Passwort ein Ablaufdatum hat. Verwenden Sie den Wert `'infinity'`, um ein Ablaufdatum zu vermeiden. Der gültige Datentyp für diesen Parameter ist timestamp.
Nur Superuser können diesen Parameter verwenden.
RENAME TO
Benennt den Benutzer um.
*new\$1name*
Der neue Name des Benutzers. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
Wenn Sie einen Benutzer umbenennen, müssen Sie auch das Passwort des Benutzers ändern. Das neue Passwort muss sich nicht vom vorherigen Passwort unterscheiden. Der Benutzername wird als Teil der Passwortverschlüsselung verwendet. Daher wird das Passwort gelöscht, wen ein Benutzer umbenannt wird. Der Benutzer kann sich erst wieder anmelden, wenn das Passwort zurückgesetzt wurde. Beispiel:
```
alter user newuser password 'EXAMPLENewPassword11';
```
CONNECTION LIMIT \$1 *Limit* \$1 UNLIMITED \$1
Die maximale Zahl von Datenbankverbindungen, die der Benutzer gleichzeitig geöffnet haben darf. Das Limit wird für Superuser nicht durchgesetzt. Mithilfe des Schlüsselworts UNLIMITED können Sie die maximale Zahl gleichzeitiger Verbindungen festlegen. Möglicherweise gilt auch ein Limit für die Zahl der Verbindungen für die einzelnen Datenbanken. Weitere Informationen finden Sie unter [CREATE DATABASE](r_CREATE_DATABASE.md). Der Standardwert ist UNLIMITED. Um die aktuellen Verbindungen anzuzeigen, führen Sie eine Abfrage für die Systemansicht [STV\$1SESSIONS](r_STV_SESSIONS.md) aus.
Wenn sowohl für Benutzer- als auch für Datenbankverbindungen Limits gelten, muss ein ungenutzter Verbindungsplatz verfügbar sein, der sich innerhalb beider Grenzen befindet, wenn ein Benutzer versucht, eine Verbindung herzustellen.
SESSION TIMEOUT *limit* \$1 RESET SESSION TIMEOUT
Die maximale Zeit in Sekunden, die eine Sitzung inaktiv oder untätig bleibt. Der Bereich liegt zwischen 60 Sekunden (einer Minute) und 1.728.000 Sekunden (20 Tagen). Wenn für den Benutzer kein Sitzungstimeout eingestellt ist, gilt die Clustereinstellung. Weitere Informationen finden Sie unter [ Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
Wenn Sie das Sitzungstimeout festlegen, wird es nur auf neue Sitzungen angewendet.
Um Informationen über aktive Benutzersitzungen, einschließlich der Startzeit, des Benutzernamens und des Sitzungstimeouts anzuzeigen, fragen Sie die [STV\$1SESSIONS](r_STV_SESSIONS.md)-Systemansicht ab. Um Informationen über den Verlauf von Benutzersitzungen anzuzeigen, fragen Sie die [STL\$1SESSIONS](r_STL_SESSIONS.md)-Ansicht an. Um Informationen über Datenbankbenutzer, einschließlich Sitzungstimeouts, abzurufen, fragen Sie die [SVL\$1USER\$1INFO](r_SVL_USER_INFO.md)-Ansicht ab.
SET
Legt für alle Sitzungen, die vom angegeben Benutzer ausgeführt werden, einen Konfigurationsparameter auf einen neuen Standardwert fest.
RESET
Setzt für den angegeben Benutzer einen Konfigurationsparameter auf den ursprünglichen Standardwert zurück.
*Parameter*
Der Name des Parameters, der festgelegt oder zurückgesetzt werden soll.
*Wert*
Neuer Wert des Parameters.
DEFAULT
Legt für alle Sitzungen, die vom angegeben Benutzer ausgeführt werden, den Konfigurationsparameter auf den Standardwert fest.
EXTERNALID *external\$1id*
Der Bezeichner für den Benutzer, der einem Identitätsanbieter zugeordnet ist. Der Benutzer muss sein Passwort deaktiviert haben. Weitere Informationen finden Sie unter [Nativer Identitätsanbieter(IdP)-Verbund für Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html).
## Nutzungshinweise
+ **Versuch, rdsdb zu ändern** – Sie können den Benutzer `rdsdb` nicht ändern.
+ **Ein unbekanntes Passwort erstellen** — Wenn Sie die AWS Identity and Access Management (IAM-) Authentifizierung verwenden, um Datenbank-Benutzeranmeldeinformationen zu erstellen, möchten Sie möglicherweise einen Superuser erstellen, der sich nur mit temporären Anmeldeinformationen anmelden kann. Sie können das Passwort eines Superusers nicht deaktivieren, aber Sie können ein unbekanntes Passwort mithilfe einer zufällig generierten MD5 Hash-Zeichenfolge erstellen.
```
alter user iam_superuser password 'md51234567890123456780123456789012';
```
+ **Festlegen von search\$1path** – Wenn Sie den Parameter [search\$1path](r_search_path.md) mit dem Befehl ALTER USER festlegen, wirkt sich die Änderung bei der nächsten Anmeldung des angegebenen Benutzers aus. Wenn Sie den „search\$1path“-Wert für den aktuellen Benutzer und die aktuelle Sitzung ändern möchten, verwenden Sie den Befehl SET.
+ **Festlegen der Zeitzone** – Wenn Sie SET TIMEZONE mit dem Befehl ALTER USER verwenden, wirkt sich die Änderung bei der nächsten Anmeldung des angegebenen Benutzers aus.
+ **Arbeiten mit dynamischer Datenmaskierung und Sicherheitsrichtlinien auf Zeilenebene**: Wenn Ihr bereitgestellter Cluster oder Serverless-Namespace über dynamische Datenmaskierungs- oder Sicherheitsrichtlinien auf Zeilenebene verfügt, werden die folgenden Befehle für normale Benutzer blockiert:
```
ALTER SET enable_case_sensitive_super_attribute/enable_case_sensitive_identifier/downcase_delimited_identifier
```
Nur Superuser und Benutzer mit der ALTER USER-Berechtigung können diese Konfigurationsoptionen festlegen. Weitere Informationen zur Sicherheit auf Zeilenebene finden Sie unter [Sicherheit auf Zeilenebene](t_rls.md). Weitere Informationen zur dynamischen Datenmaskierung finden Sie unter [Dynamische Datenmaskierung](t_ddm.md).
## Beispiele
Im folgenden Beispiel erhält der Benutzer ADMIN das Recht, Datenbanken zu erstellen:
```
alter user admin createdb;
```
Im folgenden Beispiel werden das Passwort des Benutzers ADMIN auf `adminPass9` festgelegt und Ablaufdatum und Ablaufzeit für das Passwort festgelegt:
```
alter user admin password 'adminPass9'
valid until '2017-12-31 23:59';
```
Im folgenden Beispiel wird der Benutzer ADMIN in SYSADMIN umbenannt:
```
alter user admin rename to sysadmin;
```
Im folgenden Beispiel wird das Timeout für eine Leerlaufsitzung für einen Benutzer auf 300 Sekunden aktualisiert.
```
ALTER USER dbuser SESSION TIMEOUT 300;
```
Setzt das Timeout für Leerlaufsitzungen des Benutzers zurück. Wenn Sie es zurücksetzen, gilt die Clustereinstellung. Sie müssen Datenbank-Superuser sein, um diesen Befehl auszuführen. Weitere Informationen finden Sie unter [Kontingente und Limits in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Verwaltungshandbuch zu Amazon Redshift*.
```
ALTER USER dbuser RESET SESSION TIMEOUT;
```
Im folgenden Beispiel wird die externe ID für einen Benutzer namens `bob` aktualisiert. Der Namespace lautet `myco_aad`. Wenn der Namespace keinem registrierten Identitätsanbieter zugeordnet ist, führt dies zu einem Fehler.
```
ALTER USER myco_aad:bob EXTERNALID "ABC123" PASSWORD DISABLE;
```
Im folgenden Beispiel wird die Zeitzone für alle von einem bestimmten Datenbankbenutzer ausgeführten Sitzungen eingerichtet. Die Zeitzone wird für aufeinander folgende Sitzungen, nicht für die aktuelle Sitzung geändert.
```
ALTER USER odie SET TIMEZONE TO 'Europe/Zurich';
```
Im folgenden Beispiel wird die maximale Anzahl von Datenbankverbindungen festgelegt, die der Benutzer `bob` geöffnet haben darf.
```
ALTER USER bob CONNECTION LIMIT 10;
```
# ANALYZE
Aktualisiert Tabellenstatistiken zur Verwendung durch den Abfrageplaner.
## Erforderliche Berechtigungen
Für ANALYZE sind folgende Berechtigungen erforderlich:
+ Superuser
+ Benutzer mit der Berechtigung ANALYZE
+ Besitzer der Beziehung
+ Datenbankbesitzer, für den die Tabelle freigegeben wird.
## Syntax
```
ANALYZE [ VERBOSE ]
[ [ table_name [ ( column_name [, ...] ) ] ]
[ PREDICATE COLUMNS | ALL COLUMNS ]
```
## Parameters
VERBOSE
Eine Klausel, die Nachrichten zum Fortschritt in Bezug auf die Operation ANALYZE zurückgibt. Diese Option ist nützlich, wenn Sie keine Tabelle angeben.
*table\$1name*
Sie können spezifische Tabellen analysieren, einschließlich temporärer Tabellen. Sie können die Tabelle mittels ihres Schemanamens qualifizieren. Optional können Sie einen table\$1name angeben, um eine einzelne Tabelle zu analysieren. Sie können nicht mehr als einen *table\$1name* mit einer einzelnen Anweisung ANALYZE *table\$1name* angeben. Wenn Sie keinen *table\$1name*-Wert angeben, werden alle Tabellen in der aktuell verbundenen Datenbank analysiert, einschließlich der persistenten Tabellen im Systemkatalog. Amazon Redshift überspringt die Analyse einer Tabelle, wenn der Prozentsatz der Zeilen, die seit dem letzten ANALYZE-Vorgang geändert wurden, unter dem Analyseschwellenwert liegt. Weitere Informationen finden Sie unter [Analyse-Schwellenwert](#r_ANALYZE-threshold).
Sie müssen Amazon-Redshift-Systemtabellen (STL- und STV-Tabellen) nicht analysieren.
*column\$1name*
Wenn Sie einen *table\$1name* angeben, können Sie auch eine oder mehrere Spalten in der Tabelle angeben (als durch Komma getrennte Liste in Klammern). Wenn eine Spaltenliste angegeben ist, werden nur die aufgelisteten Spalten analysiert.
PREDICATE COLUMNS \$1 ALL COLUMNS
Klausel, die angibt, ob ANALYZE nur Prädikatspalten umfassen sollte. Geben Sie PREDICATE COLUMNS an, um nur Spalten zu analysieren, die in vorherigen Abfragen als Prädikate verwendet wurden oder wahrscheinlich als Prädikate verwendet werden. Geben Sie ALL COLUMNS an, um alle Spalten zu analysieren. Der Standardwert ist ALL COLUMNS.
Eine Spalte wird nur dann in den Satz der Prädikatspalten aufgenommen, wenn Folgendes zutrifft:
+ Die Spalte wurde in einer Abfrage als Teil eines Filters, einer Join-Bedingung oder einer Gruppe durch Klausel verwendet.
+ Die Spalte ist ein Verteilungsschlüssel.
+ Die Spalte ist Teil eines Sortierschlüssels.
Wenn keine Spalten als Prädikatspalten markiert sind, beispielsweise weil für die Tabelle noch keine Abfrage ausgeführt wurde, werden alle Spalten analysiert, auch wenn PREDICATE COLUMNS angegeben ist. In diesem Fall antwortet Amazon Redshift möglicherweise mit einer Meldung wie Keine Prädikatspalten für "" *table-name* gefunden. Alle Spalten werden analysiert. Weitere Informationen zu Prädikatspalten finden Sie unter [Analysieren von Tabellen](t_Analyzing_tables.md).
## Nutzungshinweise
Amazon Redshift führt automatisch ANALYZE für Tabellen aus, die Sie mit den folgenden Befehlen erstellen:
+ CREATE TABLE AS
+ CREATE TEMP TABLE AS
+ SELECT INTO
Sie können keine externen Tabellen analysieren.
Sie müssen den Befehl ANALYZE nicht für diese Tabellen ausführen, wenn sie erstellt werden. Wenn Sie sie ändern, sollten Sie sie jedoch genauso wie andere Tabellen analysieren.
### Analyse-Schwellenwert
Um die Verarbeitungszeit zu reduzieren und die allgemeine Systemleistung zu verbessern, überspringt Amazon Redshift ANALYZE für eine Tabelle, wenn der Prozentsatz der Zeilen, die seit der letzten Ausführung des Befehls ANALYZE geändert wurden, niedriger als der durch den Parameter [analyze\$1threshold\$1percent](r_analyze_threshold_percent.md) angegebene Analyseschwellenwert ist. Der Standardwert für `analyze_threshold_percent` ist 10. Um `analyze_threshold_percent` für die aktuelle Sitzung zu ändern, führen Sie den Befehl [SET](r_SET.md) aus. Im folgenden Beispiel wird `analyze_threshold_percent` in 20 Prozent geändert.
```
set analyze_threshold_percent to 20;
```
Um Tabellen zu analysieren, wenn nur eine kleine Zahl von Zeilen geändert wurde, legen Sie `analyze_threshold_percent` auf eine beliebig kleine Zahl fest. Wenn Sie beispielsweise `analyze_threshold_percent` auf 0,01 festlegen, wird eine Tabelle mit 100.000.000 Zeilen nicht übersprungen, wenn mindestens 10.000 Zeilen geändert wurden.
```
set analyze_threshold_percent to 0.01;
```
Wenn ANALYZE eine Tabelle überspringt, weil der Analyseschwellenwert nicht erreicht wird, gibt Amazon Redshift die folgende Meldung zurück.
```
ANALYZE SKIP
```
Um alle Tabellen zu analysieren, auch wenn keine Zeilen geändert wurden, legen Sie `analyze_threshold_percent` auf 0 fest.
Um die Ergebnisse von ANALYZE-Vorgängen anzuzeigen, führen Sie für die Systemtabelle [STL\$1ANALYZE](r_STL_ANALYZE.md) eine Abfrage aus.
Weitere Informationen zum Analysieren von Tabellen finden Sie unter [Analysieren von Tabellen](t_Analyzing_tables.md).
## Beispiele
Analysiert alle Tabellen in der Datenbank TICKIT und gibt Fortschrittinformationen zurück.
```
analyze verbose;
```
Analysiert nur die Tabelle LISTING.
```
analyze listing;
```
Analysiert die Spalten VENUEID und VENUENAME in der Tabelle VENUE.
```
analyze venue(venueid, venuename);
```
Analysiert nur Prädikatspalten in der Tabelle VENUE.
```
analyze venue predicate columns;
```
# ANALYZE COMPRESSION
Führt Kompressionsanalysen aus und erstellt einen Bericht mit der vorgeschlagenen Spaltenkodierung für die analysierten Tabellen. Der Bericht enthält für jede Spalte eine Schätzung der potenziellen Reduzierung des benötigten Festplattenplatzes im Vergleich zur RAW-Kodierung.
## Syntax
```
ANALYZE COMPRESSION
[ [ table_name ]
[ ( column_name [, ...] ) ] ]
[COMPROWS numrows]
```
## Parameters
*table\$1name*
Sie können die Kompression für spezifische Tabellen analysieren, einschließlich temporärer Tabellen. Sie können die Tabelle mittels ihres Schemanamens qualifizieren. Optional können Sie einen *table\$1name* angeben, um eine einzelne Tabelle zu analysieren. Wenn Sie keinen *table\$1name* angeben, werden alle Tabellen in der aktuell verbundenen Datenbank analysiert. Sie können nicht mehr als einen *table\$1name* mit einer einzelnen Anweisung ANALYZE COMPRESSION angeben.
*column\$1name*
Wenn Sie einen *table\$1name* angeben, können Sie auch eine oder mehrere Spalten in der Tabelle angeben (als durch Komma getrennte Liste in Klammern).
COMPROWS
Die Anzahl der Zeilen, die beispielhaft für die Kompressionanalyse verwendet werden sollen. Die Analyse wird für Zeilen aus jedem Daten-Slice ausgeführt. Wenn Sie beispielsweise COMPROWS 1000000 (1.000.000) angeben und das System insgesamt 4 Slices enthält, werden nicht mehr als 250.000 Zeilen pro Slice gelesen und analysiert. Wenn COMPROWS nicht angegeben wird, werden standardmäßig 100.000 Zeilen pro Slice beispielhaft analysiert. Werte für COMPROWS, die niedriger als der Standardwert von 100.000 Zeilen pro Slice sind, werden automatisch auf den Standardwert aktualisiert. Die Komprimierungsanalyse gibt jedoch keine Empfehlungen aus, wenn die Menge der Daten in einer Tabelle nicht als aussagekräftige Grundlage für die Analyse ausreicht. Wenn der Wert für COMPROWS größer als die Anzahl der Zeilen in der Tabelle ist, wird der Befehl ANALYZE COMPRESSION dennoch fortgesetzt und die Kompressionsanalyse wird anhand aller verfügbaren Zeilen ausgeführt. Die Verwendung von COMPROWS führt zu einem Fehler, wenn keine Tabelle angegeben ist.
*numrows*
Die Anzahl der Zeilen, die beispielhaft für die Kompressionanalyse verwendet werden sollen. Der akzeptierte Bereich für *numrows* ist eine Zahl zwischen 1000 und 1000000000 (1.000.000.000).
## Nutzungshinweise
ANALYZE COMPRESSION bewirkt eine exklusive Tabellensperrung, die gleichzeitig ausgeführte Lese- und Schreibvorgänge für die Tabelle verhindert. Führen Sie den Befehl ANALYZE COMPRESSION nur aus, wenn die Tabelle nicht verwendet wird.
Führen Sie ANALYZE COMPRESSION aus, um basierend auf einer Beispielauswahl der Tabelleninhalte Empfehlungen zu Kodierungsschemata für Spalten zu erhalten. ANALYZE COMPRESSION ist ein Empfehlungstool und ändert die Spaltenkodierung der Tabelle nicht. Sie können die vorgeschlagene Kodierung anwenden, indem Sie die Tabelle neu erstellen oder eine neue Tabelle mit demselben Schema erstellen. Die Neuerstellung einer nicht komprimierten Tabelle mit geeigneten Kodierungsschemas kann den Platzbedarf auf der Festplatte erheblich reduzieren. Dieser Ansatz spart Speicherplatz und verbessert die Abfrageleistung für I/O-gebundene Workloads.
ANALYZE COMPRESSION überspringt die eigentliche Analysephase und gibt direkt den ursprünglichen Kodierungstyp für jede Spalte zurück, die als SORTKEY bezeichnet ist. Dies geschieht, weil bereichseingeschränkte Scans möglicherweise geringe Leistung zeigen, wenn SORTKEY-Spalten viel stärker komprimiert werden als andere Spalten.
## Beispiele
Das folgende Beispiel zeigt die Codierung und die geschätzte prozentuale Reduzierung für die Spalten nur in der Tabelle LISTING:
```
analyze compression listing;
Table | Column | Encoding | Est_reduction_pct
---------+----------------+----------+-------------------
listing | listid | az64 | 40.96
listing | sellerid | az64 | 46.92
listing | eventid | az64 | 53.37
listing | dateid | raw | 0.00
listing | numtickets | az64 | 65.66
listing | priceperticket | az64 | 72.94
listing | totalprice | az64 | 68.05
listing | listtime | az64 | 49.74
```
Das folgende Beispiel analysiert die Spalten QTYSOLD, COMMISSION und SALETIME in der Tabelle SALES.
```
analyze compression sales(qtysold, commission, saletime);
Table | Column | Encoding | Est_reduction_pct
-------+------------+----------+-------------------
sales | salesid | N/A | 0.00
sales | listid | N/A | 0.00
sales | sellerid | N/A | 0.00
sales | buyerid | N/A | 0.00
sales | eventid | N/A | 0.00
sales | dateid | N/A | 0.00
sales | qtysold | az64 | 83.06
sales | pricepaid | N/A | 0.00
sales | commission | az64 | 71.85
sales | saletime | az64 | 49.63
```
# ANFÜGEN EINER MASKIERUNGSRICHTLINIE
Fügt eine vorhandene Richtlinie für die dynamische Datenmaskierung an eine Spalte an. Weitere Informationen zur dynamischen Datenmaskierung finden Sie unter [Dynamische Datenmaskierung](t_ddm.md).
Superuser und Benutzer oder Rollen mit der Rolle sys:secadmin können eine Maskierungsrichtlinie anfügen.
## Syntax
```
ATTACH MASKING POLICY
{
policy_name ON relation_name
| database_name.policy_name ON database_name.schema_name.relation_name
}
( { output_column_names | output_path } )
[ USING ( { input_column_names | input_path } ) ]
TO { user_name | ROLE role_name | PUBLIC }
[ PRIORITY priority ];
```
## Parameters
*policy\$1name*
Der Name der anzufügenden Maskierungsrichtlinie.
database\$1name
Der Name der Datenbank, in der die Richtlinie und die Beziehung erstellt werden. Die Richtlinie und die Relation müssen sich in derselben Datenbank befinden. Bei der Datenbank kann es sich um die verbundene Datenbank oder um eine Datenbank handeln, die Verbundberechtigungen von Amazon Redshift unterstützt.
schema\$1name
Der Name des Schemas, zu dem die Relation gehört.
*relation\$1name*
Der Name der Relation, an die die Maskierungsrichtlinie angefügt werden soll.
*output\$1column\$1names*
Die Namen der Spalten, für die die Maskierungsrichtlinie gelten soll.
*output\$1paths*
Der vollständige Pfad des SUPER-Objekts, für das die Maskierungsrichtlinie gelten soll, einschließlich des Spaltennamens. Beispielsweise könnte für eine Relation mit einer Spalte vom Typ SUPER mit dem Namen `person` der *output\$1path* `person.name.first_name` sein.
*input\$1column\$1names*
Die Namen der Spalten, die die Maskierungsrichtlinie als Eingabe verwenden wird. Dieser Parameter ist optional. Wenn nicht angegeben, verwendet die Maskierungsrichtlinie *output\$1column\$1names* als Eingaben.
*input\$1paths*
Der vollständige Pfad des SUPER-Objekts, das die Maskierungsrichtlinie als Eingabe verwenden wird. Dieser Parameter ist optional. Wenn nicht angegeben, verwendet die Maskierungsrichtlinie *output\$1path* als Eingaben.
*user\$1name*
Der Name des Benutzers, dem die Maskierungsrichtlinie angefügt werden soll. Sie können nicht derselben Kombination aus Benutzer und Spalte oder Rolle und Spalte zwei Richtlinien zuordnen. Sie können eine Richtlinie einem Benutzer und eine weitere Richtlinie der Rolle des Benutzers anfügen. In diesem Fall gilt die Richtlinie mit der höheren Priorität.
In einem einzelnen Befehl ATTACH MASKING POLICY können Sie nur entweder user\$1name, role\$1name oder PUBLIC festlegen.
*role\$1name*
Der Name der Rolle, der die Maskierungsrichtlinie angefügt werden soll. Sie können nicht zwei Richtlinien demselben column/role Paar zuordnen. Sie können eine Richtlinie einem Benutzer und eine weitere Richtlinie der Rolle des Benutzers anfügen. In diesem Fall gilt die Richtlinie mit der höheren Priorität.
In einem einzelnen Befehl ATTACH MASKING POLICY können Sie nur entweder user\$1name, role\$1name oder PUBLIC festlegen.
*PUBLIC*
Fügt die Maskierungsrichtlinie allen Benutzern an, die auf die Tabelle zugreifen. Sie müssen anderen Maskierungsrichtlinien, die bestimmten Richtlinien column/user oder column/role Paaren zugeordnet sind, eine höhere Priorität einräumen als der Richtlinie PUBLIC, damit sie gelten.
In einem einzelnen Befehl ATTACH MASKING POLICY können Sie nur entweder user\$1name, role\$1name oder PUBLIC festlegen.
*priority*
Die Priorität der Maskierungsrichtlinie. Wenn mehrere Maskierungsrichtlinien für die Abfrage eines bestimmten Benutzers gelten, gilt die Richtlinie mit der höchsten Priorität.
Sie können derselben Spalte nicht zwei verschiedene Richtlinien mit derselben Priorität zuordnen, auch wenn die beiden Richtlinien unterschiedlichen Benutzern oder Rollen zugeordnet sind. Sie können dieselbe Richtlinie mehrmals demselben Satz von Tabellen-, Ausgabespalten-, Eingabespalten- und Prioritätsparametern zuordnen, sofern der Benutzer oder die Rolle, an die die Richtlinie angefügt wird, jedes Mal ein(e) andere(r) ist.
Sie können auf eine Spalte keine Richtlinie anwenden, die dieselbe Priorität wie eine andere dieser Spalte angefügte Richtlinie hat, auch wenn sie für unterschiedliche Rollen bestimmt ist. Dies ist ein optionales Feld. Wenn Sie keine Priorität angeben, wird die Maskierungsrichtlinie standardmäßig mit einer Priorität von 0 angefügt.
Informationen zur Verwendung von ATTACH MASKING POLICY im Amazon Redshift Federated Permissions Catalog finden Sie unter [Verwaltung der Zugriffskontrolle mit Amazon Redshift Redshift-Verbundberechtigungen](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
# ATTACH RLS POLICY
Weisen Sie einem oder mehreren Benutzern oder Rollen eine RLS-Richtlinie für eine Tabelle zu.
Superuser und Benutzer oder Rollen, die die `sys:secadmin`-Rolle haben, können eine Richtlinie anfügen.
## Syntax
```
ATTACH RLS POLICY
{
policy_name ON [TABLE] table_name [, ...]
| database_name.policy_name ON [TABLE] database_name.schema_name.table_name [, ...]
}
TO { user_name | ROLE role_name | PUBLIC } [, ...]
```
## Parameters
*policy\$1name*
Der Name der -Richtlinie.
database\$1name
Der Name der Datenbank, in der die Richtlinie und die Beziehung erstellt werden. Die Richtlinie und die Relation müssen sich in derselben Datenbank befinden. Bei der Datenbank kann es sich um die verbundene Datenbank oder um eine Datenbank handeln, die Verbundberechtigungen von Amazon Redshift unterstützt.
schema\$1name
Der Name des Schemas, zu dem die Relation gehört.
table\$1name
Die Relation, an die die Sicherheitsrichtlinie auf Zeilenebene angefügt ist.
AN \$1 *user\$1name* \$1 ROLE *role\$1name* \$1 PUBLIC\$1 [, ...]
Gibt an, ob die Richtlinie einem oder mehreren angegebenen Benutzern oder Rollen zugeordnet ist.
Informationen zur Verwendung von ATTACH RLS POLICY im Amazon Redshift Federated Permissions Catalog finden Sie unter [Verwaltung der Zugriffskontrolle mit Amazon Redshift Redshift-Verbundberechtigungen](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
## Nutzungshinweise
Beachten Sie bei der Arbeit mit der Anweisung ATTACH RLS POLICY Folgendes:
+ Die angefügte Tabelle sollte alle Spalten enthalten, die in der WITH-Klausel der Anweisung zur Richtlinienerstellung aufgeführt sind.
+ Amazon Redshift RLS unterstützt das Anfügen von RLS-Richtlinien an die folgenden Objekte:
+ Tabellen
+ Ansichten
+ Ansichten mit später Bindung
+ Materialisierte Ansichten
+ Amazon Redshift RLS unterstützt das Anfügen von RLS-Richtlinien an die folgenden Objekte nicht:
+ Katalogtabellen
+ Datenbankübergreifende Relationen
+ Externe Tabellen
+ Temporäre Tabellen
+ Suchtabellen für Richtlinien
+ Basistabellen für materialisierte Ansicht
+ RLS-Richtlinien, die an Superuser oder an Benutzer mit der Berechtigung `sys:secadmin` angefügt sind, werden ignoriert.
## Beispiele
Im folgenden Beispiel wird eine RLS-Richtlinie an die angegebenen Kombinationen von Tabellen und Rollen angefügt. Die RLS-Richtlinie gilt für alle Benutzer mit den Rollen `analyst` oder `dbadmin`, wenn sie auf die Tabelle tickit\$1category\$1redshift zugreifen.
```
ATTACH RLS POLICY policy_concerts ON tickit_category_redshift TO ROLE analyst, ROLE dbadmin;
```
# BEGIN
Startet eine Transaktion. Synonym mit START TRANSACTION.
Eine Transaktion ist eine einzelne, logische Arbeitseinheit, unabhängig davon, ob sie aus einem einzigen oder aus mehreren Befehlen besteht. Im Allgemeinen werden alle Befehle in einer Transaktion für einen Snapshot der Datenbank ausgeführt, dessen Startzeit durch den Wert bestimmt wird, der für den Systemkonfigurationsparameter `transaction_snapshot_begin` festgelegt ist.
Standardmäßig werden einzelne Amazon-Redshift-Operationen (Abfragen, DDL-Anweisungen, Lasten) der Datenbank automatisch übergeben. Wenn Sie ein Commit für eine Operation aussetzen möchten, bis die anschließende Aufgabe abgeschlossen ist, müssen Sie eine Transaktion mit der BEGIN-Anweisung öffnen, die erforderlichen Befehle ausführen und dann die Transaktion mit der Anweisung [COMMIT](r_COMMIT.md) oder [END](r_END.md) schließen. Wenn notwendig, können Sie die Anweisung [ROLLBACK](r_ROLLBACK.md) verwenden, um eine Transaktion abzubrechen, die gerade ausgeführt wird. Eine Ausnahme von diesem Verhalten stellt der Befehl [TRUNCATE](r_TRUNCATE.md) dar, der einen Commit für die Transaktion ausführt, in der er ausgeführt wird, und für den kein Rollback möglich ist.
## Syntax
```
BEGIN [ WORK | TRANSACTION ] [ ISOLATION LEVEL option ] [ READ WRITE | READ ONLY ]
START TRANSACTION [ ISOLATION LEVEL option ] [ READ WRITE | READ ONLY ]
Where option is
SERIALIZABLE
| READ UNCOMMITTED
| READ COMMITTED
| REPEATABLE READ
Note: READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ have no
operational impact and map to SERIALIZABLE in Amazon Redshift. You can see database isolation levels on your cluster
by querying the stv_db_isolation_level table.
```
## Parameters
WORK
Optionales Schlüsselwort.
TRANSACTION
Optionales Schlüsselwort; WORK und TRANSACTION sind Synonyme.
ISOLATION LEVEL SERIALIZABLE
Die serialisierbare Isolierung wird standardmäßig unterstützt. Daher bleibt das Verhalten der Transaktion stets gleich, unabhängig davon, ob diese Syntax in der Anweisung enthalten ist oder nicht. Weitere Informationen finden Sie unter [Verwalten gleichzeitiger Schreiboperationen](c_Concurrent_writes.md). Es werden keine anderen Isolierungsstufen unterstützt.
Der SQL-Standard definiert vier Stufen der Transaktionsisolierung, um folgende Ereignisse zu verhindern: *nicht korrekte Lesevorgänge* (wenn eine Transaktion Daten liest, die von einer gleichzeitigen Transaktion geschrieben werden, für die kein Commit ausgeführt wurde), *nicht wiederholbare Lesevorgänge* (wenn eine Transaktion Daten erneut liest, die sie zuvor bereits gelesen hat, und feststellt, dass die Daten durch eine andere Transaktion geändert wurden, für die seit dem ersten Lesevorgang ein Commit ausgeführt wurde) und *Phantomlesevorgänge* (wenn eine Transaktion eine Anfrage erneut ausführt, einen Satz von Zeilen zurückgibt, die eine Suchbedingung erfüllen, und dann feststellt, dass der Satz von Zeilen aufgrund einer anderen Transaktion, für die vor Kurzem ein Commit ausgeführt wurde, geändert wurde):
+ Lesen von Daten, für die kein Commit ausgeführt wurde: Nicht korrekte Lesungen, nicht wiederholbare Lesungen und Phantomlesungen sind möglich.
+ Lesen von Daten, für die ein Commit ausgeführt wurde: Nicht wiederholbare Lesungen und Phantomlesungen sind möglich.
+ Wiederholbare Lesungen: Phantomlesungen sind möglich.
+ Serialisierbar: Verhindert nicht korrekte Lesungen, nicht wiederholbare Lesungen und Phantomlesungen.
Obwohl Sie jede der vier Isolierungsstufen für Transaktionen verwenden können, verarbeitet Amazon Redshift alle Isolierungsstufen als serialisierbar.
READ WRITE
Erteilt der Transaktion Lese- und Schreibberechtigungen.
READ ONLY
Erteilt der Transaktion Leseberechtigungen.
## Beispiele
Im folgenden Beispiel wird ein serialisierbarer Transaktionsblock gestartet:
```
begin;
```
Im folgenden Beispiel wird der Transaktionsblock auf der serialisierbaren Isolierungsstufe und mit Lese- und Schreibberechtigungen gestartet:
```
begin read write;
```
# CALL
Führt eine gespeicherte Prozedur aus. Der CALL-Befehl muss den Namen der Prozedur und die Werte der Eingabeargumente enthalten. Zum Aufrufen einer gespeicherten Prozedur verwenden Sie die CALL-Anweisung.
**Anmerkung**
CALL kann nicht Teil einer regulären Abfrage sein.
## Syntax
```
CALL sp_name ( [ argument ] [, ...] )
```
## Parameters
*sp\$1name*
Der Name der Prozedur, die ausgeführt werden soll.
*argument*
Der Wert des Eingabearguments. Dieser Parameter kann auch ein Funktionsname sein, wie z. B. `pg_last_query_id()`. Abfragen können nicht als CALL-Argumente verwendet werden.
## Nutzungshinweise
In Amazon Redshift gespeicherte Prozeduren unterstützen verschachtelte und rekursive Aufrufe wie im Nachfolgenden beschrieben. Stellen Sie außerdem sicher, dass Ihre Treiberunterstützung up-to-date, ebenfalls im Folgenden beschrieben, unterstützt wird.
**Topics**
+ [Verschachtelte Aufrufe](#r_CALL_procedure-nested-calls)
+ [Treiberunterstützung](#r_CALL_procedure-driver-support)
### Verschachtelte Aufrufe
In Amazon Redshift gespeicherte Prozeduren unterstützen verschachtelte und rekursive Aufrufe. Die zulässige Höchstanzahl an Verschachtelungsebenen beträgt 16. Verschachtelte Aufrufe können Geschäftslogik in kleineren Prozeduren verkapseln, die von mehreren Aufrufern geteilt werden können.
Wenn Sie eine verschachtelte Prozedur aufrufen, die über Ausgabeparameter verfügt, muss die innere Prozedur INOUT-Argumente definieren. In diesem Fall wird die innere Prozedur in einer nicht konstanten Variable übergeben. OUT-Argumente sind nicht zulässig. Dies ist darauf zurückzuführen, dass eine Variable zum Aufnehmen der Ausgabe des inneren Aufrufs erforderlich ist.
Die Beziehung zwischen inneren und äußeren Prozeduren wird in der Spalte `from_sp_call` von [SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md) protokolliert.
Das folgende Beispiel zeigt die Übergabe von Variablen an einen verschachtelten Prozeduraufruf über INOUT-Argumente.
```
CREATE OR REPLACE PROCEDURE inner_proc(INOUT a int, b int, INOUT c int) LANGUAGE plpgsql
AS $$
BEGIN
a := b * a;
c := b * c;
END;
$$;
CREATE OR REPLACE PROCEDURE outer_proc(multiplier int) LANGUAGE plpgsql
AS $$
DECLARE
x int := 3;
y int := 4;
BEGIN
DROP TABLE IF EXISTS test_tbl;
CREATE TEMP TABLE test_tbl(a int, b varchar(256));
CALL inner_proc(x, multiplier, y);
insert into test_tbl values (x, y::varchar);
END;
$$;
CALL outer_proc(5);
SELECT * from test_tbl;
a | b
----+----
15 | 20
(1 row)
```
### Treiberunterstützung
Wir empfehlen die Aktualisierung Ihrer Java Database Connectivity (JDBC)- und Open Database Connectivity (ODBC)-Treiber auf die neueste Version, die Unterstützung für in Amazon Redshift gespeicherte Prozeduren bietet.
Wenn Ihr Clienttool Treiber-API-Operationen verwendet, die die CALL-Anweisungen an den Server übergeben, können Sie unter Umständen Ihren vorhandenen Treiber verwenden. Ausgabeparameter werden (sofern vorhanden) als Ergebnissatz mit einer Zeile zurückgegeben.
Die neusten Versionen der Amazon Redshift JDBC- und ODBC-Treiber bieten Metadatenunterstützung für die Erkennung gespeicherter Prozeduren. Außerdem bieten sie `CallableStatement`-Unterstützung für individuelle Java-Anwendungen. Weitere Informationen zu Treibern finden Sie unter [Herstellen von Verbindungen mit Amazon-Redshift-Clustern mithilfe von SQL-Client-Tools](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html) im *Amazon-Redshift-Verwaltungshandbuch*.
Die folgenden Beispiele zeigen, wie Sie unterschiedliche API-Operationen des JDBC-Treibers für Aufrufe gespeicherter Prozeduren verwenden können.
```
void statement_example(Connection conn) throws SQLException {
statement.execute("CALL sp_statement_example(1)");
}
void prepared_statement_example(Connection conn) throws SQLException {
String sql = "CALL sp_prepared_statement_example(42, 84)";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.execute();
}
void callable_statement_example(Connection conn) throws SQLException {
CallableStatement cstmt = conn.prepareCall("CALL sp_create_out_in(?,?)");
cstmt.registerOutParameter(1, java.sql.Types.INTEGER);
cstmt.setInt(2, 42);
cstmt.executeQuery();
Integer out_value = cstmt.getInt(1);
}
```
## Beispiele
Das folgende Beispiel ruft den Prozedurnamen auf `test_spl`.
```
call test_sp1(3,'book');
INFO: Table "tmp_tbl" does not exist and will be skipped
INFO: min_val = 3, f2 = book
```
Das folgende Beispiel ruft den Prozedurnamen auf `test_spl2`.
```
call test_sp2(2,'2019');
f2 | column2
---------------------+---------
2019+2019+2019+2019 | 2
(1 row)
```
# CANCEL
Bricht eine Datenbankabfrage ab, die zurzeit ausgeführt wird.
Der Befehl CANCEL erfordert die Prozess-ID oder Sitzungs-ID der ausgeführten Abfrage und zeigt eine Bestätigungsmeldung an, um zu bestätigen, dass die Abfrage abgebrochen wurde.
## Erforderliche Berechtigungen
Für CANCEL sind folgende Berechtigungen erforderlich:
+ Superuser bricht seine eigene Abfrage ab
+ Superuser bricht die Abfrage eines Benutzers ab
+ Benutzer mit der Berechtigung CANCEL bricht die Abfrage eines Benutzers ab
+ Benutzer storniert seine eigene Abfrage
## Syntax
```
CANCEL process_id [ 'message' ]
```
## Parameters
*process\$1id*
Um eine Abfrage abzubrechen, die in einem Amazon-Redshift-Cluster ausgeführt wird, verwenden Sie die `pid` (Prozess-ID) aus [STV\$1RECENTS](r_STV_RECENTS.md), die der Abfrage entspricht, die Sie abbrechen möchten.
Um eine Abfrage abzubrechen, die in einer Arbeitsgruppe in Amazon Redshift Serverless ausgeführt wird, verwenden Sie die `session_id` aus [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md), die der Abfrage entspricht, die Sie abbrechen möchten.
'*message*'
Eine optionale Bestätigungsmeldung, die angezeigt wird, wenn der Abbruch der Abfrage abgeschlossen ist. Wenn Sie keine Meldung angeben, zeigt Amazon Redshift die Standardmeldung als Verifizierung an. Sie müssen die Meldung in einfache Anführungszeichen setzen.
## Nutzungshinweise
Sie können eine Abfrage nicht durch Angabe einer *Abfrage-ID* abbrechen. Sie müssen die *Prozess-ID* (PID) oder die *Sitzungs-ID* der Abfrage angeben. Sie können nur Aufträge abbrechen, die zurzeit von Ihrem Benutzer ausgeführt werden. Superuser können alle Abfragen abbrechen.
Wenn Abfragen in mehreren Sitzungen dieselbe Tabelle sperren, können Sie die Funktion [PG\$1TERMINATE\$1BACKEND](PG_TERMINATE_BACKEND.md) verwenden, um eine der Sitzungen zu beenden. Dabei werden alle Transaktionen, die zurzeit in der beendeten Sitzung ausgeführt werden, gezwungen, alle Sperren aufzuheben und für die Transaktionen ein Rollback auszuführen. Führen Sie eine Abfrage für die Systemtabelle [STV\$1LOCKS](r_STV_LOCKS.md) aus, um die zurzeit vorhandenen Sperren anzuzeigen.
Im Anschluss an bestimmte interne Ereignisse startet Amazon Redshift möglicherweise eine aktive Sitzung neu und weist eine neue PID zu. Wenn die PID geändert wurde, erhalten Sie möglicherweise die folgende Fehlermeldung.
```
Session does not exist. The session PID might have changed. Check the stl_restarted_sessions system table for details.
```
Um die neue PID zu suchen, führen Sie eine Abfrage für die Systemtabelle [STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md) aus und filtern nach der Tabelle `oldpid`.
```
select oldpid, newpid from stl_restarted_sessions where oldpid = 1234;
```
## Beispiele
Um eine Abfrage abzubrechen, die aktuell in einem Amazon-Redshift-Cluster ausgeführt wird, rufen Sie zuerst die Prozess-ID für die Abfrage ab, die Sie abbrechen möchten. Geben Sie den folgenden Befehl ein, um den Prozess IDs für alle derzeit laufenden Abfragen zu ermitteln:
```
select pid, starttime, duration,
trim(user_name) as user,
trim (query) as querytxt
from stv_recents
where status = 'Running';
pid | starttime | duration | user | querytxt
-----+----------------------------+----------+----------+-----------------
802 | 2008-10-14 09:19:03.550885 | 132 | dwuser | select
venuename from venue where venuestate='FL', where venuecity not in
('Miami' , 'Orlando');
834 | 2008-10-14 08:33:49.473585 | 1250414 | dwuser | select *
from listing;
964 | 2008-10-14 08:30:43.290527 | 326179 | dwuser | select
sellerid from sales where qtysold in (8, 10);
```
Überprüfen Sie den Text der Abfrage, um festzustellen, welche Prozess-ID (POD) der Abfrage entspricht, die Sie abbrechen möchten.
Geben Sie den folgenden Befehl ein, um PID 802 zu verwenden und diese Abfrage abzubrechen:
```
cancel 802;
```
Die Sitzung, in der die Abfrage ausgeführt wurde, zeigt die folgende Meldung an:
```
ERROR: Query (168) cancelled on user's request
```
`168` ist die Abfrage-ID (nicht die Prozess-ID, die für den Abbruch der Abfrage verwendet wurde).
Alternativ können Sie eine benutzerdefinierte Bestätigungsmeldung angeben, die statt der Standardmeldung angezeigt wird. Um eine benutzerdefinierte Meldung anzugeben, setzen Sie die Meldung am Ende des Befehls CANCEL (ABBRECHEN) in Anführungszeichen:
```
cancel 802 'Long-running query';
```
Die Sitzung, in der die Abfrage ausgeführt wurde, zeigt die folgende Meldung an:
```
ERROR: Long-running query
```
# CLOSE
(Optional) Schließt alle freien Ressourcen, die mit einem offenen Cursor verbunden sind. [COMMIT](r_COMMIT.md), [END](r_END.md) und [ROLLBACK](r_ROLLBACK.md) schließen den Cursor automatisch, so dass es nicht erforderlich ist, den CLOSE-Befehl zu verwenden, um den Cursor explizit zu schließen.
Weitere Informationen finden Sie unter [DECLARE](declare.md), [FETCH](fetch.md).
## Syntax
```
CLOSE cursor
```
## Parameters
*cursor*
Der Name des Cursors, der geschlossen werden soll.
## Beispiel für CLOSE
Mit den folgenden Befehlen werden der Cursor geschlossen und ein Commit ausgeführt, wodurch die Transaktion beendet wird:
```
close movie_cursor;
commit;
```
# COMMENT
Erstellt oder ändert einen Kommentar zu einem Datenbankobjekt.
## Syntax
```
COMMENT ON
{
TABLE object_name |
COLUMN object_name.column_name |
CONSTRAINT constraint_name ON table_name |
DATABASE object_name |
VIEW object_name
}
IS 'text' | NULL
```
## Parameters
*object\$1name*
Der Name des Datenbankobjekts, das kommentiert wird. Sie können den folgenden Objekten Kommentare hinzufügen:
+ TABLE
+ COLUMN (akzeptiert auch *column\$1name*).
+ CONSTRAINT (akzeptiert auch *constraint\$1name* und *table\$1name*).
+ DATABASE
+ VIEW
+ SCHEMA
IS '*text*' \$1 NULL
Der Kommentartext, den Sie für das angegebene Objekt hinzufügen oder ersetzen möchten. Die *Text*-Zeichenfolge hat den Datentyp TEXT. Sie müssen den Kommentar in einfache Anführungszeichen einschließen. Setzen Sie den Wert auf NULL, um den Kommentartext zu entfernen.
*column\$1name*
Der Name der Spalte, die kommentiert wird. Parameter von COLUMN. Folgt einer Tabelle, die in angegeben ist `object_name`.
*constraint\$1name*
Der Name der Einschränkung, die kommentiert wird. Parameter von CONSTRAINT.
*table\$1name*
Der Name einer Tabelle, die die Einschränkung enthält. Parameter von CONSTRAINT.
## Nutzungshinweise
Sie müssen der Besitzer eines Datenbankobjekts sein, um einen Kommentar hinzufügen oder aktualisieren zu können.
Kommentare zu Datenbanken können nur auf die aktuelle Datenbank angewendet werden. Es wird eine Warnmeldung angezeigt, wenn Sie versuchen, eine andere Datenbank zu kommentieren. Dieselbe Warnung wird für Kommentare zu Datenbanken angezeigt, die nicht vorhanden sind.
Kommentare zu externen Tabellen, externen Spalten und Spalten von spätbindenden Ansichten werden nicht unterstützt.
## Beispiele
Im folgenden Beispiel wird der SALES-Tabelle ein neuer Kommentar hinzugefügt.
```
COMMENT ON TABLE sales IS 'This table stores tickets sales data';
```
Im folgenden Beispiel wird der Kommentar zur SALES-Tabelle angezeigt.
```
select obj_description('public.sales'::regclass);
obj_description
-------------------------------------
This table stores tickets sales data
```
Im folgenden Beispiel wird aus der SALES-Tabelle ein Kommentar entfernt.
```
COMMENT ON TABLE sales IS NULL;
```
Im folgenden Beispiel wird der EVENTID-Spalte der SALES-Tabelle ein neuer Kommentar hinzugefügt.
```
COMMENT ON COLUMN sales.eventid IS 'Foreign-key reference to the EVENT table.';
```
Im folgenden Beispiel wird der Kommentar zur EVENTID-Spalte (Spalte 5) der SALES-Tabelle angezeigt.
```
select col_description( 'public.sales'::regclass, 5::integer );
col_description
-----------------------------------------
Foreign-key reference to the EVENT table.
```
Im folgenden Beispiel wird der Tabelle EVENT ein beschreibender Kommentar hinzugefügt.
```
comment on table event is 'Contains listings of individual events.';
```
Zum Anzeigen von Kommentaren führen Sie eine Abfrage für den PG\$1DESCRIPTION-Systemkatalog aus. Das folgende Beispiel gibt die Beschreibung für die EVENT-Tabelle zurück.
```
select * from pg_catalog.pg_description
where objoid =
(select oid from pg_class where relname = 'event'
and relnamespace =
(select oid from pg_catalog.pg_namespace where nspname = 'public') );
objoid | classoid | objsubid | description
-------+----------+----------+----------------------------------------
116658 | 1259 | 0 | Contains listings of individual events.
```
# COMMIT
Führt einen Commit der aktuellen Transaktion an die Datenbank aus. Durch diesen Befehl werden die Datenbankupdates durch die Transaktion permanent.
## Syntax
```
COMMIT [ WORK | TRANSACTION ]
```
## Parameters
WORK
Optionales Schlüsselwort. Dieses Schlüsselwort wird in einer gespeicherten Prozedur nicht unterstützt.
TRANSACTION
Optionales Schlüsselwort. WORK und TRANSACTION sind Synonyme. Beide werden in einer gespeicherten Prozedur nicht unterstützt.
Informationen zur Verwendung von COMMIT innerhalb einer gespeicherten Prozedur finden Sie unter [Verwalten von Transaktionen](stored-procedure-transaction-management.md).
## Beispiele
In jedem der folgenden Beispiele wird ein Commit der aktuellen Transaktion an die Datenbank ausgeführt:
```
commit;
```
```
commit work;
```
```
commit transaction;
```
# COPY
| |
| --- |
| Die clientseitige Verschlüsselung für die Befehle COPY und UNLOAD steht Neukunden ab dem 30. April 2025 nicht mehr zur Verfügung. Wenn Sie in den 12 Monaten vor dem 30. April 2025 die clientseitige Verschlüsselung für die Befehle COPY und UNLOAD verwendet haben, können Sie die clientseitige Verschlüsselung für die Befehle COPY oder UNLOAD bis zum 30. April 2026 weiter verwenden. Nach dem 30. April 2026 können Sie die clientseitige Verschlüsselung für COPY und UNLOAD nicht mehr verwenden. Wir empfehlen, so schnell wie möglich zur serverseitigen Verschlüsselung für COPY und UNLOAD zu wechseln. Wenn Sie die serverseitige Verschlüsselung für COPY und UNLOAD bereits verwenden, ändert sich nichts und Sie können sie weiterhin verwenden, ohne Ihre Abfragen zu ändern. Weitere Informationen zur Verschlüsselung für COPY und UNLOAD finden Sie unten im Abschnitt zum Parameter ENCRYPTED. |
Lädt Daten aus Datendateien oder aus einer Amazon-DynamoDB-Tabelle in eine Tabelle. Die Dateien können sich in einem Amazon-Simple-Storage-Service(Amazon S3)-Bucket, einem Amazon-EMR-Cluster oder auf einem Remote-Host befinden, auf den über eine Secure-Shell(SSH)-Verbindung zugegriffen wird.
**Anmerkung**
Externe Tabellen von Amazon Redshift Spectrum sind schreibgeschützt. Sie können keinen COPY-Vorgang zu einer externen Tabelle ausführen.
Der COPY-Befehl fügt die Eingabedaten als zusätzliche Zeilen an die Tabelle an.
Die maximale Größe einer einzelnen Eingabezeile aus einer beliebigen Quelle beträgt 4 MB.
**Topics**
+ [Erforderliche Berechtigungen](#r_COPY-permissions)
+ [COPY-Syntax](#r_COPY-syntax)
+ [Erforderliche Parameter](#r_COPY-syntax-required-parameters)
+ [Optionale Parameter](#r_COPY-syntax-overview-optional-parameters)
+ [Nutzungshinweise und zusätzliche Ressourcen für den Befehl COPY](#r_COPY-using-the-copy-command)
+ [Befehlsbeispiele](#r_COPY-using-the-copy-command-examples)
+ [COPY JOB](r_COPY-JOB.md)
+ [Mit SCHABLONE KOPIEREN](r_COPY-WITH-TEMPLATE.md)
+ [COPY-Parameterreferenz](r_COPY-parameters.md)
+ [Nutzungshinweise](r_COPY_usage_notes.md)
+ [Beispiele für COPY](r_COPY_command_examples.md)
## Erforderliche Berechtigungen
Um den COPY-Befehl verwenden zu können, benötigen Sie das [INSERT](r_GRANT.md#grant-insert)-Recht für die Amazon-Redshift-Tabelle.
## COPY-Syntax
```
COPY table-name
[ column-list ]
FROM data_source
authorization
[ [ FORMAT ] [ AS ] data_format ]
[ parameter [ argument ] [, ... ] ]
```
Sie können COPY-Operationen mit nur drei Parametern ausführen: Tabellenname, Datenquelle und Autorisierung für den Zugriff auf die Daten.
Amazon Redshift erweitert die Funktionalität des COPY-Befehls, damit Sie Daten in verschiedenen Datenformaten aus mehreren Datenquellen laden, den Zugriff auf das Laden von Daten steuern, Datentransformierungen verwalten und die Ladeoperation verwalten können.
In den folgenden Abschnitten werden die erforderlichen Parameter für den COPY-Befehl vorgestellt und die optionalen Parameter nach Funktion gruppiert. Dazu werden die einzelnen Parameter beschrieben und es wird erläutert, wie die verschiedenen Optionen zusammenwirken. Sie können auch anhand der alphabetischen Liste der Parameter direkt zur Parameterbeschreibung wechseln.
## Erforderliche Parameter
Der COPY-Befehl erfordert drei Elemente:
+ [Table Name](#r_COPY-syntax-overview-table-name)
+ [Data Source](#r_COPY-syntax-overview-data-source)
+ [Authorization](#r_COPY-syntax-overview-credentials)
Der einfachste COPY-Befehl verwendet das folgende Format.
```
COPY table-name
FROM data-source
authorization;
```
Im folgenden Beispiel wird eine Tabelle namens CATDEMO erstellt. Anschließend wird die Tabelle mit Stichprobendaten aus einer Datendatei in Amazon S3 namens geladen `category_pipe.txt`.
```
create table catdemo(catid smallint, catgroup varchar(10), catname varchar(10), catdesc varchar(50));
```
Im folgenden Beispiel ist die Datenquelle für den COPY-Befehl eine Datendatei namens `category_pipe.txt` im Ordner `tickit` eines Amazon-S3-Buckets namens `redshift-downloads`. Der COPY-Befehl ist autorisiert, über eine AWS Identity and Access Management (IAM-) Rolle auf den Amazon S3 S3-Bucket zuzugreifen. Wenn Ihr Cluster bereits eine IAM-Rolle mit Berechtigung für den Zugriff auf Amazon S3 besitzt, können Sie den Amazon-Ressourcennamen (ARN) Ihrer Rolle im folgenden COPY-Befehl einsetzen und diesen ausführen.
```
copy catdemo
from 's3://redshift-downloads/tickit/category_pipe.txt'
iam_role 'arn:aws:iam:::role/'
region 'us-east-1';
```
Vollständige Anweisungen zur Verwendung von COPY-Befehlen zum Laden von Beispieldaten, einschließlich Anweisungen zum Laden von Daten aus anderen AWS Regionen, finden Sie unter [Load Sample Data from Amazon S3](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) im Amazon Redshift Getting Started Guide.
*table-name*
Der Name der Zieltabelle für den COPY-Befehl. Die Tabelle muss in der Datenbank bereits vorhanden sein. Die Tabelle kann temporär oder persistent sein. Der COPY-Befehl fügt die neuen Eingabedaten den vorhandenen Zeilen in der Tabelle an.
FROM *data-source*
Der Speicherort der Quelldaten, die in die Zieltabelle geladen werden sollen. Bei manchen Datenquellen kann eine Manifestdatei angegeben werden.
Das am häufigsten verwendete Daten-Repository sind Amazon-S3-Buckets. Außerdem können Sie Daten aus Datendateien laden, die sich in einem Amazon-EMR-Cluster, einer Amazon-EC2-Instance oder auf einem Remote-Host befinden, auf den Ihr Cluster über eine SSH-Verbindung zugreifen kann. Sie können Daten auch direkt aus einer DynamoDB-Tabelle laden.
+ [COPY aus Amazon S3](copy-parameters-data-source-s3.md)
+ [COPY aus Amazon EMR](copy-parameters-data-source-emr.md)
+ [COPY von Remote-Hosts (SSH)](copy-parameters-data-source-ssh.md)
+ [COPY aus Amazon DynamoDB](copy-parameters-data-source-dynamodb.md)
Autorisierung
Eine Klausel, die die Methode angibt, die Ihr Cluster für die Authentifizierung und Autorisierung für den Zugriff auf andere AWS Ressourcen verwendet. Der COPY-Befehl benötigt eine Autorisierung, um auf Daten in einer anderen AWS Ressource zuzugreifen, einschließlich in Amazon S3, Amazon EMR, Amazon DynamoDB und Amazon EC2. Sie können diese Autorisierung bereitstellen, indem Sie eine IAM-Rolle referenzieren, die Ihrem Cluster angefügt ist, oder indem Sie die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel für einen IAM-Benutzer bereitstellen.
+ [Autorisierungsparameter](copy-parameters-authorization.md)
+ [Rollenbasierte Zugriffskontrolle](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [Schlüsselbasierte Zugriffssteuerung](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
## Optionale Parameter
Sie können optional angeben, wie COPY den Spalten in der Zieltabelle Felddaten zuweist, Quelldatenattribute definieren, damit der COPY-Befehl die Quelldaten korrekt lesen und analysieren kann, und festlegen, welche Operation der COPY-Befehl während des Ladevorgangs ausführt.
+ [Optionen für das Mapping von Spalten](copy-parameters-column-mapping.md)
+ [Datenformatparameter](#r_COPY-syntax-overview-data-format)
+ [Datenkonvertierungsparameter](#r_COPY-syntax-overview-data-conversion)
+ [Datenladeoperationen](#r_COPY-syntax-overview-data-load)
### Mapping von Spalten
Standardmäßig fügt COPY Feldwerte in derselben Reihenfolge in die Spalten der Zieltabelle ein, die die Felder in den Datendateien haben. Wenn die standardmäßige Spaltenreihenfolge nicht funktioniert, können Sie eine Spaltenliste angeben oder JSONPath Ausdrücke verwenden, um Quelldatenfelder den Zielspalten zuzuordnen.
+ [Column List](copy-parameters-column-mapping.md#copy-column-list)
+ [JSONPaths File](copy-parameters-column-mapping.md#copy-column-mapping-jsonpaths)
### Datenformatparameter
Sie können Daten aus Textdateien in einem Format mit fester Breite, in einem Format mit Trennzeichen, in einem durch Komma getrennten Format (CSV) oder im JSON-Format laden. Sie können Daten auch aus Avro-Dateien laden.
Standardmäßig geht der COPY-Befehl davon aus, dass sich die Quelldaten in UTF-8-Textdateien mit Trennzeichen befinden. Das Standardtrennzeichen ist der senkrechte Strich (\$1). Wenn sich die Quelldaten in einem anderen Format befinden, verwenden Sie die folgenden Parameter, um das Datenformat anzugeben.
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [PARQUET](copy-parameters-data-format.md#copy-parquet)
+ [ORC](copy-parameters-data-format.md#copy-orc)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
### Datenkonvertierungsparameter
Wenn COPY die Tabelle lädt, versucht der Befehl implizit, die Zeichenfolgen in den Quelldaten in den Datentyp der Zielspalte zu konvertieren. Wenn Sie eine Konvertierung angeben müssen, die sich vom Standardverhalten unterscheidet, oder wenn die Standardkonvertierung zu Fehlern führt, können Sie Datenkonvertierungen verwalten, indem Sie die folgenden Parameter angeben.
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
### Datenladeoperationen
Verwalten Sie das Standardverhalten der Ladeoperation, um Fehler zu beheben oder die Ladezeiten zu reduzieren, indem Sie die folgenden Parameter angeben.
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
## Nutzungshinweise und zusätzliche Ressourcen für den Befehl COPY
Weitere Informationen zur Verwendung des COPY-Befehls finden Sie in den folgenden Themen:
+ [Nutzungshinweise](r_COPY_usage_notes.md)
+ [Tutorial: So laden Sie Daten aus Amazon S3](tutorial-loading-data.md)
+ [Bewährte Methoden für Amazon Redshift zum Laden von Daten](c_loading-data-best-practices.md)
+ [Laden von Tabellen mit dem Befehl COPY](t_Loading_tables_with_the_COPY_command.md)
+ [So laden Sie Daten aus Amazon S3](t_Loading-data-from-S3.md)
+ [So laden Sie Daten aus Amazon EMR:](loading-data-from-emr.md)
+ [Laden von Daten aus Remote-Hosts](loading-data-from-remote-hosts.md)
+ [Laden von Daten aus einer Amazon-DynamoDB-Tabelle](t_Loading-data-from-dynamodb.md)
+ [Fehlerbehebung bei Datenladevorgängen](t_Troubleshooting_load_errors.md)
## Befehlsbeispiele
Weitere Beispiele, die zeigen, wie aus verschiedenen Quellen, in unterschiedlichen Formaten und mit unterschiedlichen COPY-Optionen KOPIERT wird, finden Sie unter [Beispiele für COPY](r_COPY_command_examples.md).
# COPY JOB
Weitere Informationen zur Verwendung dieses Befehls finden Sie unter [Erstellen einer S3-Ereignisintegration, um Dateien automatisch aus Amazon-S3-Buckets zu kopieren](loading-data-copy-job.md).
Verwaltet COPY-Befehle, die Daten in eine Tabelle laden. Der Befehl COPY JOB ist eine Erweiterung des COPY-Befehls, der das Laden von Daten aus Amazon-S3-Buckets automatisiert. Wenn Sie einen COPY JOB erstellen, erkennt es Amazon Redshift, wenn neue Amazon-S3-Dateien in einem bestimmten Pfad erstellt werden, und lädt diese dann automatisch, ohne dass Sie eine Maßnahme ergreifen müssen. Beim Laden der Daten werden dieselben Parameter wie im ursprünglichen COPY-Befehl verwendet. Amazon Redshift verfolgt die geladenen Dateien (basierend auf dem Dateinamen), um sicherzustellen, dass sie nur einmal geladen werden.
**Anmerkung**
Informationen zum COPY-Befehl, seiner Syntax, seinen Parametern und Berechtigungen, finden Sie unter [COPY](r_COPY.md).
## Erforderliche Berechtigung
Um den Befehl COPY JOB verwenden zu können, benötigen Sie zusätzlich zu allen für die Verwendung von COPY erforderlichen Berechtigungen eine der folgenden Berechtigungen:
+ Superuser
+ Alle der folgenden Berechtigungen:
+ Die relevante bereichsbezogene Berechtigung CREATE, ALTER oder DROP für COPY JOBS in der Datenbank, zu der Sie COPY ausführen möchten.
+ Die Berechtigung USAGE für das Schema, zu der Sie COPY ausführen möchten, oder die bereichsbezogene Berechtigung USAGE für Schemas in der Datenbank, zu der Sie COPY ausführen möchten.
+ Die Berechtigung INSERT für die Tabelle, zu der Sie COPY ausführen möchten, oder die bereichsbezogene Berechtigung INSERT für Tabellen im Schema oder in der Datenbank, zu der Sie COPY ausführen möchten.
Die mit dem COPY-Befehl angegebene IAM-Rolle muss über die Berechtigung zum Zugriff auf die zu ladenden Daten verfügen. Weitere Informationen finden Sie unter [IAM-Berechtigungen für COPY, UNLOAD und CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
## Syntax
Erstellen eines Kopierauftrags. Die Parameter des COPY-Befehls werden zusammen mit dem Kopierauftrag gespeichert.
Sie können COPY JOB CREATE nicht innerhalb eines Transaktionsblocks ausführen.
```
COPY copy-command JOB CREATE job-name
[AUTO ON | OFF]
```
Ändern der Konfiguration eines Kopierauftrags.
```
COPY JOB ALTER job-name
[AUTO ON | OFF]
```
Ausführen eines Kopierauftrags. Es werden die gespeicherten Parameter des COPY-Befehls verwendet.
```
COPY JOB RUN job-name
```
Auflisten aller Kopieraufträge.
```
COPY JOB LIST
```
Anzeigen der Details zu dem Kopierauftrag.
```
COPY JOB SHOW job-name
```
Löschen eines Kopierauftrags.
Sie können COPY JOB DROP nicht innerhalb eines Transaktionsblocks ausführen.
```
COPY JOB DROP job-name
```
## Parameters
*copy-command*
Ein COPY-Befehl, der Daten aus Amazon S3 in Amazon Redshift lädt. Die Klausel enthält COPY-Parameter, die den Amazon-S3-Bucket, die Zieltabelle, die IAM-Rolle und andere Parameter definieren, die beim Laden von Daten verwendet werden. Es werden alle Parameter eines COPY-Befehls zum Laden von Amazon-S3-Daten unterstützt, mit folgenden Ausnahmen:
+ Der COPY JOB nimmt keine bereits vorhandenen Dateien in dem Ordner auf, auf den der COPY-Befehl verweist. Nur Dateien, die nach dem Erstellungszeitstempel von COPY JOB erstellt wurden, werden aufgenommen.
+ Sie können einen COPY-Befehl nicht mit den Optionen MAXERROR oder IGNOREALLERRORS angeben.
+ Sie können keine Manifestdatei angeben. COPY JOB erfordert einen festgelegten Amazon-S3-Speicherort, um diesen auf neu erstellte Dateien überwachen zu können.
+ Sie können einen COPY-Befehl nicht mit Autorisierungstypen wie Zugriffsschlüsseln und geheimen Schlüsseln angeben. Es werden nur COPY-Befehle unterstützt, die den Parameter `IAM_ROLE` für die Autorisierung verwenden. Weitere Informationen finden Sie unter [Autorisierungsparameter](copy-parameters-authorization.md).
+ Die dem Cluster zugeordnete standardmäßige IAM-Rolle wird von COPY JOB nicht unterstützt. Sie müssen die `IAM_ROLE` im COPY-Befehl angeben.
Weitere Informationen finden Sie unter [COPY aus Amazon S3](copy-parameters-data-source-s3.md).
*job-name*
Der Name des Auftrags, der verwendet wird, um auf den COPY-Auftrag zu verweisen. Der *job-name* darf keinen Bindestrich (‐) enthalten.
[AUTO ON / OFF]
Klausel, die angibt, ob Amazon-S3-Daten automatisch in Amazon-Redshift-Tabellen geladen werden.
+ Bei Angabe von `ON` überwacht Amazon Redshift den Amazon-S3-Quellpfad auf neu erstellte Dateien. Falls welche gefunden werden, wird ein COPY-Befehl mit den COPY-Parametern aus der Auftragsdefinition ausgeführt. Dies ist die Standardeinstellung.
+ Bei Angabe von `OFF` führt Amazon Redshift den COPY JOB nicht automatisch aus.
## Nutzungshinweise
Die Optionen des COPY-Befehls werden erst zur Laufzeit validiert. Eine ungültige `IAM_ROLE` oder eine Amazon-S3-Datenquelle führt beispielsweise zu Laufzeitfehlern, wenn COPY JOB gestartet wird.
Wenn der Cluster angehalten ist, werden COPY JOBS nicht ausgeführt.
Informationen zur Abfrage von geladenen COPY-Befehlsdateien sowie zu Ladefehlern finden Sie unter [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md), [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md), [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md). Weitere Informationen finden Sie unter [Überprüfung, ob die Daten korrekt geladen wurden](verifying-that-data-loaded-correctly.md).
COPY JOBS werden auf Zero-ETL-Datenbanken nicht unterstützt, da sie im schreibgeschützten Modus arbeiten.
## Beispiele
Im folgenden Beispiel wird demonstriert, wie Sie einen COPY JOB erstellen, um Daten aus einem Amazon-S3-Bucket zu laden.
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
JOB CREATE my_copy_job_name
AUTO ON;
```
# Mit SCHABLONE KOPIEREN
Sie können Redshift-Vorlagen mit COPY-Befehlen verwenden, um die Befehlssyntax zu vereinfachen und die Konsistenz zwischen Datenladevorgängen sicherzustellen. Anstatt dieselben Formatierungsparameter wiederholt anzugeben, definieren Sie sie einmal in einer Vorlage und verweisen in Ihren COPY-Befehlen auf die Vorlage. Wenn Sie eine Vorlage verwenden, kombiniert der Befehl COPY die Parameter aus der Vorlage mit allen direkt im Befehl angegebenen Parametern. Wenn derselbe Parameter sowohl in der Vorlage als auch im Befehl vorkommt, hat der Befehlsparameter Vorrang. Weitere Informationen finden Sie unter [VORLAGE ERSTELLEN](r_CREATE_TEMPLATE.md).
Vorlagen für den Befehl COPY können wie folgt erstellt werden:
+ [Datenformatparameter](copy-parameters-data-format.md)
+ [Dateikomprimierungsparameter](copy-parameters-file-compression.md)
+ [Datenkonvertierungsparameter](copy-parameters-data-conversion.md)
+ [Datenladeoperationen](copy-parameters-data-load.md)
Eine vollständige Liste der unterstützten Parameter finden Sie unter [COPY](r_COPY.md) Befehl.
## Erforderliche Berechtigung
Um eine Vorlage in einem COPY-Befehl zu verwenden, benötigen Sie:
+ Alle erforderlichen Berechtigungen zur Ausführung des COPY-Befehls (siehe[Erforderliche Berechtigungen](r_COPY.md#r_COPY-permissions))
+ Eine der folgenden Vorlagenberechtigungen:
+ Superuser-Rechte
+ USAGE-Privileg für die Vorlage und USAGE-Privileg für das Schema, das die Vorlage enthält
## Syntax
```
COPY target_table FROM 's3://...'
authorization
[ option, ...]
USING TEMPLATE [database_name.][schema_name.]template_name;
```
## Parameters
*database\$1name*
(Optional) Der Name der Datenbank, in der die Vorlage existiert. Wenn nicht angegeben, wird die aktuelle Datenbank verwendet.
*schema\$1name*
(Optional) Der Name des Schemas, in dem die Vorlage existiert. Wenn nicht angegeben, wird im aktuellen Suchpfad nach der Vorlage gesucht.
*Vorlagenname*
Der Name der Vorlage, die in COPY verwendet werden soll.
## Nutzungshinweise
+ Befehlsspezifische Parameter (Quelle, Ziel, Autorisierung) müssen weiterhin im COPY-Befehl angegeben werden.
+ Vorlagen können keine Manifestdateispezifikationen für COPY-Befehle enthalten.
## Beispiele
Die folgenden Beispiele zeigen, wie eine Vorlage erstellt und in COPY-Befehlen verwendet wird:
```
CREATE TEMPLATE public.test_template FOR COPY AS
CSV DELIMITER '|' IGNOREHEADER 1 MAXERROR 100;
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
USING TEMPLATE public.test_template;
```
Wenn ein Parameter sowohl in der Vorlage als auch im Befehl vorhanden ist, hat der Befehlsparameter Vorrang. In diesem Beispiel wird das Kommatrennzeichen () aus dem Befehl anstelle des Pipe-Trennzeichens (`,`) aus der Vorlage verwendet, wenn die Vorlage `public.test_template` enthält, `DELIMITER '|'` aber der COPY-Befehl dies angibt`DELIMITER ','`. `|`
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
DELIMITER ','
USING TEMPLATE public.test_template;
```
# COPY-Parameterreferenz
COPY hat viele Parameter, die in vielen Situationen verwendet werden können. Es werden jedoch nicht alle Parameter in jeder Situation unterstützt. Beispielsweise gibt es eine begrenzte Anzahl unterstützter Parameter, um aus ORC- oder PARQUET-Dateien zu laden. Weitere Informationen finden Sie unter [COPY aus spaltenbasierten Datenformaten](copy-usage_notes-copy-from-columnar.md).
**Topics**
+ [Datenquellen](copy-parameters-data-source.md)
+ [Autorisierungsparameter](copy-parameters-authorization.md)
+ [Optionen für das Mapping von Spalten](copy-parameters-column-mapping.md)
+ [Datenformatparameter](copy-parameters-data-format.md)
+ [Dateikomprimierungsparameter](copy-parameters-file-compression.md)
+ [Datenkonvertierungsparameter](copy-parameters-data-conversion.md)
+ [Datenladeoperationen](copy-parameters-data-load.md)
+ [Alphabetische Liste der Parameter](r_COPY-alphabetical-parm-list.md)
# Datenquellen
Sie können Daten aus Textdateien in einem Amazon-S3-Bucket, in einem Amazon-EMR-Cluster oder auf einem Remote-Host laden, auf den Ihr Cluster über eine SSH-Verbindung zugreifen kann. Sie können Daten auch direkt aus einer DynamoDB-Tabelle laden.
Die maximale Größe einer einzelnen Eingabezeile aus einer beliebigen Quelle beträgt 4 MB.
Um Daten aus einer Tabelle in einen Satz von Dateien in einem Amazon-S3-Bucket zu exportieren, verwenden Sie den Befehl [UNLOAD](r_UNLOAD.md).
**Topics**
+ [COPY aus Amazon S3](copy-parameters-data-source-s3.md)
+ [COPY aus Amazon EMR](copy-parameters-data-source-emr.md)
+ [COPY von Remote-Hosts (SSH)](copy-parameters-data-source-ssh.md)
+ [COPY aus Amazon DynamoDB](copy-parameters-data-source-dynamodb.md)
# COPY aus Amazon S3
Um Daten aus Dateien zu laden, die sich in einzelnen oder mehreren S3 Buckets befinden, verwenden Sie die FROM-Klausel. Diese Klausel gibt an, wie COPY die Dateien in Amazon S3 sucht. Sie können den Objektpfad zu den Datendateien als Teil der FROM-Klausel bereitstellen oder den Speicherort einer Manifestdatei angeben, die eine Liste von Amazon-S3-Objektpfaden enthält. COPY aus Amazon S3 verwendet eine HTTPS-Verbindung. Stellen Sie sicher, dass die S3-IP-Bereiche zu Ihrer Zulassungsliste hinzugefügt werden. Weitere Informationen zu den erforderlichen S3-IP-Bereichen finden Sie unter [Netzwerkisolierung](https://docs.aws.amazon.com//redshift/latest/mgmt/security-network-isolation.html#network-isolation).
**Wichtig**
Wenn sich die Amazon S3 S3-Buckets, die die Datendateien enthalten, nicht in derselben AWS Region wie Ihr Cluster befinden, müssen Sie den [REGION](#copy-region) Parameter verwenden, um die Region anzugeben, in der sich die Daten befinden.
**Topics**
+ [Syntax](#copy-parameters-data-source-s3-syntax)
+ [Beispiele](#copy-parameters-data-source-s3-examples)
+ [Optionale Parameter](#copy-parameters-data-source-s3-optional-parms)
+ [Nicht unterstützte Parameter](#copy-parameters-data-source-s3-unsupported-parms)
## Syntax
```
FROM { 's3://objectpath' | 's3://manifest_file' }
authorization
| MANIFEST
| ENCRYPTED
| REGION [AS] 'aws-region'
| optional-parameters
```
## Beispiele
Im folgenden Beispiel wird ein Objektpfad verwendet, um Daten aus Amazon S3 zu laden.
```
copy customer
from 's3://amzn-s3-demo-bucket/customer'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Im folgenden Beispiel wird eine Manifestdatei verwendet, um Daten aus Amazon S3 zu laden.
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest;
```
### Parameters
FROM
Die Quelle der Daten, die geladen werden sollen. Weitere Informationen zur Kodierung der Amazon-S3-Datei finden Sie unter [Datenkonvertierungsparameter](copy-parameters-data-conversion.md).
's3://*copy\$1from\$1s3\$1objectpath*'
Gibt den Pfad zu den Amazon-S3-Objekten an, die die Daten enthalten, z. B. `'s3://amzn-s3-demo-bucket/custdata.txt'`. Der Parameter *s3://copy\$1from\$1s3\$1objectpath* kann eine einzelne Datei, einen Satz von Objekten oder Ordner mit denselben Schlüsselpräfixen referenzieren. Beispielsweise ist der Name `custdata.txt` ein Schlüsselpräfix, der sich auf eine Anzahl physischer Dateien bezieht: `custdata.txt`, `custdata.txt.1`, `custdata.txt.2`, `custdata.txt.bak` usw. Das Schlüsselpräfix kann auch eine Anzahl von Ordnern referenzieren. Beispielsweise bezieht sich `'s3://amzn-s3-demo-bucket/custfolder'` auf die Ordner `custfolder`, `custfolder_1`, `custfolder_2` usw. Wenn ein Schlüsselpräfix mehrere Ordner referenziert, werden alle Dateien in den Ordnern geladen. Wenn ein Schlüsselpräfix mit einer Datei und einem Ordner übereinstimmt, beispielsweise `custfolder.log`, versucht COPY, auch die Datei zu laden. Wenn ein Schlüsselpräfix dazu führen könnte, dass COPY versucht, nicht erwünschte Dateien zu laden, verwenden Sie eine Manifestdatei. Weitere Informationen finden Sie unter [copy_from_s3_manifest_file](#copy-manifest-file).
Wenn sich der S3-Bucket, der die Datendateien enthält, nicht in derselben AWS Region wie Ihr Cluster befindet, müssen Sie den [REGION](#copy-region) Parameter verwenden, um die Region anzugeben, in der sich die Daten befinden.
Weitere Informationen finden Sie unter [So laden Sie Daten aus Amazon S3](t_Loading-data-from-S3.md).
's3://*copy\$1from\$1s3\$1manifest\$1file*'
Gibt den Amazon-S3-Objektschlüssel für eine Manifestdatei an, die die Datendateien auflistet, die geladen werden sollen. Das Argument *'s3://*copy\$1from\$1s3\$1manifest\$1file'** muss explizit auf eine einzelne Datei verweisen, z. B. `'s3://amzn-s3-demo-bucket/manifest.txt'`. Es darf kein Schlüsselpräfix referenzieren.
Das Manifest ist eine Textdatei im JSON-Format, die die URL jeder Datei auflistet, die aus Amazon S3 geladen werden soll. Die URL enthält den Bucket-Namen und den vollständigen Objektpfad für die Datei. Die im Manifest angegebenen Dateien können sich in verschiedenen Buckets befinden, aber alle Buckets müssen sich in derselben AWS Region wie der Amazon Redshift Redshift-Cluster befinden. Wenn eine Datei zweimal aufgelistet wird, wird die Datei zweimal geladen. Im folgenden Beispiel wird der JSON-Code für ein Manifest gezeigt, das drei Dateien lädt.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket1/custdata.2","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/custdata.1","mandatory":false}
]
}
```
Die doppelten Anführungszeichen sind erforderlich. Es muss sich um normale Anführungszeichen (0x22) handeln. Es dürfen keine schrägen oder „smarten“ Anführungszeichen sein. Jeder Eintrag im Manifest kann optional ein `mandatory`-Flag enthalten. Wenn `mandatory` auf `true` gesetzt ist, wird COPY beendet, wenn der Befehl die Datei für diesen Eintrag nicht findet. Andernfalls wird COPY fortgesetzt. Der Standardwert für den `mandatory` beträgt `false`.
Beim Laden aus Datendateien im ORC- oder Parquet-Format ist ein `meta`-Feld erforderlich, wie im folgenden Beispiel gezeigt.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
Die Manifestdatei darf nicht verschlüsselt oder komprimiert sein, auch wenn die Optionen ENCRYPTED, GZIP, LZOP oder ZSTD angegeben BZIP2 sind. COPY gibt einen Fehler zurück, wenn die angegebene Manifestdatei nicht gefunden wird oder die Manifestdatei nicht korrekt formatiert ist.
Wenn ein Manifestdatei verwendet wird, muss der Parameter MANIFEST für den COPY-Befehl angegeben werden. Wenn der Parameter MANIFEST nicht angegeben ist, nimmt COPY an, dass die für FROM angegebene Datei eine Datendatei ist.
Weitere Informationen finden Sie unter [So laden Sie Daten aus Amazon S3](t_Loading-data-from-S3.md).
*Autorisierung*
Der COPY-Befehl benötigt eine Autorisierung für den Zugriff auf Daten in anderen AWS -Ressourcen, einschließlich Amazon S3, Amazon EMR, Amazon DynamoDB und Amazon EC2. Sie können diese Autorisierung gewähren, indem Sie auf eine AWS Identity and Access Management (IAM-) Rolle verweisen, die Ihrem Cluster zugeordnet ist (rollenbasierte Zugriffskontrolle), oder indem Sie die Zugangsdaten für einen Benutzer angeben (schlüsselbasierte Zugriffskontrolle). Um Sicherheit und Flexibilität zu verbessern, wird die Verwendung der IAM-rollenbasierten Zugriffssteuerung empfohlen. Weitere Informationen finden Sie unter [Autorisierungsparameter](copy-parameters-authorization.md).
MANIFEST
Gibt an, dass ein Manifest verwendet wird, um die Datendateien aufzulisten, die aus Amazon S3 geladen werden sollen. Wenn der Parameter MANIFEST verwendet wird, lädt COPY Daten aus den in dem Manifest aufgelisteten Dateien, das durch *'s3://copy\$1from\$1s3\$1manifest\$1file'* referenziert wird. Wenn die Manifestdatei nicht gefunden wird oder nicht korrekt formatiert ist, schlägt COPY fehl. Weitere Informationen finden Sie unter [Verwenden eines Manifests für die Angabe von Datendateien](loading-data-files-using-manifest.md).
ENCRYPTED
Eine Klausel, die angibt, dass die Eingabedateien in Amazon S3 mittels clientseitiger Verschlüsselung mit vom Kunden verwalteten Schlüsseln verschlüsselt sind. Weitere Informationen finden Sie unter [Laden verschlüsselter Datendateien aus Amazon S3](c_loading-encrypted-files.md). Geben Sie ENCRYPTED nicht an, wenn die Eingabedateien mittels serverseitiger Amazon S3-Verschlüsselung (SSE-KMS or SSE-S3) verschlüsselt sind. COPY liest serverseitig verschlüsselte Dateien automatisch.
Wenn Sie den Parameter ENCRYPTED angeben, müssen Sie auch den Parameter [MASTER_SYMMETRIC_KEY](#copy-master-symmetric-key) angeben oder den Wert für **master\$1symmetric\$1key** in die Zeichenfolge [Verwenden des Parameters CREDENTIALS](copy-parameters-authorization.md#copy-credentials) einfügen.
Wenn die verschlüsselten Dateien in komprimiertem Format vorliegen, fügen Sie den Parameter GZIP, LZOP oder ZSTD hinzu. BZIP2
Manifestdateien und JSONPaths Dateien dürfen nicht verschlüsselt werden, auch wenn die Option ENCRYPTED angegeben ist.
MASTER\$1SYMMETRIC\$1KEY '*root\$1key*'
Der symmetrische Root-Schlüssel, der für die Verschlüsselung von Datendateien in Amazon S3 verwendet wurde. Wenn MASTER\$1SYMMETRIC\$1KEY angegeben ist, muss auch der Parameter [ENCRYPTED](#copy-encrypted) angegeben werden. MASTER\$1SYMMETRIC\$1KEY kann nicht mit dem Parameter CREDENTIALS verwendet werden. Weitere Informationen finden Sie unter [Laden verschlüsselter Datendateien aus Amazon S3](c_loading-encrypted-files.md).
Wenn die verschlüsselten Dateien im komprimierten Format vorliegen, fügen Sie den Parameter GZIP, LZOP oder BZIP2 ZSTD hinzu.
REGION [AS] '*aws-region*'
Gibt die AWS Region an, in der sich die Quelldaten befinden. REGION ist für COPY aus einem Amazon-S3-Bucket oder einer DynamoDB-Tabelle erforderlich, wenn sich die AWS -Ressource, die die Daten enthält, nicht in derselben Region wie der Amazon-Redshift-Cluster befindet.
Der Wert für *aws\$1region* muss einer Region entsprechen, die in der Tabelle [Amazon-Redshift-Regionen und -Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#redshift_region) aufgeführt ist.
Wenn der Parameter REGION angegeben ist, müssen sich alle Ressourcen in der angegebenen Region befinden, einschließlich einer Manifestdatei oder mehrerer Amazon-S3-Buckets.
Für die Übertragung von Daten zwischen Regionen werden dem Amazon-S3-Bucket oder der DynamoDB-Tabelle, die die Daten enthält, zusätzliche Gebühren berechnet. Weitere Informationen zu den Preisen finden Sie unter **Ausgehende Datenübertragung von Amazon S3 in eine andere AWS Region** auf der [Amazon S3 S3-Preisseite](https://aws.amazon.com/s3/pricing/) und **Ausgehende Datenübertragung** auf der [Preisseite von Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Standardmäßig nimmt COPY an, dass sich die Daten in derselben Region wie der Amazon-Redshift-Cluster befinden.
## Optionale Parameter
Sie können für COPY aus Amazon S3 optional die folgenden Parameter angeben:
+ [Optionen für das Mapping von Spalten](copy-parameters-column-mapping.md)
+ [Datenformatparameter](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Datenkonvertierungsparameter](copy-parameters-data-conversion.md)
+ [Datenladeoperationen](copy-parameters-data-load.md)
## Nicht unterstützte Parameter
Die folgenden Parameter können Sie für COPY aus Amazon S3 nicht verwenden:
+ SSH
+ READRATIO
# COPY aus Amazon EMR
Sie können den COPY-Befehl verwenden, um Daten parallel aus einem Amazon-EMR-Cluster zu laden, das für das Schreiben von Textdateien zum Hadoop Distributed File System (HDFS) in Form von Dateien mit fester Breite, von durch Zeichen getrennten Dateien, von CSV-Dateien, von JSON-Dateien oder von Avro-Dateien konfiguriert wurde.
**Topics**
+ [Syntax](#copy-parameters-data-source-emr-syntax)
+ [Beispiel](#copy-parameters-data-source-emr-example)
+ [Parameters](#copy-parameters-data-source-emr-parameters)
+ [Unterstützte Parameter](#copy-parameters-data-source-emr-optional-parms)
+ [Nicht unterstützte Parameter](#copy-parameters-data-source-emr-unsupported-parms)
## Syntax
```
FROM 'emr://emr_cluster_id/hdfs_filepath'
authorization
[ optional_parameters ]
```
## Beispiel
Im folgenden Beispiel werden Daten aus einem Amazon-EMR-Cluster geladen.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Parameters
FROM
Die Quelle der Daten, die geladen werden sollen.
'emr://*emr\$1cluster\$1id*/*hdfs\$1file\$1path*'
Der eindeutige Bezeichner für den Amazon-EMR-Cluster und den HDFS-Dateipfad, der die Datendateien für den COPY-Befehl referenziert. Die HDFS-Datendateinamen dürfen nicht die Platzhalterzeichen Sternchen (\$1) und Fragezeichen (?) enthalten.
Der Amazon-EMR-Cluster muss weiter ausgeführt werden, bis die COPY-Operation abgeschlossen ist. Wenn eine der HDFS-Datendateien vor Abschluss der COPY-Operation geändert oder gelöscht wird, kann dies zu unerwarteten Ergebnissen führen. Es ist auch möglich, dass die COPY-Operation fehlschlägt.
Sie können die Platzhalterzeichen Sternchen (\$1) und Fragezeichen (?) als Teil des *hdfs\$1file\$1path*-Arguments verwenden, um mehrere zu ladende Dateien anzugeben. Beispielsweise identifiziert `'emr://j-SAMPLE2B500FC/myoutput/part*'` die Dateien `part-0000`, `part-0001` usw. Wenn der Dateipfad keine Platzhalterzeichen enthält, wird er als Zeichenfolgeliteral behandelt. Wenn Sie nur einen Ordnernamen angeben, versucht COPY, alle Dateien im Ordner zu laden.
Wenn Sie Platzhalterzeichen oder nur den Ordnernamen verwenden, müssen Sie überprüfen, ob unerwünschte Dateien geladen werden. Einige Prozesse schreiben beispielsweise eine Protokolldatei in den Ausgabeordner.
Weitere Informationen finden Sie unter [So laden Sie Daten aus Amazon EMR:](loading-data-from-emr.md).
*Autorisierung*
Der COPY-Befehl benötigt eine Autorisierung für den Zugriff auf Daten in anderen AWS -Ressourcen, einschließlich Amazon S3, Amazon EMR, Amazon DynamoDB und Amazon EC2. Sie können diese Autorisierung erteilen, indem Sie auf eine AWS Identity and Access Management (IAM-) Rolle verweisen, die Ihrem Cluster zugeordnet ist (rollenbasierte Zugriffskontrolle), oder indem Sie die Zugangsdaten für einen Benutzer angeben (schlüsselbasierte Zugriffskontrolle). Um Sicherheit und Flexibilität zu verbessern, wird die Verwendung der IAM-rollenbasierten Zugriffssteuerung empfohlen. Weitere Informationen finden Sie unter [Autorisierungsparameter](copy-parameters-authorization.md).
## Unterstützte Parameter
Sie können für COPY aus Amazon EMR optional die folgenden Parameter angeben:
+ [Optionen für das Mapping von Spalten](copy-parameters-column-mapping.md)
+ [Datenformatparameter](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Datenkonvertierungsparameter](copy-parameters-data-conversion.md)
+ [Datenladeoperationen](copy-parameters-data-load.md)
## Nicht unterstützte Parameter
Die folgenden Parameter können Sie für COPY aus Amazon EMR nicht verwenden:
+ ENCRYPTED
+ MANIFEST
+ REGION
+ READRATIO
+ SSH
# COPY von Remote-Hosts (SSH)
Sie können den Befehl COPY verwenden, um Daten parallel Daten aus einem oder mehreren Remote-Hosts wie Amazon-Elastic-Compute-Cloud(Amazon EC2)-Instances oder anderen Computern zu laden. COPY stellt über Secure Shell (SSH) eine Verbindung zu den Remote-Hosts her und führt Befehle auf den Remote-Hosts aus, um Textausgaben zu generieren. Beim Remote-Host kann es sich um eine EC2-Linux-Instance oder einen anderen Unix- oder Linux-Computer handeln, der für die Annahme von SSH-Verbindungen konfiguriert wurde. Amazon Redshift kann eine Verbindung zu mehreren Hosts herstellen und für jeden Host mehrere SSH-Verbindungen öffnen. Amazon Redshift sendet über jede Verbindung einen eindeutigen Befehl, um die Textausgabe an die Standardausgabe des Hosts zu generieren. Amazon Redshift liest diese dann wie eine Textdatei.
Verwenden Sie die FROM-Klausel, um den Amazon S3-Objektschlüssel für die Manifestdatei anzugeben, die die Informationen bereitstellt, die COPY zum Öffnen von SSH-Verbindungen und zum Ausführen der Remote-Befehle verwendet.
**Topics**
+ [Syntax](#copy-parameters-data-source-ssh-syntax)
+ [Beispiele](#copy-parameters-data-source-ssh-examples)
+ [Parameters](#copy-parameters-data-source-ssh-parameters)
+ [Optionale Parameter](#copy-parameters-data-source-ssh-optional-parms)
+ [Nicht unterstützte Parameter](#copy-parameters-data-source-ssh-unsupported-parms)
**Wichtig**
Wenn sich der S3 Bucket, der die Manifestdatei enthält, nicht in derselben AWS -Region wie der Cluster befindet, müssen Sie den Parameter REGION verwenden, um die Region anzugeben, in der sich der Bucket befindet.
## Syntax
```
FROM 's3://'ssh_manifest_file' }
authorization
SSH
| optional-parameters
```
## Beispiele
Im folgenden Beispiel wird eine Manifestdatei verwendet, um Daten über SSH aus einem Remote-Host zu laden.
```
copy sales
from 's3://amzn-s3-demo-bucket/ssh_manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
ssh;
```
## Parameters
FROM
Die Quelle der Daten, die geladen werden sollen.
's3://*copy\$1from\$1ssh\$1manifest\$1file*'
Der COPY-Befehl kann über SSH Verbindungen zu mehreren Hosts herstellen und für jeden Host mehrere SSH-Verbindungen erstellen. COPY führt über jede Hostverbindung einen Befehl aus und lädt anschließend die Ausgabe der Befehle parallel in die Tabelle. Das Argument *s3://copy\$1from\$1ssh\$1manifest\$1file* gibt den Amazon-S3-Objektschlüssel für die Manifestdatei an, die die Informationen bereitstellt, die COPY zum Öffnen von SSH-Verbindungen und zum Ausführen der Remote-Befehle verwendet.
Das Argument *s3://copy\$1from\$1ssh\$1manifest\$1file* muss explizit eine einzelne Datei referenzieren; es darf sich nicht um ein Schlüsselpräfix handeln. Im Folgenden sehen Sie ein Beispiel:
```
's3://amzn-s3-demo-bucket/ssh_manifest.txt'
```
Die Manifestdatei ist eine Textdatei im JSON-Format, die Amazon Redshift zum Herstellen der Verbindung zum Host verwendet. Die Manifestdatei gibt die Endpunkte des SSH-Hosts und die Befehle an, die auf den Hosts ausgeführt werden, um Daten an Amazon Redshift zurückzugeben. Optional können Sie den öffentlichen Schlüssel des Hosts, den Anmeldebenutzernamen und ein obligatorisches Flag für die einzelnen Einträge einschließen. Im folgenden Beispiel wird eine Manifestdatei gezeigt, die zwei SSH-Verbindungen erstellt:
```
{
"entries": [
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""},
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""}
]
}
```
Die Manifestdatei enthält für jede SSH-Verbindung jeweils ein `"entries"`-Konstrukt. Es kann mehrere Verbindungen zu einem einzelnen Host oder mehrere Verbindungen zu mehreren Hosts geben. Doppelte Anführungszeichen sind sowohl für Feldnamen als auch für Werte erforderlich. Es muss sich um normale Anführungszeichen (0x22) handeln. Es dürfen keine schrägen oder „smarten“ Anführungszeichen sein. Der einzige Wert, der keine doppelten Anführungszeichen benötigt, ist der boolesche Wert `true` oder `false` für das Feld `"mandatory"`.
Die folgende Liste beschreibt die Felder in der Manifestdatei.
endpoint
Die URL- oder IP-Adresse des Hosts, z. B. `"ec2-111-222-333.compute-1.amazonaws.com"` oder `"198.51.100.0"`.
command
Der Befehl, der durch den Host ausgeführt werden soll, um eine Textausgabe oder eine Binärausgabe im gzip-, lzop-, bzip2- oder zstd-Format zu generieren. Bei diesem Befehl kann es sich um jeden Befehl handeln, zu dessen Ausführung der Benutzer *host\$1user\$1name* berechtigt ist. Beim Befehl kann es sich um einen einfachen Befehl zum Drucken einer Datei oder um die Abfrage einer Datenbank oder das Starten eines Skripts handeln. Die Ausgabe (Textdatei, binäre gzip-Datei, binäre lzop-Datei oder binäre bzip2-Datei) muss ein Format aufweisen, das der Amazon-Redshift-Befehl COPY verarbeiten kann. Weitere Informationen finden Sie unter [Vorbereiten der Eingabedaten](t_preparing-input-data.md).
publickey
(Optional) Der öffentliche Schlüssel des Hosts. Wenn angegeben, verwendet Amazon Redshift den öffentlichen Schlüssel, um den Host zu identifizieren. Wenn der öffentliche Schlüssel nicht angegeben ist, versucht Amazon Redshift nicht, den Host zu identifizieren. Wenn beispielsweise der öffentliche Schlüssel des Remote-Hosts `ssh-rsa AbcCbaxxx…Example root@amazon.com` ist, geben Sie den folgenden Text in das Feld für den öffentlichen Schlüssel ein: `"AbcCbaxxx…Example"`.
mandatory
(Optional) Eine Klausel, die anzeigt, ob der COPY-Befehl fehlschlagen soll, wenn der Verbindungsversuch fehlschlägt. Der Standardwert ist `false`. Wenn Amazon Redshift nicht mindestens eine Verbindung herstellt, schlägt der COPY-Befehl fehl.
username
(Optional) Der Benutzername, der für die Anmeldung am Hostsystem und die Ausführung des Remotebefehls verwendet wird. Der Benutzeranmeldename muss mit dem Anmeldenamen identisch sein, der zum Hinzufügen des öffentlichen Schlüssels des Amazon-Redshift-Clusters zur Datei des Hosts mit den autorisierten Schlüsseln verwendet wurde. Der Standardbenutzername ist `redshift`.
Weitere Informationen zum Erstellen einer Manifestdatei finden Sie unter [Prozess für das Laden von Daten](loading-data-from-remote-hosts.md#load-from-host-process).
Um eine COPY-Operation aus einem Remote-Host auszuführen, muss für den COPY-Befehl der Parameter SSH angegeben werden. Wenn der Parameter SSH nicht angegeben ist, nimmt COPY an, dass die für FROM angegebene Datei eine Datendatei ist und schlägt fehl.
Wenn Sie die automatische Komprimierung verwenden, führt der COPY-Befehl zwei Datenleseoperationen aus. Das bedeutet, dass der Remotebefehl zweimal ausgeführt wird. Die erste Leseoperation dient dazu, eine Datenstichprobe zur Kompressionsanalyse bereitzustellen. In der zweiten Leseoperation werden die Daten tatsächlich geladen. Wenn die zweimalige Ausführung des Remotebefehls Probleme verursachen könnte, sollten Sie die automatische Kompression deaktivieren. Um die automatische Kompression zu deaktivieren, führen Sie den COPY-Befehl aus, wobei Sie den Parameter COMPUPDATE auf OFF festlegen. Weitere Informationen finden Sie unter [Laden von Tabellen mit automatischer Kompression](c_Loading_tables_auto_compress.md).
Details zur Verwendung der COPY-Operation aus SSH finden Sie unter [Laden von Daten aus Remote-Hosts](loading-data-from-remote-hosts.md).
*Autorisierung*
Der COPY-Befehl benötigt eine Autorisierung für den Zugriff auf Daten in anderen AWS -Ressourcen, einschließlich Amazon S3, Amazon EMR, Amazon DynamoDB und Amazon EC2. Sie können diese Autorisierung erteilen, indem Sie auf eine AWS Identity and Access Management (IAM-) Rolle verweisen, die Ihrem Cluster zugeordnet ist (rollenbasierte Zugriffskontrolle), oder indem Sie die Zugangsdaten für einen Benutzer angeben (schlüsselbasierte Zugriffskontrolle). Um Sicherheit und Flexibilität zu verbessern, wird die Verwendung der IAM-rollenbasierten Zugriffssteuerung empfohlen. Weitere Informationen finden Sie unter [Autorisierungsparameter](copy-parameters-authorization.md).
SSH
Eine Klausel, die angibt, dass die Daten über das SSH-Protokoll aus einem Remote-Host geladen werden sollen. Wenn Sie SSH angeben, müssen Sie auch unter Verwendung des Arguments [s3://copy_from_ssh_manifest_file](#copy-ssh-manifest) eine Manifestdatei angeben.
Wenn Sie SSH verwenden, um von einem Host mit einer privaten IP-Adresse in einem Remote-VPC zu kopieren, muss für den VPC erweitertes VPC-Routing aktiviert sein. Für weitere Informationen zu erweitertem VPC-Routing vgl. [Amazon Redshift Enhanced VPC Routing](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html).
## Optionale Parameter
Sie können für COPY aus SSH optional die folgenden Parameter angeben:
+ [Optionen für das Mapping von Spalten](copy-parameters-column-mapping.md)
+ [Datenformatparameter](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Datenkonvertierungsparameter](copy-parameters-data-conversion.md)
+ [Datenladeoperationen](copy-parameters-data-load.md)
## Nicht unterstützte Parameter
Die folgenden Parameter können Sie für COPY aus SSH nicht verwenden:
+ ENCRYPTED
+ MANIFEST
+ READRATIO
# COPY aus Amazon DynamoDB
Um Daten aus einer vorhandenen DynamoDB-Tabelle zu laden, verwenden Sie die FROM-Klausel, um den Namen der DynamoDB-Tabelle anzugeben.
**Topics**
+ [Syntax](#copy-parameters-data-source-dynamodb-syntax)
+ [Beispiele](#copy-parameters-data-source-dynamodb-examples)
+ [Optionale Parameter](#copy-parameters-data-source-dynamodb-optional-parms)
+ [Nicht unterstützte Parameter](#copy-parameters-data-source-dynamodb-unsupported-parms)
**Wichtig**
Wenn sich die DynamoDB-Tabelle nicht in derselben Region wie Ihr Amazon-Redshift-Cluster befindet, müssen Sie den Parameter REGION verwenden, um die Region anzugeben, in der sich die Daten befinden.
## Syntax
```
FROM 'dynamodb://table-name'
authorization
READRATIO ratio
| REGION [AS] 'aws_region'
| optional-parameters
```
## Beispiele
Im folgenden Beispiel werden Daten aus einer DynamoDB-Tabelle geladen.
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
### Parameters
FROM
Die Quelle der Daten, die geladen werden sollen.
'dynamodb://*table-name*'
Der Name der DynamoDB-Tabelle, die die Daten enthält, beispielsweise `'dynamodb://ProductCatalog'`. Details dazu, wie DynamoDB-Attribute den Amazon-Redshift-Spalten zugewiesen werden, finden Sie unter [Laden von Daten aus einer Amazon-DynamoDB-Tabelle](t_Loading-data-from-dynamodb.md).
Ein DynamoDB-Tabellenname ist für ein AWS Konto eindeutig, das durch die AWS Zugangsdaten identifiziert wird.
*Autorisierung*
Der COPY-Befehl benötigt eine Autorisierung für den Zugriff auf Daten in anderen AWS -Ressourcen, einschließlich Amazon S3, Amazon EMR, DynamoDB und Amazon EC2. Sie können diese Autorisierung gewähren, indem Sie auf eine AWS Identity and Access Management (IAM-) Rolle verweisen, die Ihrem Cluster zugeordnet ist (rollenbasierte Zugriffskontrolle), oder indem Sie die Zugangsdaten für einen Benutzer angeben (schlüsselbasierte Zugriffskontrolle). Um Sicherheit und Flexibilität zu verbessern, wird die Verwendung der IAM-rollenbasierten Zugriffssteuerung empfohlen. Weitere Informationen finden Sie unter [Autorisierungsparameter](copy-parameters-authorization.md).
READRATIO [AS] *ratio*
Der Prozentsatz des für die DynamoDB-Tabelle bereitgestellten Durchsatzes, der für das Laden der Daten verwendet werden soll. READRATIO ist für COPY aus DynamoDB erforderlich. Der Parameter kann nicht für COPY aus Amazon S3 verwendet werden. Es wird nachdrücklich empfohlen, das Verhältnis auf einen Wert festzulegen, der kleiner als der durchschnittliche Wert für nicht genutzten bereitgestellten Durchsatz ist. Gültige Werte sind Ganzzahlen von 1 bis 200.
Wenn Sie READRATIO auf 100 oder höher festlegen, kann Amazon Redshift den gesamten Durchsatz nutzen, der für die DynamoDB-Tabelle bereitgestellt wurde. Dies führt zu einer erheblich schlechteren Leistung für Leseoperationen, die für dieselbe Tabelle gleichzeitig mit der COPY-Sitzung ausgeführt werden. Der Schreibdatenverkehr ist nicht betroffen. Werte über 100 sind zulässig, um Fehler im Zusammenhang mit seltenen Szenarien zu beheben, wenn Amazon Redshift den für die Tabelle bereitgestellten Durchsatz nicht erreicht. Wenn Sie kontinuierlich Daten aus DynamoDB in Amazon Redshift laden, sollten Sie Ihre DynamoDB-Tabellen als Zeitreihe organisieren, um den Live-Datenverkehr von der COPY-Operation zu trennen.
## Optionale Parameter
Sie können für COPY aus Amazon DynamoDB optional die folgenden Parameter angeben:
+ [Optionen für das Mapping von Spalten](copy-parameters-column-mapping.md)
+ Folgende Datenkonvertierungsparameter werden unterstützt:
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [Datenladeoperationen](copy-parameters-data-load.md)
## Nicht unterstützte Parameter
Die folgenden Parameter können Sie für COPY aus DynamoDB nicht verwenden:
+ Alle Datenformatparameter
+ ESCAPE
+ FILLRECORD
+ IGNOREBLANKLINES
+ IGNOREHEADER
+ NULL
+ REMOVEQUOTES
+ ACCEPTINVCHARS
+ MANIFEST
+ ENCRYPTED
# Autorisierungsparameter
Der COPY-Befehl benötigt eine Autorisierung, um auf Daten in einer anderen AWS Ressource zuzugreifen, einschließlich in Amazon S3, Amazon EMR, Amazon DynamoDB und Amazon EC2. Sie gewähren diese Autorisierung durch die Referenzierung einer [IAM-Rolle (AWS Identity and Access Management )](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html), die mit Ihrem Cluster verbunden ist (*rollenbasierte Zugriffskontrolle*). Sie können Ihre Ladedaten auf Amazon S3 verschlüsseln.
In den folgenden Themen finden Sie weitere Details und Beispiele für Authentifizierungsoptionen:
+ [IAM-Berechtigungen für COPY, UNLOAD und CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions)
+ [Rollenbasierte Zugriffskontrolle](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [Schlüsselbasierte Zugriffssteuerung](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
Verwenden Sie eines der folgenden Verfahren, um eine Autorisierung für den COPY-Befehl bereitzustellen:
+ [Verwenden des Parameters IAM\$1ROLE](#copy-iam-role) Parameter
+ [Verwenden der Parameter ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY](#copy-access-key-id) parameters
+ [Verwenden des Parameters CREDENTIALS](#copy-credentials)-Klausel
## Verwenden des Parameters IAM\$1ROLE
### IAM\$1ROLE
Verwenden Sie das Standardstichwort, damit Amazon Redshift die IAM-Rolle verwendet, die als Standard festgelegt und mit dem Cluster verknüpft ist, wenn der COPY-Befehl ausgeführt wird.
Verwenden Sie den Amazon-Ressourcennamen (ARN) für eine IAM-Rolle, die von Ihrem Cluster für Authentifizierung und Autorisierung verwendet wird. Wenn Sie IAM\$1ROLE angeben, können Sie ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY, SESSION\$1TOKEN oder CREDENTIALS nicht verwenden.
Im Folgenden wird die Syntax für den Parameter IAM\$1ROLE gezeigt.
```
IAM_ROLE { default | 'arn:aws:iam:::role/' }
```
Weitere Informationen finden Sie unter [Rollenbasierte Zugriffskontrolle](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
## Verwenden der Parameter ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY
### ACCESS\$1KEY\$1ID, SECRET\$1ACCESS\$1KEY
Diese Autorisierungsmethode wird nicht empfohlen.
**Anmerkung**
Es wird nach nachdrücklich empfohlen, eine rollenbasierte Authentifizierung durch Angabe des Parameters IAM\$1ROLE zu verwenden, statt die Zugriffsanmeldeinformationen in Textform bereitzustellen. Weitere Informationen finden Sie unter [Rollenbasierte Zugriffskontrolle](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
### SESSION\$1TOKEN
Das Sitzungstoken, das für temporäre Zugriffsanmeldeinformationen verwendet wird. Wenn SESSION\$1TOKEN angegeben wird, müssen Sie auch ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY verwenden, um temporäre Zugriffsschlüssel-Anmeldeinformationen bereitzustellen. Wenn Sie SESSION\$1TOKEN angeben, können Sie IAM\$1ROLE oder CREDENTIALS nicht verwenden. Weitere Informationen finden Sie unter [Temporäre Sicherheitsanmeldeinformationen](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials) im IAM-Benutzerhandbuch.
**Anmerkung**
Es wird nach nachdrücklich empfohlen, eine rollenbasierte Authentifizierung zu verwenden, statt temporäre Sicherheitsanmeldeinformationen zu erstellen. Wenn Sie eine Autorisierung unter Verwendung einer IAM-Rolle ausführen, erstellt Amazon Redshift automatisch für jede Sitzung temporäre Benutzeranmeldeinformationen. Weitere Informationen finden Sie unter [Rollenbasierte Zugriffskontrolle](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
Im Folgenden wird die Syntax für den Parameter SESSION\$1TOKEN mit den Parametern ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY gezeigt.
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
Wenn Sie SESSION\$1TOKEN angeben, können Sie CREDENTIALS oder IAM\$1ROLE nicht verwenden.
## Verwenden des Parameters CREDENTIALS
### CREDENTIALS
Eine Klausel, die angibt, welche Methode Ihr Cluster beim Zugriff auf andere AWS Ressourcen verwenden wird, die Datendateien oder Manifestdateien enthalten. Sie können den Parameter CREDENTIALS nicht mit IAM\$1ROLE oder ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY verwenden.
Im Folgenden wird die Syntax für den Parameter CREDENTIALS gezeigt.
```
[WITH] CREDENTIALS [AS] 'credentials-args'
```
**Anmerkung**
Um die Flexibilität zu verbessern, wird die Verwendung des Parameters [IAM\$1ROLE](#copy-iam-role-iam) anstelle des Parameters CREDENTIALS empfohlen.
Wenn der Parameter [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) verwendet wird, stellt die Zeichenfolge *credentials-args* auch den Verschlüsselungsschlüssel bereit.
Die Zeichenfolge *credentials-args* unterscheidet zwischen Groß- und Kleinschreibung und darf keine Leerzeichen enthalten.
Die Schlüsselwörter WITH und AS sind optional und werden ignoriert.
Sie können entweder [role-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based.phrase) oder [key-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based.phrase) angeben. In beiden Fällen müssen die IAM-Rolle oder der Benutzer die nötigen Berechtigungen besitzen, um auf die angegebenen AWS -Ressourcen zuzugreifen. Weitere Informationen finden Sie unter [IAM-Berechtigungen für COPY, UNLOAD und CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
**Anmerkung**
Um Ihre AWS Anmeldeinformationen und vertrauliche Daten zu schützen, empfehlen wir dringend, die rollenbasierte Zugriffskontrolle zu verwenden.
Um die rollenbasierte Zugriffssteuerung anzugeben, stellen Sie die Zeichenfolge *credentials-args* im folgenden Format bereit.
```
'aws_iam_role=arn:aws:iam:::role/'
```
Um temporäre Token-Anmeldeinformationen zu verwenden, müssen Sie die temporäre Zugriffschlüssel-ID, den temporären geheimen Zugriffschlüssel und das temporäre Token bereitstellen. Die *credentials-args*-Zeichenfolge hat das folgende Format.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
Ein COPY-Befehl mit einer rollenbasierten Zugriffssteuerung mit temporären Anmeldeinformationen würde der folgenden Beispielanweisung ähnlich sein:
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
Weitere Informationen finden Sie unter [Temporäre Sicherheitsanmeldeinformationen](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials).
Wenn der [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) Parameter verwendet wird, hat die Zeichenfolge *credentials args das* folgende Format, wobei es sich um den Wert des Stammschlüssels ** handelt, der zum Verschlüsseln der Dateien verwendet wurde.
```
CREDENTIALS
';master_symmetric_key='
```
Ein COPY-Befehl mit einer rollenbasierten Zugriffssteuerung mit einem Verschlüsselungsschlüssel würde der folgenden Beispielanweisung ähnlich sein:
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_iam_role=arn:aws:iam:::role/;master_symmetric_key='
```
# Optionen für das Mapping von Spalten
Standardmäßig fügt COPY Werte in derselben Reihenfolge in die Spalten der Zieltabelle ein, die die Felder in den Datendateien haben. Wenn die standardmäßige Spaltenreihenfolge nicht funktioniert, können Sie eine Spaltenliste angeben oder JSONPath Ausdrücke verwenden, um Quelldatenfelder den Zielspalten zuzuordnen.
+ [Column List](#copy-column-list)
+ [JSONPaths File](#copy-column-mapping-jsonpaths)
## Spaltenliste
Sie können eine durch Komma getrennte Liste von Spaltennamen angeben, um Quelldatenfelder in spezifische Zielspalten zu laden. Die Spalten können in der COPY-Anweisung eine beliebige Reihenfolge aufweisen. Wenn sie jedoch aus Flat-Files geladen werden, beispielsweise in einem Amazon-S3-Bucket, muss ihre Reihenfolge mit der Reihenfolge der Quelldaten übereinstimmen.
Beim Laden aus einer Amazon-DynamoDB-Tabelle spielt die Reihenfolge keine Rolle. Der COPY-Befehl gleicht Attributnamen in den Elementen, die aus der DynamoDB-Tabelle abgerufen wurden, mit Spaltennamen in der Amazon-Redshift-Tabelle ab. Weitere Informationen finden Sie unter [Laden von Daten aus einer Amazon-DynamoDB-Tabelle](t_Loading-data-from-dynamodb.md)
Das Format einer Spaltenliste ist wie folgt.
```
COPY tablename (column1 [,column2, ...])
```
Wenn eine Spalte in der Zieltabelle aus der Spaltenliste ausgelassen wird, lädt COPY den [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default)-Ausdruck der Zielspalte.
Wenn die Zielspalte keinen Standardwert besitzt, versucht COPY, NULL zu laden.
Wenn COPY versucht, einer Spalte NULL zuzuweisen, die als NOT NULL definiert ist, schlägt der COPY-Befehl fehl.
Wenn eine [IDENTITY](r_CREATE_TABLE_NEW.md#identity-clause)-Spalte in der Spaltenliste enthalten ist, muss auch [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids) angegeben werden. Wenn keine IDENTITY-Spalte angegeben ist, kann EXPLICIT\$1IDS nicht angegeben werden. Wenn keine Spaltenliste angegeben ist, verhält sich der Befehl, als ob eine vollständige, reihenfolgegerechte Spaltenliste angegeben ist, wobei IDENTITY-Spalten ausgelassen werden, wenn EXPLICIT\$1IDS nicht angegeben wurde.
Wenn eine Spalte mit GENERATED BY DEFAULT AS IDENTITY definiert ist, kann sie kopiert werden. Die Werte werden mit den von Ihnen angegebenen Werten generiert oder aktualisiert. Die Option EXPLICIT\$1IDS ist nicht erforderlich. COPY aktualisiert nicht die Identity High Watermark. Weitere Informationen finden Sie unter [GENERATED BY DEFAULT AS IDENTITY](r_CREATE_TABLE_NEW.md#identity-generated-bydefault-clause).
## JSONPaths Datei
Beim Laden von Daten aus Datendateien im JSON- oder Avro-Format weist COPY die Datenelemente in den JSON- oder Avro-Quelldaten automatisch den Spalten in der Zieltabelle zu. Dies geschieht durch den Abgleich von Feldnamen im Avro-Schema mit den Spaltennamen in der Zieltabelle oder Spaltenliste.
In einigen Fällen werden die Spaltennamen und Feldnamen nicht übereinstimmen oder Sie müssen Zuweisungen tiefer in der Datenhierarchie vornehmen. In diesen Fällen können Sie eine JSONPaths Datei verwenden, um JSON- oder Avro-Datenelemente explizit Spalten zuzuordnen.
Weitere Informationen finden Sie unter [JSONPaths Datei](copy-parameters-data-format.md#copy-json-jsonpaths).
# Datenformatparameter
Standardmäßig geht der COPY-Befehl davon aus, dass es sich bei den Quelldaten um UTF-8-Text mit Trennzeichen handelt. Das Standardtrennzeichen ist der senkrechte Strich (\$1). Wenn sich die Quelldaten in einem anderen Format befinden, verwenden Sie die folgenden Parameter, um das Datenformat anzugeben:
+ [FORMAT](#copy-format)
+ [CSV](#copy-csv)
+ [DELIMITER](#copy-delimiter)
+ [FIXEDWIDTH](#copy-fixedwidth)
+ [SHAPEFILE](#copy-shapefile)
+ [AVRO](#copy-avro)
+ [JSON format for COPY](#copy-json)
+ [PARQUET](#copy-parquet)
+ [ORC](#copy-orc)
Neben den Standarddatenformaten unterstützt COPY die folgenden spaltenbasierten Datenformate für COPY aus Amazon S3:
+ [ORC](#copy-orc)
+ [PARQUET](#copy-parquet)
COPY aus einem spaltenbasierten Format wird mit bestimmten Einschränkungen unterstützt. Weitere Informationen finden Sie unter [COPY aus spaltenbasierten Datenformaten](copy-usage_notes-copy-from-columnar.md). Datenformatparameter
FORMAT [AS]
(Optional) Identifiziert Datenformatschlüsselwörter. Die FORMAT-Argumente werden im Folgenden beschrieben.
CSV [ QUOTE [AS] *'quote\$1character'* ]
Ermöglicht die Verwendung des CSV-Formats in den Eingabedaten. Um Trennzeichen, Zeichen für neue Zeilen und Zeilenumbrüche automatisch mit Escape-Zeichen zu markieren, schließen Sie das Feld in das durch den Parameter QUOTE angegebene Zeichen ein. Das Standardanführungszeichen ist das doppelte Anführungszeichen ("). Wird das Anführungszeichen innerhalb des Feldes verwendet, verwenden Sie ein weiteres Anführungszeichen als Escape-Zeichen. Wenn beispielsweise das Anführungszeichen ein doppeltes Anführungszeichen ist und die Zeichenfolge `A "quoted" word` eingefügt werden soll, sollte die Eingabedatei die Zeichenfolge `"A ""quoted"" word"` enthalten. Wenn der CSV-Parameter verwendet wird, ist das Standardtrennzeichen ein Komma (,). Sie können ein anderes Trennzeichen angeben, indem Sie den Parameter DELIMITER verwenden.
Wenn ein Feld in Anführungszeichen eingeschlossen wird, werden Leerzeichen zwischen Trennzeichen und Anführungszeichen ignoriert. Wenn das Trennzeichen ein Leerzeichen ist, beispielsweise ein Tabulatorzeichen, wird das Trennzeichen nicht als Leerzeichen behandelt.
Das CSV-Format kann nicht mit FIXEDWIDTH, REMOVEQUOTES oder ESCAPE verwendet werden.
QUOTE [AS] *'quote\$1character'*
Optional. Gibt das Zeichen an, das als Anführungszeichen verwendet werden soll, wenn der CSV-Parameter verwendet wird. Der Standardwert ist das doppelte Anführungszeichen ("). Wenn Sie den Parameter QUOTE verwenden, um ein anderes Anführungszeichen als ein doppeltes Anführungszeichen zu definieren, müssen Sie doppelte Anführungszeichen innerhalb des Felds nicht mit Escape-Zeichen markieren. Der Parameter QUOTE kann nur mit dem Parameter CSV verwendet werden. Das Schlüsselwort AS ist optional.
DELIMITER [AS] ['*delimiter\$1char*']
Gibt Zeichen an, die verwendet werden, um Felder in der Eingabedatei zu trennen, beispielsweise das Pipe-Zeichen (`|`), das Komma (`,`), das Tabulatorzeichen (`\t`) oder mehrere Zeichen (z. B. `|~|`). Nicht druckbare Zeichen werden unterstützt. Zeichen können auch oktal als ihre UTF-8-Codeeinheiten dargestellt werden. Verwenden Sie für die oktale Darstellung das Format „\$1ddd“, wobei „d“ eine Oktalziffer ist (0–7). Das Standardtrennzeichen ist das Pipe-Zeichen (`|`), wenn nicht der Parameter CSV verwendet wird. In diesem Fall ist das Standardtrennzeichen das Komma (`,`). Das Schlüsselwort AS ist optional. DELIMITER kann nicht mit FIXEDWIDTH verwendet werden.
FIXEDWIDTH '*fixedwidth\$1spec*'
Lädt die Daten aus einer Datei, in der jede Spalte eine feste Breite hat, statt durch ein Trennzeichen abgetrennt zu werden. *fixedwidth\$1spec* ist eine Zeichenfolge, die eine benutzerdefinierte Spaltenbezeichnung und eine benutzerdefinierte Spaltenbreite angibt. Die Spaltenbezeichnung kann eine Textzeichenfolge oder eine Ganzzahl sein, abhängig davon, wofür sich der Benutzer entscheidet. Spaltenbezeichnung und Spaltenname sind nicht aufeinander bezogen. Die Reihenfolge der label/width Paare muss exakt mit der Reihenfolge der Tabellenspalten übereinstimmen. FIXEDWIDTH kann nicht mit CSV oder DELIMITER verwendet werden. In Amazon Redshift wird die Länge der CHAR- und VARCHAR-Spalten in Bytes ausgedrückt. Achten Sie daher darauf, dass die von Ihnen angegebene Spaltenbreite beim Vorbereiten der Datei auf das Laden die binäre Länge von Multibyte-Zeichen berücksichtigt. Weitere Informationen finden Sie unter [Zeichentypen](r_Character_types.md).
Das Format für *fixedwidth\$1spec* wird im Folgenden gezeigt:
```
'colLabel1:colWidth1,colLabel:colWidth2, ...'
```
SHAPEFILE [ SIMPLIFY [AUTO] [*'Toleranz'*] ]
Ermöglicht die Verwendung des SHAPEFILE-Formats in den Eingabedaten. Standardmäßig ist die erste Spalte des Shapefile entweder eine `GEOMETRY`- oder `IDENTITY`-Spalte. Alle nachfolgenden Spalten folgen der im Shapefile angegebenen Reihenfolge.
SHAPEFILE kann nicht mit FIXEDWIDTH, REMOVEQUOTES oder ESCAPE verwendet werden.
Um `GEOGRAPHY`-Objekte mit `COPY FROM SHAPEFILE` zu verwenden, erfassen Sie zuerst in eine `GEOMETRY`-Spalte und wandeln dann die Objekte in `GEOGRAPHY`-Objekte um.
SIMPLIFY [*Toleranz*]
(Optional) Vereinfacht alle Geometrien während des Aufnahmeprozesses mithilfe des Ramer-Douglas-Peucker Algorithmus und der angegebenen Toleranz.
SIMPLIFY AUTO [*Toleranz*]
(Optional) Vereinfacht nur Geometrien, die größer als die maximale Geometriegröße sind. Bei dieser Vereinfachung werden der Ramer-Douglas-Peucker Algorithmus und die automatisch berechnete Toleranz verwendet, sofern diese die angegebene Toleranz nicht überschreitet. Der Algorithmus berechnet die Größe zum Speichern von Objekten innerhalb der angegebenen Toleranz. Der *Toleranz*-Wert ist optional.
Beispiele zum Laden von Shapefiles finden Sie unter [Laden eines Shapefile in Amazon Redshift](r_COPY_command_examples.md#copy-example-spatial-copy-shapefile).
AVRO [AS] '*avro\$1option*'
Gibt an, dass die Quelldaten im Avro-Format vorliegen.
Das Avro-Format wird durch folgende Services und Protokolle für den COPY-Befehl unterstützt:
+ Amazon S3
+ Amazon EMR
+ Remote-Hosts (SSH)
Avro wird für COPY aus DynamoDB nicht unterstützt.
Avro ist ein Protokoll für die Datenserialisierung. Eine Avro-Quelldatei enthält ein Schema, das die Struktur der Daten definiert. Der Avro-Schematyp muss sein `record`. COPY akzeptiert Avro-Dateien, die unter Verwendung des standardmäßigen nicht komprimierten Codec sowie der Komprimierungs-Codecs `deflate` und `snappy` erstellt wurden. Weitere Informationen zu Avro finden Sie unter [Apache Avro](https://avro.apache.org/).
Gültige Werte für *avro\$1option* sind folgende:
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
Der Standardwert ist `'auto'`.
COPY weist die Datenelemente in den Avro-Quelldaten automatisch den Spalten in der Zieltabelle zu. Dies geschieht durch den Abgleich von Feldnamen im Avro-Schema mit den Spaltennamen in der Zieltabelle. Mit `'auto'` wird beim Abgleich die Groß-/Kleinschreibung beachtet, mit `'auto ignorecase'` nicht.
Spaltennamen in Amazon-Redshift-Tabellen verwenden stets Kleinbuchstaben. Daher müssen übereinstimmende Feldnamen ebenfalls Kleinbuchstaben verwenden, wenn Sie die Option `'auto'` verwenden. Wenn die Feldnamen nicht alle Kleinbuchstaben sind, können Sie die Option `'auto ignorecase'` verwenden. Mit dem Standardargument `'auto'` erkennt COPY nur die erste Ebene von Feldern bzw. die *äußeren Felder* in der Struktur.
Um den Avro-Feldnamen explizit Spaltennamen zuzuordnen, können Sie verwenden [JSONPaths Datei](#copy-json-jsonpaths).
Standardmäßig versucht COPY, alle Spalten in der Zieltabelle mit Avro-Feldnamen abzugleichen. Um einen Subsatz der Spalten zu laden, können Sie optional eine Spaltenliste angeben. Wenn eine Spalte in der Zieltabelle aus der Spaltenliste ausgelassen wird, lädt COPY den [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default)-Ausdruck der Zielspalte. Wenn die Zielspalte keinen Standardwert besitzt, versucht COPY, NULL zu laden. Wenn eine Spalte in der Spaltenliste enthalten ist und COPY in den Avro-Daten kein übereinstimmendes Feld findet, versucht COPY, NULL in die Spalte zu laden.
Wenn COPY versucht, einer Spalte NULL zuzuweisen, die als NOT NULL definiert ist, schlägt der COPY-Befehl fehl.
**Avro-Schema**
Eine Avro-Quelldatendatei enthält ein Schema, das die Struktur der Daten definiert. COPY liest das Schema, das Teil der Avro-Quelldatendatei ist, um Datenelemente zu Zieltabellenspalten zuzuweisen. Die folgende Abbildung zeigt ein Avro-Schema.
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"}]
}
```
Das Avro-Schema wird unter Verwendung des JSON-Formats definiert. Das JSON-Objekt auf der obersten Ebene enthält drei Name/Wert-Paare mit den Namen bzw. *Schlüsseln* `"name"`, `"type"` und `"fields"`.
Der `"fields"`-Schlüssel wird mit einem Array von Objekten verknüpft, die den Namen und Datentyp der einzelnen Felder in der Datenstruktur definieren. Standardmäßig gleicht COPY die Feldnamen mit Spaltennamen ab. Spaltennamen verwenden stets Kleinbuchstaben. Daher müssen übereinstimmende Feldnamen ebenfalls Kleinbuchstaben verwenden, außer Sie geben die Option `‘auto ignorecase’` an. Feldnamen, die mit keiner Spalte übereinstimmen, werden ignoriert. Die Reihenfolge spielt keine Rolle. Im vorherigen Beispiel führt COPY einen Abgleich mit den Spaltennamen `id`, `guid`, `name` und `address` aus.
Bei Verwendung des Standardarguments `'auto'` gleicht COPY nur Objekte auf der ersten Ebene mit Spalten ab. Verwenden Sie eine Datei, um die Zuordnung zu tieferen Ebenen im Schema vorzunehmen oder wenn Feld- und Spaltennamen nicht übereinstimmen, definieren Sie die Zuordnung mithilfe einer JSONPaths Datei. Weitere Informationen finden Sie unter [JSONPaths Datei](#copy-json-jsonpaths).
Wenn es sich bei dem Wert, der mit einem Schlüssel verknüpft ist, um einen komplexen Avro-Datentyp wie Byte, Array, Datensatz, Zuweisung oder Link handelt, lädt COPY den Wert als Zeichenfolge. Hier ist die Zeichenfolge die JSON-Darstellung der Daten. COPY lädt Avro-Aufzählungsdatentypen als Zeichenfolgen, wobei der Inhalt der Name des Typs ist. Ein Beispiel finden Sie unter [COPY von JSON-Format](copy-usage_notes-copy-from-json.md).
Die maximale Größe des Avro-Dateiheaders, der das Schema und die Dateimetadaten enthält, beträgt 1 MB.
Die maximale Größe eines einzelnen Avro-Datenblocks beträgt 4 MB. Dies ist etwas anderes als die maximale Zeilengröße. Wenn die maximale Größe eines einzelnen Avro-Datenblocks überschritten wird, schlägt der COPY-Befehl fehl. Dies ist auch dann der Fall, wenn die entsprechende Zeilengröße unter der Grenze von 4 MB für Zeilengrößen liegt.
Bei der Berechnung der Zeilengröße zählt Amazon Redshift intern Pipe-Zeichen (\$1) zweimal. Wenn Ihre Eingabedaten eine sehr große Zahl von Pipe-Zeichen enthalten, ist es möglich, dass die Zeilengröße 4 MB überschreitet, auch wenn der Datenblock kleiner als 4 MB ist.
JSON [AS] '*json\$1option*'
Die Quelldaten weisen das JSON-Format auf.
Das JSON-Format wird durch folgende Services und Protokolle für den COPY-Befehl unterstützt:
+ Amazon S3
+ COPY aus Amazon EMR
+ COPY aus SSH
JSON wird für COPY aus DynamoDB nicht unterstützt.
Gültige Werte für *json\$1option* sind folgende:
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
+ `'noshred'`
Der Standardwert ist `'auto'`. Amazon Redshift zerlegt die Attribute von JSON-Strukturen beim Laden eines JSON-Dokuments nicht in mehrere Spalten.
Standardmäßig versucht COPY, alle Spalten in der Zieltabelle mit JSON-Feldnamenschlüsseln abzugleichen. Um einen Subsatz der Spalten zu laden, können Sie optional eine Spaltenliste angeben. Wenn die JSON-Feldnamenschlüssel nicht nur Kleinbuchstaben verwenden, können Sie `'auto ignorecase'` oder [JSONPaths Datei](#copy-json-jsonpaths) verwenden, um Spaltennamen explizit zu JSON-Feldnamenschlüsseln zuzuweisen.
Wenn eine Spalte in der Zieltabelle aus der Spaltenliste ausgelassen wird, lädt COPY den [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default)-Ausdruck der Zielspalte. Wenn die Zielspalte keinen Standardwert besitzt, versucht COPY, NULL zu laden. Wenn eine Spalte in der Spaltenliste enthalten ist und COPY in den JSON-Daten kein übereinstimmendes Feld findet, versucht COPY, NULL in die Spalte zu laden.
Wenn COPY versucht, einer Spalte NULL zuzuweisen, die als NOT NULL definiert ist, schlägt der COPY-Befehl fehl.
COPY weist die Datenelemente in den JSON-Quelldaten den Spalten in der Zieltabelle zu. Dies geschieht durch den Abgleich der *Objektschlüssel* oder -namen in den Name-Wert-Paaren der Quelle mit den Namen der Spalten in der Zieltabelle.
Im Folgenden finden Sie nähere Angaben zu den einzelnen *json\$1option*-Werten:
'auto'
Bei dieser Option wird zwischen Groß- und Kleinschreibung unterschieden. Spaltennamen in Amazon-Redshift-Tabellen verwenden stets Kleinbuchstaben. Daher müssen übereinstimmende JSON-Feldnamen ebenfalls Kleinbuchstaben verwenden, wenn Sie die Option `'auto'` verwenden.
'auto ignorecase'
Bei dieser Option wird nicht zwischen Groß- und Kleinschreibung unterschieden. Spaltennamen in Amazon-Redshift-Tabellen verwenden stets Kleinbuchstaben. Wenn Sie die Option `'auto ignorecase'` verwenden, können entsprechende JSON-Feldnamen Kleinbuchstaben, Großbuchstaben oder beides verwenden.
's3://*jsonpaths\$1file*'
Bei dieser Option verwendet COPY die benannte JSONPaths Datei, um die Datenelemente in den JSON-Quelldaten den Spalten in der Zieltabelle zuzuordnen. Das *`s3://jsonpaths_file`*-Argument muss ein Amazon S3-Objektschlüssel sein, der explizit auf eine einzelne Datei verweist. Ein Beispiel ist `'s3://amzn-s3-demo-bucket/jsonpaths.txt`'. Das Argument darf kein Schlüsselpräfix sein. Weitere Hinweise zur Verwendung einer JSONPaths Datei finden Sie unter[JSONPaths Datei](#copy-json-jsonpaths).
In einigen Fällen hat die von `jsonpaths_file` angegebene Datei dasselbe Präfix wie der von `copy_from_s3_objectpath` angegebene Pfad für die Datendateien. Falls ja, liest COPY die JSONPaths Datei als Datendatei und gibt Fehler zurück. Nehmen wir zum Beispiel an, dass Ihre Datendateien den Objektpfad verwenden `s3://amzn-s3-demo-bucket/my_data.json` und Ihre JSONPaths Datei bereits`s3://amzn-s3-demo-bucket/my_data.jsonpaths`. In diesem Fall versucht COPY, `my_data.jsonpaths` als Datendatei zu laden.
'noshred'
Mit dieser Option zerlegt Amazon Redshift die Attribute von JSON-Strukturen beim Laden eines JSON-Dokuments nicht in mehrere Spalten.
## JSON-Datendatei
Die JSON-Datendatei enthält einen Satz von Objekten oder einen Satz von Arrays. COPY lädt jedes JSON-Objekt oder -Array in eine einzige Zeile in der Zieltabelle. Jedes Objekt oder Array, das einer Zeile entspricht, muss eine eigenständige Struktur auf Stammebene besitzen, d. h., es darf kein Mitglied einer anderen JSON-Struktur sein.
Ein JSON-*Objekt* beginnt und endet mit geschweiften Klammern (\$1\$1) und enthält eine nicht geordnete Sammlung von Name/Wert-Paaren. Name und Wert in einem Paar werden durch einen Doppelpunkt getrennt und die Paare werden durch Kommas getrennt. Standardmäßig muss der *Objektschlüssel* bzw. Name in den Name-Wert-Paaren mit dem Namen der entsprechenden Spalte in der Tabelle übereinstimmen. Spaltennamen in Amazon-Redshift-Tabellen verwenden stets Kleinbuchstaben. Daher müssen übereinstimmende JSON-Feldnamenschlüssel ebenfalls Kleinbuchstaben verwenden. Wenn Ihre Spaltennamen und JSON-Schlüssel nicht übereinstimmen, verwenden Sie [JSONPaths Datei](#copy-json-jsonpaths), um Spalten explizit Schlüsseln zuzuweisen.
Die Reihenfolge in einem JSON-Objekt spielt keine Rolle. Namen, die mit keiner Spalte übereinstimmen, werden ignoriert. Im Folgenden wird die Struktur eines einfachen JSON-Objekts gezeigt.
```
{
"column1": "value1",
"column2": value2,
"notacolumn" : "ignore this value"
}
```
Ein JSON-*Array* beginnt und endet mit eckigen Klammern ([]) und enthält eine geordnete Sammlung von Werten, getrennt durch Kommas. Wenn Ihre Datendateien Arrays verwenden, müssen Sie eine JSONPaths Datei angeben, um die Werte den Spalten zuzuordnen. Im Folgenden wird die Struktur eines einfachen JSON-Arrays gezeigt.
```
["value1", value2]
```
JSON muss wohl geformt sein. Die Objekte oder Arrays dürfen beispielsweise nicht durch Kommas oder andere Zeichen getrennt werden, sondern nur durch Leerzeichen. Zeichenfolgen müssen in doppelte Anführungszeichen eingeschlossen werden. Bei den Anführungszeichen muss es sich um normale Anführungszeichen (0x22) handeln. Es dürfen keine schrägen oder „smarten“ Anführungszeichen sein.
Die maximale Größe eines einzelnen JSON-Objekts oder -Arrays einschließlich geschweifter oder eckiger Klammern beträgt 4 MB. Dies ist etwas anderes als die maximale Zeilengröße. Wenn die maximale Größe eines einzelnen JSON-Objekts oder Arrays überschritten wird, schlägt der COPY-Befehl fehl. Dies ist auch dann der Fall, wenn die entsprechende Zeilengröße unter der Grenze von 4 MB für Zeilengrößen liegt.
Bei der Berechnung der Zeilengröße zählt Amazon Redshift intern Pipe-Zeichen (\$1) zweimal. Wenn Ihre Eingabedaten eine sehr große Zahl von Pipe-Zeichen enthalten, ist es möglich, dass die Zeilengröße 4 MB überschreitet, auch wenn die Objektgröße weniger als 4 MB beträgt.
COPY lädt `\n` als Zeichen für neue Zeilen und `\t` als Tabulatorzeichen. Um einen Backslash zu laden, muss ein Backslash als Escape-Zeichen verwendet werden ( `\\` ).
COPY durchsucht die angegebene JSON-Quelle nach einem wohl geformten, gültigen JSON-Objekt oder -Array. Wenn COPY vor dem Auffinden einer verwendbaren JSON-Struktur oder zwischen gültigen JSON-Objekten oder -Arrays auf Zeichen stößt, die keine Leerzeichen sind, gibt COPY für jede Instance einen Fehler zurück. Diese Fehler werden auf die MAXERROR-Fehlerzahl angerechnet. Wenn die Fehlerzahl gleich oder größer als MAXERROR ist, schlägt COPY fehl.
Für jeden Fehler zeichnet Amazon Redshift eine Zeile in der Systemtabelle STL\$1LOAD\$1ERRORS auf. Die Spalte LINE\$1NUMBER zeichnet die letzte Zeile des JSON-Objekts auf, das den Fehler verursacht hat.
Wenn IGNOREHEADER angegeben ist, ignoriert COPY die angegebene Zahl von Zeilen in den JSON-Daten. Zeichen für neue Zeilen in den JSON-Daten werden stets für IGNOREHEADER-Berechnungen berücksichtigt.
COPY lädt leere Zeichenfolgen standardmäßig als leere Felder. Wenn EMPTYASNULL angegeben ist, lädt COPY leere Zeichenfolgen für CHAR- und VARCHAR-Felder als NULL. Leere Zeichenfolgen für andere Datentypen, beispielsweise INT, werden stets mit NULL geladen.
Die folgenden Optionen werden für JSON nicht unterstützt:
+ CSV
+ DELIMITER
+ ESCAPE
+ FILLRECORD
+ FIXEDWIDTH
+ IGNOREBLANKLINES
+ NULL AS
+ READRATIO
+ REMOVEQUOTES
Weitere Informationen finden Sie unter [COPY von JSON-Format](copy-usage_notes-copy-from-json.md). Weitere Informationen zu JSON-Datenstrukturen finden Sie unter [www.json.org](https://www.json.org/).
## JSONPaths Datei
Wenn Sie Daten aus Quelldaten im JSON-Format oder aus Avro-Quelldaten laden, weist COPY standardmäßig die Datenelemente auf der ersten Ebene in den Quelldaten den Spalten in der Zieltabelle zu. Dazu wird jeder Name bzw. Objektschlüssel in einem Name-Wert-Paar mit dem Namen einer Spalte in der Zieltabelle abgeglichen.
Wenn Ihre Spaltennamen und Objektschlüssel nicht übereinstimmen oder um sie tieferen Ebenen in der Datenhierarchie zuzuordnen, können Sie eine JSONPaths Datei verwenden, um JSON- oder Avro-Datenelemente explizit Spalten zuzuordnen. Die JSONPaths Datei ordnet JSON-Datenelemente Spalten zu, indem sie die Spaltenreihenfolge in der Zieltabelle oder Spaltenliste anpasst.
Die JSONPaths Datei darf nur ein einzelnes JSON-Objekt (kein Array) enthalten. Das JSON-Objekt ist ein Name-Wert-Paar. Der *Objektschlüssel* (der Name im Name-Wert-Paar) muss `"jsonpaths"` sein. *Der *Wert* im Name-Wert-Paar ist ein Array von JSONPath Ausdrücken.* Jeder JSONPath Ausdruck verweist auf ein einzelnes Element in der JSON-Datenhierarchie oder im Avro-Schema, ähnlich wie ein XPath Ausdruck auf Elemente in einem XML-Dokument verweist. Weitere Informationen finden Sie unter [JSONPath Ausdrücke](#copy-json-jsonpath-expressions).
Um eine JSONPaths Datei zu verwenden, fügen Sie dem Befehl COPY das Schlüsselwort JSON oder AVRO hinzu. Geben Sie den S3-Bucket-Namen und den Objektpfad der JSONPaths Datei im folgenden Format an.
```
COPY tablename
FROM 'data_source'
CREDENTIALS 'credentials-args'
FORMAT AS { AVRO | JSON } 's3://jsonpaths_file';
```
Der `s3://jsonpaths_file`-Wert muss ein Amazon S3-Objektschlüssel sein, der explizit auf eine einzelne Datei verweist, z. B. `'s3://amzn-s3-demo-bucket/jsonpaths.txt'`. Es darf kein Schlüsselpräfix sein.
Bei Ladevorgängen aus Amazon S3 hat die von `jsonpaths_file` angegebene Datei in einigen Fällen dasselbe Präfix wie der von `copy_from_s3_objectpath` angegebene Pfad für die Datendateien. Falls ja, liest COPY die JSONPaths Datei als Datendatei und gibt Fehler zurück. Nehmen wir zum Beispiel an, dass Ihre Datendateien den Objektpfad verwenden `s3://amzn-s3-demo-bucket/my_data.json` und Ihre JSONPaths Datei bereits`s3://amzn-s3-demo-bucket/my_data.jsonpaths`. In diesem Fall versucht COPY, `my_data.jsonpaths` als Datendatei zu laden.
Wenn der Schlüsselname eine andere Zeichenfolge als `"jsonpaths"` ist, gibt der COPY-Befehl keinen Fehler zurück, sondern ignoriert *jsonpaths\$1file* und verwendet stattdessen das Argument `'auto'`.
Wenn eine der folgenden Bedingungen zutrifft, schlägt der COPY-Befehl fehl:
+ Der JSON-Code ist schlecht geformt.
+ Es gibt mehr als ein JSON-Objekt.
+ Außerhalb des Objekts sind Zeichen (außer Leerzeichen) vorhanden.
+ Ein Array-Element ist eine leere Zeichenfolge oder keine Zeichenfolge.
MAXERROR gilt nicht für die JSONPaths Datei.
Die JSONPaths Datei darf nicht verschlüsselt sein, auch wenn die [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) Option angegeben ist.
Weitere Informationen finden Sie unter [COPY von JSON-Format](copy-usage_notes-copy-from-json.md).
## JSONPath Ausdrücke
Die JSONPaths Datei verwendet JSONPath Ausdrücke, um Datenfelder Zielspalten zuzuordnen. Jeder JSONPath Ausdruck entspricht einer Spalte in der Amazon Redshift Redshift-Zieltabelle. Die Reihenfolge der JSONPath Array-Elemente muss mit der Reihenfolge der Spalten in der Zieltabelle oder der Spaltenliste übereinstimmen, wenn eine Spaltenliste verwendet wird.
Doppelte Anführungszeichen sind sowohl für Feldnamen als auch für Werte erforderlich. Es muss sich um normale Anführungszeichen (0x22) handeln. Es dürfen keine schrägen oder „smarten“ Anführungszeichen sein.
Wenn ein Objektelement, auf das ein JSONPath Ausdruck verweist, in den JSON-Daten nicht gefunden wird, versucht COPY, einen NULL-Wert zu laden. Wenn das referenzierte Objekt schlecht geformt ist, gibt COPY einen Ladefehler zurück.
Wenn ein Array-Element, auf das von einem JSONPath Ausdruck verwiesen wird, in den JSON- oder Avro-Daten nicht gefunden wird, schlägt COPY mit dem folgenden Fehler fehl: `Invalid JSONPath format: Not an array or index out of range.` Entfernen Sie alle Array-Elemente aus dem JSONPaths , die in den Quelldaten nicht vorhanden sind, und überprüfen Sie, ob die Arrays in den Quelldaten korrekt geformt sind.
Die JSONPath Ausdrücke können entweder die Klammernotation oder die Punktnotation verwenden, aber Sie können Notationen nicht mischen. Das folgende Beispiel zeigt JSONPath Ausdrücke, die die Klammernotation verwenden.
```
{
"jsonpaths": [
"$['venuename']",
"$['venuecity']",
"$['venuestate']",
"$['venueseats']"
]
}
```
Das folgende Beispiel zeigt JSONPath Ausdrücke in Punktnotation.
```
{
"jsonpaths": [
"$.venuename",
"$.venuecity",
"$.venuestate",
"$.venueseats"
]
}
```
Im Kontext der Amazon Redshift COPY-Syntax muss ein JSONPath Ausdruck den expliziten Pfad zu einem einzelnen Namenselement in einer hierarchischen JSON- oder Avro-Datenstruktur angeben. Amazon Redshift unterstützt keine JSONPath Elemente wie Platzhalterzeichen oder Filterausdrücke, die zu einem mehrdeutigen Pfad oder mehreren Namenselementen aufgelöst werden könnten.
Weitere Informationen finden Sie unter [COPY von JSON-Format](copy-usage_notes-copy-from-json.md).
## Verwendung JSONPaths mit Avro Data
Im folgenden Beispiel wird ein Avro-Schema mit mehreren Ebenen gezeigt.
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "isActive", "type": "boolean"},
{"name": "age", "type": "int"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"},
{"name": "latitude", "type": "double"},
{"name": "longitude", "type": "double"},
{
"name": "tags",
"type": {
"type" : "array",
"name" : "inner_tags",
"items" : "string"
}
},
{
"name": "friends",
"type": {
"type" : "array",
"name" : "inner_friends",
"items" : {
"name" : "friends_record",
"type" : "record",
"fields" : [
{"name" : "id", "type" : "int"},
{"name" : "name", "type" : "string"}
]
}
}
},
{"name": "randomArrayItem", "type": "string"}
]
}
```
Das folgende Beispiel zeigt eine JSONPaths Datei, die AvroPath Ausdrücke verwendet, um auf das vorherige Schema zu verweisen.
```
{
"jsonpaths": [
"$.id",
"$.guid",
"$.address",
"$.friends[0].id"
]
}
```
Das JSONPaths Beispiel umfasst die folgenden Elemente:
jsonpaths
Der Name des JSON-Objekts, das die AvroPath Ausdrücke enthält.
[ … ]
Eckige Klammern schließen das JSON-Array ein, das die Pfadelemente enthält.
\$1
Das Dollarzeichen bezieht sich auf das Stammelement im Avro-Schema, das das `"fields"`-Array ist.
"\$1.id",
Das Ziel des AvroPath Ausdrucks. In diesem Fall ist das Ziel das Element im `"fields"`-Array mit dem Namen `"id"`. Die Ausdrücke werden durch Kommas getrennt.
"\$1.friends[0].id"
Klammern geben einen Array-Index an. JSONPath Ausdrücke verwenden eine nullbasierte Indizierung, sodass dieser Ausdruck auf das erste Element im `"friends"` Array mit dem Namen verweist. `"id"`
Die Avro-Schemasyntax erfordert die Verwendung von *internen Feldern*, um die Struktur der Datensatz- und Array-Datentypen zu definieren. Die inneren Felder werden von den Ausdrücken ignoriert. AvroPath Beispielsweise definiert das Feld `"friends"` ein Array namens `"inner_friends"`, das wiederum einen Datensatz namens `"friends_record"` definiert. Der AvroPath Ausdruck, der auf das Feld verweist, `"id"` kann die zusätzlichen Felder ignorieren, um direkt auf das Zielfeld zu verweisen. Die folgenden AvroPath Ausdrücke verweisen auf die beiden Felder, die zum `"friends"` Array gehören.
```
"$.friends[0].id"
"$.friends[0].name"
```
## Spaltendatenformat-Parameter
Neben den Standarddatenformaten unterstützt COPY die folgenden spaltenbasierten Datenformate für COPY aus Amazon S3. COPY aus einem Spaltenformat wird mit bestimmten Einschränkungen unterstützt. Weitere Informationen finden Sie unter [COPY aus spaltenbasierten Datenformaten](copy-usage_notes-copy-from-columnar.md).
ORC
Lädt die Daten aus einer Datei im Optimized Row Columnar (ORC)-Format.
PARQUET
Lädt die Daten aus einer Datei im Parquet-Format.
# Dateikomprimierungsparameter
Sie können Daten aus komprimierten Datendateien laden, indem Sie die folgenden Parameter angeben. Dateikomprimierungsparameter
BZIP2
Ein Wert, der angibt, dass die Eingabedatei oder die Eingabedateien das komprimierte bzip2-Format (.bz2-Dateien) aufweist/aufweisen. Die COPY-Operation liest jede komprimierte Datei und entkomprimiert die Daten während des Ladens.
GZIP
Ein Wert, der angibt, dass die Eingabedatei oder die Eingabedateien das komprimierte gzip-Format (.gz-Dateien) aufweist/aufweisen. Die COPY-Operation liest jede komprimierte Datei und entkomprimiert die Daten während des Ladens.
LZOP
Ein Wert, der angibt, dass die Eingabedatei oder die Eingabedateien das komprimierte lzop-Format (.lzo-Dateien) aufweist/aufweisen. Die COPY-Operation liest jede komprimierte Datei und entkomprimiert die Daten während des Ladens.
COPY unterstützt keine Dateien, die mittels der lzop-Option *--filter* komprimiert wurden.
ZSTD
Ein Wert, der angibt, dass die Eingabedatei oder die Eingabedateien das komprimierte Zstandard-Format (.zst-Dateien) aufweist/aufweisen. Die COPY-Operation liest jede komprimierte Datei und entkomprimiert die Daten während des Ladens.
ZSTD wird nur für COPY aus Amazon S3 unterstützt.
# Datenkonvertierungsparameter
Wenn COPY die Tabelle lädt, versucht der Befehl implizit, die Zeichenfolgen in den Quelldaten in den Datentyp der Zielspalte zu konvertieren. Wenn Sie eine Konvertierung angeben müssen, die sich vom Standardverhalten unterscheidet, oder wenn die Standardkonvertierung zu Fehlern führt, können Sie Datenkonvertierungen verwalten, indem Sie die folgenden Parameter angeben. Weitere Informationen zur Syntax dieser Parameter finden Sie unter [COPY-Syntax](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax).
+ [ACCEPTANYDATE](#copy-acceptanydate)
+ [ACCEPTINVCHARS](#copy-acceptinvchars)
+ [BLANKSASNULL](#copy-blanksasnull)
+ [DATEFORMAT](#copy-dateformat)
+ [EMPTYASNULL](#copy-emptyasnull)
+ [ENCODING](#copy-encoding)
+ [ESCAPE](#copy-escape)
+ [EXPLICIT_IDS](#copy-explicit-ids)
+ [FILLRECORD](#copy-fillrecord)
+ [IGNOREBLANKLINES](#copy-ignoreblanklines)
+ [IGNOREHEADER](#copy-ignoreheader)
+ [NULL AS](#copy-null-as)
+ [REMOVEQUOTES](#copy-removequotes)
+ [ROUNDEC](#copy-roundec)
+ [TIMEFORMAT](#copy-timeformat)
+ [TRIMBLANKS](#copy-trimblanks)
+ [TRUNCATECOLUMNS](#copy-truncatecolumns) Datenkonvertierungsparameter
ACCEPTANYDATE
Ermöglicht das Laden jedes Datumsformats einschließlich ungültiger Formate wie `00/00/00 00:00:00`, ohne dass ein Fehler generiert wird. Dieser Parameter gilt nur für die Spalten TIMESTAMP und DATE. Verwenden Sie ACCEPTANYDATE stets mit dem Parameter DATEFORMAT. Wenn das Datumsformat für die Daten nicht der Spezifikation DATEFORMAT entspricht, fügt Amazon Redshift einen NULL-Wert in das betreffende Feld ein.
ACCEPTINVCHARS [AS] ['*replacement\$1char*']
Ermöglicht das Laden von Daten in VARCHAR-Spalten, auch wenn die Daten ungültige UTF-8-Zeichen enthalten. Wenn ACCEPTINVCHARS angegeben ist, ersetzt COPY jedes ungültige UTF-8-Zeichen durch eine Zeichenfolge mit gleicher Länge, die aus dem Zeichen besteht, das von *replacement\$1char* angegeben wird. Wenn das Ersetzungszeichen beispielsweise `^` ist, wird ein ungültiges Zeichen mit drei Bytes durch `^^^` ersetzt.
Das Ersetzungszeichen kann aus jedem ASCII-Zeichen außer NULL bestehen. Der Standardwert ist das Fragezeichen (?). Informationen zu ungültigen UTF-8-Zeichen finden Sie unter [Fehler beim Laden von Multibyte-Zeichen](multi-byte-character-load-errors.md).
COPY gibt die Anzahl der Zeilen mit ungültigen UTF-8-Zeichen zurück und fügt der Systemtabelle [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md) einen Eintrag für jede betroffene Zeile hinzu (bis zu maximal 100 Zeilen pro Knoten-Slice). Zusätzliche ungültige UTF-8-Zeichen werden ebenfalls ersetzt. Diese Ersetzungsereignisse werden jedoch nicht aufgezeichnet.
Wenn ACCEPTINVCHARS nicht angegeben ist, gibt COPY einen Fehler zurück, wenn der Befehl auf ein ungültiges UTF-8-Zeichen trifft.
ACCEPTINVCHARS ist nur für VARCHAR-Spalten gültig.
BLANKSASNULL
Lädt leere Felder, die nur aus Leerzeichen bestehen, als NULL. Diese Option gilt nur für CHAR- und VARCHAR-Spalten. Leere Felder für andere Datentypen, beispielsweise INT, werden stets mit NULL geladen. Beispielsweise wird eine Zeichenfolge, die drei aufeinanderfolgende Leerzeichen (und keine anderen Zeichen) enthält, als NULL geladen. Das Standardverhalten (ohne Angabe dieser Option) besteht im Laden der Leerzeichen wie vorhanden.
DATEFORMAT [AS] \$1'*dateformat\$1string*' \$1 'auto' \$1
Wenn kein DATEFORMAT angegeben ist, ist das Standardformat `'YYYY-MM-DD'`. Ein alternatives gültiges Format ist beispielsweise `'MM-DD-YYYY'`.
Wenn der COPY-Befehl das Format Ihrer Datums- oder Zeitwerte nicht erkennt oder Ihre Datums- oder Zeitwerte unterschiedliche Formate verwenden, verwenden Sie das Argument `'auto'` mit dem Parameter DATEFORMAT oder TIMEFORMAT. Das Argument `'auto'` erkennt verschiedene Formate, die bei der Verwendung einer DATEFORMAT- und TIMEFORMAT-Zeichenfolge nicht unterstützt werden. Das Schlüsselwort `'auto'` unterscheidet zwischen Groß- und Kleinschreibung. Weitere Informationen finden Sie unter [Verwenden der automatischen Erkennung bei DATEFORMAT und TIMEFORMAT](automatic-recognition.md).
Das Datumsformat kann Zeitinformationen (Stunde, Minuten, Sekunden) enthalten. Diese Informationen werden jedoch ignoriert. Das Schlüsselwort AS ist optional. Weitere Informationen finden Sie unter [DATEFORMAT- und TIMEFORMAT-ZeichenfolgenBeispiel](r_DATEFORMAT_and_TIMEFORMAT_strings.md).
EMPTYASNULL
Zeigt an, dass Amazon Redshift leere CHAR- und VARCHAR-Felder als NULL laden soll. Leere Felder für andere Datentypen, beispielsweise INT, werden stets mit NULL geladen. Leere Felder treten auf, wenn Daten zwei aufeinanderfolgende Trennzeichen enthalten, ohne dass sich zwischen den Trennzeichen Zeichen befinden. EMPTYASNULL und NULL AS '' (leere Zeichenfolge) führen zum selben Verhalten.
ENCODING [AS] *file\$1encoding*
Gibt den Kodierungstyp der Daten an, die geladen werden. Der COPY-Befehl konvertiert während des Ladens die Daten aus der angegebenen Kodierung in UTF-8.
Gültige Werte für *file\$1encoding* sind folgende:
+ `UTF8`
+ `UTF16`
+ `UTF16LE`
+ `UTF16BE`
+ `ISO88591`
Der Standardwert ist `UTF8`.
Quelldateinamen müssen UTF-8-Kodierung verwenden.
Die folgenden Dateien müssen UTF-8-Kodierung verwenden, auch wenn für die Daten, die geladen werden, eine andere Kodierung angegeben ist:
+ Manifestdateien
+ JSONPaths Dateien
Die mit den folgenden Parametern bereitgestellten Argumentzeichenfolgen müssen UTF-8 verwenden:
+ FIXEDWIDTH '*fixedwidth\$1spec*'
+ ACCEPTINVCHARS '*replacement\$1char*'
+ DATEFORMAT '*dateformat\$1string*'
+ TIMEFORMAT '*timeformat\$1string*'
+ NULL AS '*null\$1string*'
Datendateien mit fester Breite müssen UTF-8-Kodierung verwenden. Die Feldbreiten basieren auf der Anzahl der Zeichen, nicht der Bytes.
Alle geladenen Daten müssen die angegebene Kodierung verwenden. Wenn COPY auf eine andere Kodierung trifft, werden die Datei übersprungen und ein Fehler zurückgegeben.
Wenn Sie `UTF16` angeben, müssen Ihre Daten eine Byte-Reihenfolgenmarkierung (Byte Order Mark, BOM) besitzen. Wenn Sie wissen, ob Ihre UTF-16-Daten little-endian (LE) oder big-endian (BE) sind, können Sie unabhängig vom Vorhandensein einer BOM `UTF16LE` oder `UTF16BE` verwenden.
Um die Kodierung ISO-8859-1 zu verwenden, geben Sie `ISO88591` an. Weitere Informationen finden Sie unter [ISO/IEC 8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) in *Wikipedia*.
ESCAPE
Wenn dieser Parameter angegeben ist, wird das Backslash-Zeichen (`\`) in Eingabedaten als Escape-Zeichen behandelt. Das Zeichen, das dem Backslash-Zeichen folgt, wird als Teil des aktuellen Spaltenwerts in die Tabelle geladen, auch wenn es sich um ein Zeichen handelt, das normalerweise einem speziellen Zweck dient. Sie können diesen Parameter beispielsweise verwenden, um das Trennzeichen, ein Fragezeichen, ein eingebettetes Zeichen für neue Zeilen oder das Escape-Zeichen selbst mit einer Escape-Markierung zu markieren, wenn eines dieser Zeichen legitimer Teil eines Spaltenwerts ist.
Wenn Sie den Parameter ESCAPE in Kombination mit dem Parameter REMOVEQUOTES angeben, können Sie Anführungszeichen (`'` oder `"`) mit Escape-Zeichen markieren und beibehalten, die ansonsten möglicherweise entfernt würden. Die standardmäßige Null-Zeichenfolge `\N` funktioniert wie vorhanden, kann jedoch in den Eingabedaten ebenfalls mit einem Escape-Zeichen markiert werden: `\\N`. Solange sie keine alternative Null-Zeichenfolge mit dem Parameter NULL AS angeben, führen `\N` und `\\N` zu denselben Ergebnissen.
Das Steuerzeichen `0x00` (NUL) kann nicht mit einem Escape-Zeichen markiert werden und sollte aus den Eingabedaten entfernt werden oder konvertiert werden. Dieses Zeichen wird als Markierung für das Ende von Datensätzen (End of Record, EOR) verwendet, was dazu führt, dass der Rest des Datensatzes abgeschnitten wird.
Sie können den Parameter ESCAPE nicht bei FIXEDWIDTH-Ladevorgängen verwenden. Darüber hinaus können Sie das Escape-Zeichen selbst nicht angeben; das Escape Zeichen ist stets das Backslash-Zeichen. Außerdem müssen Sie sicherstellen, dass die Eingabedaten das Escape-Zeichen an den richtigen Stellen enthalten.
Im Folgenden finden Sie einige Beispiele für Eingabedaten und die entsprechenden geladenen Daten, wenn der Parameter ESCAPE angegeben ist. Das Ergebnis für Zeile 4 geht davon aus, dass der Parameter REMOVEQUOTES ebenfalls angegeben ist. Die Eingabedaten bestehen aus zwei Feldern, die durch das Pipe-Zeichen getrennt sind:
```
1|The quick brown fox\[newline]
jumped over the lazy dog.
2| A\\B\\C
3| A \| B \| C
4| 'A Midsummer Night\'s Dream'
```
Die Daten, die in Spalte 2 geladen wurden, sehen wie folgt aus:
```
The quick brown fox
jumped over the lazy dog.
A\B\C
A|B|C
A Midsummer Night's Dream
```
Die Anwendung des Escape-Zeichens auf die Eingabedaten, die geladen werden sollen, liegt in der Verantwortung der Benutzer. Eine Ausnahme für diese Anforderung liegt dann vor, wenn Sie Daten erneut laden, die zuvor mit dem Parameter ESCAPE entladen wurden. In diesem Fall enthalten die Daten die notwendigen Escape-Zeichen bereits.
Der Parameter ESCAPE interpretiert keine Oktal-, Hex-, Unicode- oder andere Escape-Sequenznotierungen. Wenn Ihre Quelldaten beispielsweise den oktalen Zeilen-Feed-Wert (`\012`) enthalten und Sie versuchen, diese Daten mit dem Parameter ESCAPE zu laden, lädt Amazon Redshift den Wert `012` in die Tabelle und interpretiert diesen Wert nicht als Zeilen-Feed, der mit einem Escape-Zeichen markiert wurde.
Um in Daten, die aus Microsoft Windows-Plattformen stammen, das Zeichen für neue Zeilen mit einem Escape-Zeichen zu markieren, müssen Sie möglicherweise zwei Escape-Zeichen verwenden: ein Zeichen für die Zeilenumschaltung und ein Zeichen für den Zeilen-Feed. Alternativ können Sie die Zeilenumschaltungen vor dem Laden der Datei entfernen (beispielsweise durch Verwendung des Hilfsprogramms dos2unix).
EXPLICIT\$1IDS
Verwenden Sie EXPLICIT\$1IDS für Tabellen, die IDENTITY-Spalten besitzen, wenn Sie die automatisch generierten Werte durch explizite Werte aus den Quelldatendateien für die Tabellen überschreiben möchten. Wenn der Befehl eine Spaltenliste enthält, muss diese Liste die IDENTITY-Spalten enthalten, um diesen Parameter verwenden zu können. Das Datenformat für EXPLICIT\$1IDS-Werte muss mit dem IDENTITY-Format übereinstimmen, das von der Definition CREATE TABLE angegeben wird.
Nachdem Sie einen COPY-Befehl mit der EXPLICIT\$1IDS-Option für eine Tabelle ausgeführt haben, überprüft Amazon Redshift die Eindeutigkeit von IDENTITY-Spalten in der Tabelle nicht.
Wenn eine Spalte mit GENERATED BY DEFAULT AS IDENTITY definiert ist, kann sie kopiert werden. Die Werte werden mit den von Ihnen angegebenen Werten generiert oder aktualisiert. Die Option EXPLICIT\$1IDS ist nicht erforderlich. COPY aktualisiert nicht die Identity High Watermark.
Ein Beispiel für einen COPY-Befehl mit EXPLICIT\$1IDS finden Sie unter [Laden von VENUE mit expliziten Werte für eine IDENTITY-Spalte](r_COPY_command_examples.md#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column).
FILLRECORD
Ermöglicht das Laden von Datendateien, wenn am Ende einiger Datensätze angrenzende Spalten fehlen. Die fehlenden Spalten werden geladen als NULLs. Wenn es sich bei der fehlenden Spalte bei Text- und CSV-Formaten um eine VARCHAR-Spalte handelt, werden stattdessen leere Zeichenketten geladen. NULLs Um Daten aus Text und CSV NULLs in VARCHAR-Spalten zu laden, geben Sie das Schlüsselwort EMPTYASNULL an. Die NULL-Ersetzung funktioniert nur, wenn die Spaltendefinition dies zulässt. NULLs
Wenn die Tabellendefinition beispielsweise vier nullwertfähige CHAR-Spalten enthält und ein Datensatz die Werte `apple, orange, banana, mango` enthält, könnte der COPY-Befehl einen Datensatz laden und ausfüllen, der nur die Werte `apple, orange` enthält. Die fehlenden CHAR-Werte würden als NULL-Werte geladen.
IGNOREBLANKLINES
Ignoriert leere Zeilen, die nur einen Zeilen-Feed in einer Datendatei enthalten, und versucht nicht, sie zu laden.
IGNOREHEADER [ AS ] *number\$1rows*
Behandelt die angegebene *number\$1rows* als Dateiheader und lädt sie nicht. Sie verwenden IGNOREHEADER, um in einem parallelen Ladevorgang Dateiheader in allen Dateien zu überspringen.
NULL AS '*null\$1string*'
Lädt Felder, die mit *null\$1string* als NULL übereinstimmen, wobei *null\$1string* jede Zeichenfolge sein kann. Wenn Ihre Daten einen Null-Terminator enthalten, auch als NUL (UTF-8 0000) oder Binär-Null (0x000) bezeichnet, behandelt COPY diesen als ein beliebiges anderes Zeichen. Zum Beispiel wird ein Datensatz, der '1' \$1\$1 NUL \$1\$1 '2' enthält, als Zeichenkette der Länge 3 Bytes kopiert. Wenn ein Feld nur NUL enthält, können Sie NULL AS verwenden, um den Nullterminator durch NULL zu ersetzen, indem Sie `'\0'` oder `'\000'`angeben, z. B. `NULL AS '\0'` oder `NULL AS '\000'`. Wenn ein Feld eine Zeichenfolge enthält, die mit NUL endet, und NULL AS angegeben ist, wird die Zeichenfolge mit NUL am Ende eingefügt. Verwenden Sie für den *null\$1string*-Wert nicht '\$1n' (Zeilenumbruch). Amazon Redshift reserviert '\$1n' für die Verwendung als Zeilentrennzeichen. Der Standardwert für *null\$1string* ist `'\N`'.
Wenn Sie versuchen, Null-Werte in eine Spalte zu laden, die als NOT NULL definiert ist, schlägt der Befehl COPY fehl.
REMOVEQUOTES
Entfernt in den eingehenden Daten Anführungszeichen, die Zeichenfolgen umschließen. Alle Zeichen innerhalb der Anführungszeichen einschließlich Trennzeichen bleiben bewahrt. Wenn eine Zeichenfolge mit einem einfachen oder doppelten Anführungszeichen beginnt, es jedoch kein entsprechendes schließendes Anführungszeichen gibt, lädt der COPY-Befehl diese Zeile nicht und gibt einen Fehler zurück. In der folgenden Tabelle werden einige einfache Beispiele für Zeichenfolgen mit Anführungszeichen und die entsprechenden geladenen Werte gezeigt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/copy-parameters-data-conversion.html)
ROUNDEC
Rundet numerische Werte auf, wenn die Skala des Eingabewerts größer als die Skala der Spalte ist. Standardmäßig schneidet COPY Werte ab, wenn notwendig, um sie an die Spaltenskala anzupassen. Wenn beispielsweise der Wert `20.259` in eine DECIMAL(8,2)-Spalte geladen wird, schneidet COPY den Wert standardmäßig auf `20.25` ab. Wenn ROUNDEC angegeben ist, rundet COPY den Wert auf auf `20.26`. Der INSERT-Befehl rundet Werte stets, wenn notwendig, um sie an die Spaltenskala anzupassen. Daher weist ein COPY-Befehl mit dem Parameter ROUNDEC dasselbe Verhalten wie ein INSERT-Befehl auf.
TIMEFORMAT [AS] \$1'*timeformat\$1string*' \$1 'auto' \$1 'epochsecs' \$1 'epochmillisecs' \$1
Gibt das Zeitformat an. Wenn TIMEFORMAT nicht angegeben wird, ist das Standardformat `YYYY-MM-DD HH:MI:SS` für TIMESTAMP-Spalten oder `YYYY-MM-DD HH:MI:SSOF` für TIMESTAMPTZ-Spalten, wobei `OF` der Unterschied zur Coordinated Universal Time (UTC) ist. Sie können in der *Zeitformatzeichenfolge* keinen Zeitzonenspezifikator verwenden. Um TIMESTAMPTZ-Daten zu laden, die sich in einem anderen Format als dem Standardformat befinden, geben Sie 'auto' an. Weitere Informationen finden Sie unter [Verwenden der automatischen Erkennung bei DATEFORMAT und TIMEFORMAT](automatic-recognition.md). Weitere Informationen zu *timeformat\$1string* finden Sie unter [DATEFORMAT- und TIMEFORMAT-ZeichenfolgenBeispiel](r_DATEFORMAT_and_TIMEFORMAT_strings.md).
Das Argument `'auto'` erkennt verschiedene Formate, die bei der Verwendung einer DATEFORMAT- und TIMEFORMAT-Zeichenfolge nicht unterstützt werden. Wenn der COPY-Befehl das Format Ihrer Datums- oder Zeitwerte nicht erkennt oder Ihre Datums- oder Zeitwerte unterschiedliche verwenden, verwenden Sie das Argument `'auto'` mit dem Parameter DATEFORMAT oder TIMEFORMAT. Weitere Informationen finden Sie unter [Verwenden der automatischen Erkennung bei DATEFORMAT und TIMEFORMAT](automatic-recognition.md).
Wenn Ihre Quelldaten als Epochenzeit dargestellt werden, d. h. als Zahl der Sekunden oder Millisekunden seit dem 1. Januar 1970, 00:00:00 UTC, geben Sie `'epochsecs'` oder `'epochmillisecs'` an.
Die Schlüsselwörter `'auto'`, `'epochsecs'` und `'epochmillisecs'` unterscheiden zwischen Groß- und Kleinschreibung.
Das Schlüsselwort AS ist optional.
TRIMBLANKS
Entfernt Leerzeichen am Ende von VARCHAR-Zeichenfolgen. Dieser Parameter gilt nur für die Spalten mit dem Datentyp VARCHAR.
TRUNCATECOLUMNS
Schneidet Daten in Spalten auf die entsprechende Zahl von Zeichen ab, sodass sie der Spaltenspezifikation entsprechen. Gilt nur für Spalten mit dem Datentyp VARCHAR und CHAR und Zeilen mit einer Größe von 4 MB oder weniger.
# Datenladeoperationen
Verwalten Sie das Standardverhalten der Ladeoperation, um Fehler zu beheben oder die Ladezeiten zu reduzieren, indem Sie die folgenden Parameter angeben.
+ [COMPROWS](#copy-comprows)
+ [COMPUPDATE](#copy-compupdate)
+ [IGNOREALLERRORS](#copy-ignoreallerrors)
+ [MAXERROR](#copy-maxerror)
+ [NOLOAD](#copy-noload)
+ [STATUPDATE](#copy-statupdate) Parameters
COMPROWS *numrows*
Gibt die Anzahl der Zeilen an, die als Stichprobengröße für Kompressionsanalysen verwendet werden soll. Die Analyse wird für Zeilen aus jedem Daten-Slice ausgeführt. Wenn Sie beispielsweise `COMPROWS 1000000` (1.000.000) angeben und das System insgesamt vier Slices enthält, werden nicht mehr als 250.000 Zeilen pro Slice gelesen und analysiert.
Wenn COMPROWS nicht angegeben wird, werden standardmäßig 100.000 Zeilen pro Slice als Stichprobe analysiert. Werte für COMPROWS, die niedriger als der Standardwert von 100.000 Zeilen pro Slice sind, werden automatisch auf den Standardwert aktualisiert. Es findet jedoch keine automatische Kompression statt, wenn die Menge der geladenen Daten nicht für eine relevante Stichrobe reicht.
Wenn der Wert für COMPROWS größer als die Anzahl der Zeilen in der Eingabedatei ist, wird der Befehl COPY dennoch fortgesetzt und die Kompressionsanalyse wird für alle verfügbaren Zeilen ausgeführt. Der akzeptierte Bereich für dieses Argument ist eine Zahl zwischen 1000 und 2147483647 (2,147,483,647).
COMPUPDATE [ PRESET \$1 \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
Steuert, ob während einer COPY-Operation automatisch komprimierende Codierungen angewendet werden.
Während COMPUPDATE den Wert PRESET hat, wählt der COPY-Befehl die Komprimierungscodierung für jede Spalte, wenn die Zieltabelle leer ist. Dies gilt auch, wenn die Spalten bereits eine andere Codierung als RAW aufweisen. Aktuell angegebene Spaltenkodierungen können ersetzt werden. Die Codierung jeder Spalte basiert auf dem Datentyp der Spalte. Es werden keine Stichproben der Daten genommen. Amazon Redshift weist die Komprimierungskodierung automatisch wie folgt zu:
+ Spalten, die als Sortierschlüssel definiert sind, wird die RAW-Kompression zugewiesen.
+ Spalten, die als die Datentypen BOOLEAN, REAL oder DOUBLE PRECISION definiert sind, wird die RAW-Kodierung zugewiesen.
+ Spalten, die als SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIMESTAMP oder TIMESTAMPTZ definiert sind, wird Komprimierung zugewiesen. AZ64
+ Spalten, die als CHAR oder VARCHAR definiert sind, wird LZO-Komprimierung zugewiesen.
Wenn COMPUPDATE ausgelassen wird, wählt der COPY-Befehl die Komprimierungskodierung für die einzelnen Spalten nur dann aus, wenn die Zieltabelle leer ist und Sie keine Kodierung (außer RAW) für die Spalten angegeben haben. Die Kodierung einer jeden Spalte wird durch Amazon Redshift bestimmt. Es werden keine Stichproben der Daten genommen.
Wenn COMPUDATE auf ON (oder TRUE) festgelegt ist oder COMPUPDATE ohne Option angegeben wird, wendet der COPY-Befehl die automatische Komprimierung an, wenn die Tabelle leer ist, auch wenn die Tabellenspalten bereits andere Kodierungen als RAW aufweisen. Aktuell angegebene Spaltenkodierungen können ersetzt werden. Die Kodierung einer jeden Spalte basiert auf der Analyse von Stichprobendaten. Weitere Informationen finden Sie unter [Laden von Tabellen mit automatischer Kompression](c_Loading_tables_auto_compress.md).
Wenn COMPUPDATE auf OFF (oder FALSE eingestellt ist), wird die automatische Kompression deaktiviert. Spaltenkodierungen werden nicht geändert.
Informationen zur Systemtabelle für die Analyse der Komprimierung finden Sie unter [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md).
IGNOREALLERRORS
Sie können diese Option angeben, wenn alle Fehler, die während des Ladevorgangs auftreten, ignoriert werden sollen.
Sie können die Option IGNOREALLERRORS nicht angeben, wenn Sie die Option MAXERROR verwenden. Sie können die Option IGNOREALLERRORS nicht für spaltenbasierte Formate wie ORC und Parquet angeben.
MAXERROR [AS] *error\$1count*
Wenn der Ladevorgang *error\$1count* Fehler oder mehr zurückgibt, schlägt der Ladevorgang fehl. Wenn der Ladevorgang weniger Fehler zurückgibt, wird er fortgesetzt und gibt eine INFO-Meldung zurück, die die Anzahl der Zeilen angibt, die nicht geladen werden konnten. Sie verwenden diesen Parameter, um die Fortsetzung von Ladevorgängen zuzulassen, wenn bestimmte Zeilen aufgrund von Formatierungsfehlern oder aufgrund anderer Inkonsistenzen in den Daten nicht in die Tabelle geladen werden können.
Legen Sie diesen Wert auf `0` oder `1` fest, wenn der Ladevorgang fehlschlagen soll, sobald der erste Fehler auftritt. Das Schlüsselwort AS ist optional. Der Standardwert für MAXERROR ist `0` und das Limit ist `100000`.
Aufgrund der parallelen Struktur von Amazon Redshift kann die tatsächliche Zahl der gemeldeten Fehler größer als der für MAXERROR angegebene Wert sein. Wenn ein Knoten im Amazon-Redshift-Cluster feststellt, dass MAXERROR ausgeführt wurde, melden alle Knoten alle Fehler, die sie festgestellt haben.
NOLOAD
Prüft die Gültigkeit der Datendatei, ohne die Daten tatsächlich zu laden. Verwenden Sie den Parameter NOLOAD, um zu prüfen, ob die Datendatei ohne Fehler geladen wird, bevor der tatsächliche Datenladevorgang ausgeführt wird. COPY mit angegebenem Parameter NOLOAD ist sehr viel schneller als das Laden der Daten, da die Dateien lediglich analysiert werden.
STATUPDATE [ \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
Regelt die automatische Berechnung und die Aktualisierung der Optimierungsstatistik am Ende eines erfolgreichen COPY-Befehls. Wenn der Parameter STATUPDATE nicht verwendet wird, werden die Statistiken automatisch aktualisiert, wenn die Tabelle anfangs leer ist.
Wenn durch das Hinzufügen von Daten zu einer nicht leeren Tabelle die Größe der Tabelle erheblich verändert wird, sollten Sie die Statistik aktualisieren, indem Sie entweder einen [ANALYZE](r_ANALYZE.md)-Befehl ausführen oder das Argument STATUPDATE ON verwenden.
Bei Verwendung des Arguments STATUPDATE ON (oder TRUE) werden die Statistiken automatisch aktualisiert, unabhängig davon, ob die Tabelle anfangs leer ist. Wenn STATUPDATE verwendet wird, muss der aktuelle Benutzer entweder der Tabellenbesitzer oder ein Superuser sein. Wenn STATUPDATE nicht angegeben ist, ist nur die INSERT-Berechtigung erforderlich.
Bei Angabe von STATUPDATE OFF (oder FALSE) werden die Statistiken niemals aktualisiert.
Weitere Informationen finden Sie unter [Analysieren von Tabellen](t_Analyzing_tables.md).
# Alphabetische Liste der Parameter
In der folgenden List werden Links zur Beschreibung der einzelnen Parameter des COPY-Befehls in alphabetischer Reihenfolge bereitgestellt.
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [ACCESS\$1KEY\$1ID, SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id-access)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials-cred)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role-iam)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [MASTER_SYMMETRIC_KEY](copy-parameters-data-source-s3.md#copy-master-symmetric-key)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [READRATIO](copy-parameters-data-source-dynamodb.md#copy-readratio)
+ [REGION](copy-parameters-data-source-s3.md#copy-region)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [SSH](copy-parameters-data-source-ssh.md#copy-ssh)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
# Nutzungshinweise
**Topics**
+ [Berechtigungen AWS für den Zugriff auf andere Ressourcen](copy-usage_notes-access-permissions.md)
+ [Verwenden von COPY mit Amazon-S3-Zugriffspunkt-Aliasen](copy-usage_notes-s3-access-point-alias.md)
+ [Laden von Multibyte-Daten aus Amazon S3](copy-usage_notes-multi-byte.md)
+ [Laden einer Spalte des Datentyps GEOMETRY oder GEOGRAPHY](copy-usage_notes-spatial-data.md)
+ [Laden des Datentyps HLLSKETCH](copy-usage_notes-hll.md)
+ [Laden einer Spalte des Datentyps VARBYTE](copy-usage-varbyte.md)
+ [Fehler beim Lesen mehrerer Dateien](copy-usage_notes-multiple-files.md)
+ [COPY von JSON-Format](copy-usage_notes-copy-from-json.md)
+ [COPY aus spaltenbasierten Datenformaten](copy-usage_notes-copy-from-columnar.md)
+ [DATEFORMAT- und TIMEFORMAT-Zeichenfolgen](r_DATEFORMAT_and_TIMEFORMAT_strings.md)
+ [Verwenden der automatischen Erkennung bei DATEFORMAT und TIMEFORMAT](automatic-recognition.md)
# Berechtigungen AWS für den Zugriff auf andere Ressourcen
Um Daten zwischen Ihrem Cluster und einer anderen AWS Ressource wie Amazon S3, Amazon DynamoDB, Amazon EMR oder Amazon EC2 zu verschieben, muss Ihr Cluster über die Berechtigung verfügen, auf die Ressource zuzugreifen und die erforderlichen Aktionen auszuführen. Um beispielsweise Daten aus Amazon S3 zu laden, muss COPY über LIST-Zugriff auf den Bucket und GET-Zugriff auf die Bucket-Objekte verfügen. Weitere Informationen zu den mindestens erforderlichen Berechtigungen finden Sie unter [IAM-Berechtigungen für COPY, UNLOAD und CREATE LIBRARY](#copy-usage_notes-iam-permissions).
Um die Autorisierung für den Zugriff auf die Ressource zu erhalten, muss Ihr Cluster authentifiziert werden. Sie können eine der beiden folgenden Authentifizierungsmethoden verwenden:
+ [Rollenbasierte Zugriffskontrolle](#copy-usage_notes-access-role-based)— Für die rollenbasierte Zugriffskontrolle geben Sie eine AWS Identity and Access Management (IAM-) Rolle an, die Ihr Cluster für die Authentifizierung und Autorisierung verwendet. Um Ihre AWS Anmeldeinformationen und vertraulichen Daten zu schützen, empfehlen wir dringend, die rollenbasierte Authentifizierung zu verwenden.
+ [Schlüsselbasierte Zugriffssteuerung](#copy-usage_notes-access-key-based)— Für die schlüsselbasierte Zugriffskontrolle geben Sie die Zugangsdaten ( AWS Zugriffsschlüssel-ID und geheimer Zugriffsschlüssel) für einen Benutzer als Klartext an.
## Rollenbasierte Zugriffskontrolle
Mit einer rollenbasierten Zugriffssteuerung übernimmt Ihr Cluster vorübergehend in Ihrem Namen eine IAM-Rolle. Anschließend kann Ihr Cluster auf der Basis der Autorisierungen, die der Rolle gewährt wurden, auf die erforderlichen AWS -Ressourcen zugreifen.
Das Erstellen einer IAM-*Rolle* ähnelt insofern dem Erteilen von Berechtigungen für einen Benutzer, als es sich um eine AWS -Identität mit Berechtigungsrichtlinien handelt, die festlegen, welche Aktionen die Identität in AWS ausführen kann und welche nicht. Eine Rolle ist jedoch nicht einem einzigen Benutzer zugeordnet, sondern kann von allen Entitäten angenommen werden, die diese Rolle benötigen. Einer Rolle sind auch keine Anmeldeinformationen (Passwort oder Zugriffsschlüssel) zugeordnet. Wenn eine Rolle mit einem Cluster verknüpft ist, werden die Zugriffsschlüssel stattdessen dynamisch erstellt und dem Cluster bereitgestellt.
Wir empfehlen die Verwendung einer rollenbasierten Zugriffskontrolle, da sie zusätzlich zum Schutz Ihrer Anmeldeinformationen eine sicherere und detailliertere Steuerung des Zugriffs auf AWS Ressourcen und vertrauliche Benutzerdaten ermöglicht. AWS
Die rollenbasierte Authentifizierung bietet folgende Vorteile:
+ Sie können AWS Standard-IAM-Tools verwenden, um eine IAM-Rolle zu definieren und die Rolle mehreren Clustern zuzuordnen. Wenn Sie die Zugriffsrichtlinie für eine Rolle ändern, werden die Änderungen automatisch auf alle Cluster angewendet, die diese Rolle verwenden.
+ Sie können detaillierte IAM-Richtlinien definieren, die bestimmten Clustern und Datenbankbenutzern Berechtigungen für den Zugriff auf bestimmte Ressourcen und Aktionen gewähren. AWS
+ Ihr Cluster erhält temporäre Sitzungsanmeldeinformationen zur Laufzeit. Die Anmeldeinformationen werden wie benötigt aktualisiert, bis die Operation abgeschlossen ist. Wenn Sie schlüsselbasierte temporäre Anmeldeinformationen verwenden, schlägt die Operation fehl, wenn die temporären Anmeldeinformationen ablaufen, bevor die Operation abgeschlossen ist.
+ Die Zugriffsschlüssel-ID und die ID des geheimen Zugriffsschlüssels werden nicht übertragen oder im SQL-Code gespeichert.
Um die rollenbasierte Zugriffssteuerung zu verwenden, müssen Sie zunächst unter Verwendung des Amazon-Redshift-Servicerollentyps eine IAM-Rolle erstellen und die Rolle anschließend Ihrem Cluster hinzufügen. Die Rolle muss mindestens die in aufgelisteten Berechtigungen besitzen [IAM-Berechtigungen für COPY, UNLOAD und CREATE LIBRARY](#copy-usage_notes-iam-permissions). Schritte zum Erstellen einer IAM-Rolle und zum Anhängen dieser Rolle an Ihren Cluster finden Sie unter [Autorisieren von Amazon Redshift, in Ihrem Namen auf andere AWS Services zuzugreifen](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) im *Amazon Redshift* Management Guide.
Sie können über die Amazon-Redshift-Managementkonsole, die CLI oder eine API einem Cluster eine Rolle hinzufügen oder die Rollen anzeigen, die mit einem Cluster verknüpft sind. Weitere Informationen finden Sie unter [Verknüpfen einer IAM-Rolle mit einem Cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) im *Amazon-Redshift-Verwaltungshandbuch*.
Beim Erstellen einer IAM-Rolle gibt IAM einen Amazon-Ressourcennamen (ARN) für die Rolle zurück. Um eine IAM-Rolle anzugeben, geben Sie für den ARN der Rolle entweder den Parameter [Verwenden des Parameters IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role) oder den Parameter [Verwenden des Parameters CREDENTIALS](copy-parameters-authorization.md#copy-credentials) an.
Angenommen, die folgende Rolle ist dem Cluster angefügt.
```
"IamRoleArn": "arn:aws:iam::0123456789012:role/MyRedshiftRole"
```
Im folgenden Beispiel für den COPY-Befehl wird der Parameter IAM\$1ROLE mit dem ARN im vorherigen Beispiel verwendet, um Authentifizierung und Zugriff auf Amazon S3 bereitzustellen.
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Im folgenden Beispiel für den COPY-Befehl wird der Parameter CREDENTIALS verwendet, um die IAM-Rolle anzugeben.
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
credentials
'aws_iam_role=arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Darüber hinaus kann ein Superuser Datenbankbenutzern und -gruppen das Privileg ASSUMEROLE gewähren, um einer Rolle Zugriff auf COPY-Operationen zu ermöglichen. Weitere Informationen finden Sie unter [GRANT](r_GRANT.md).
## Schlüsselbasierte Zugriffssteuerung
Bei der schlüsselbasierten Zugriffskontrolle geben Sie die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel für einen IAM-Benutzer an, der berechtigt ist, auf die Ressourcen zuzugreifen, die die Daten enthalten. AWS Sie können entweder die Parameter [Verwenden der Parameter ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id) zusammen verwenden oder den Parameter [Verwenden des Parameters CREDENTIALS](copy-parameters-authorization.md#copy-credentials) verwenden.
**Anmerkung**
Es wird nachdrücklich empfohlen, eine IAM-Rolle für die Authentifizierung zu verwenden, statt eine Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel im Textformat bereitzustellen. Wenn Sie sich für die schlüsselbasierte Zugriffskontrolle entscheiden, verwenden Sie niemals Ihre AWS Kontoanmeldeinformationen (Root). Erstellen Sie stets einen IAM-Benutzer und geben Sie die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel für diesen Benutzer an. Schritte zum Erstellen eines IAM-Benutzers finden Sie unter [Erstellen eines IAM-Benutzers in Ihrem AWS -Konto](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
Um sich mit ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY zu authentifizieren, ersetzen Sie und durch die Zugriffsschlüssel-ID ** und den vollständigen ** geheimen Zugriffsschlüssel eines autorisierten Benutzers, wie unten gezeigt.
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY '';
```
Um sich mit dem CREDENTIALS-Parameter zu authentifizieren, ersetzen Sie ** und durch die Zugriffsschlüssel-ID und den ** vollständigen geheimen Zugriffsschlüssel eines autorisierten Benutzers, wie im Folgenden dargestellt.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=';
```
Der IAM-Benutzer muss mindestens die in aufgelisteten Berechtigungen besitzen [IAM-Berechtigungen für COPY, UNLOAD und CREATE LIBRARY](#copy-usage_notes-iam-permissions).
### Temporäre Sicherheitsanmeldeinformationen
Wenn Sie die schlüsselbasierte Zugriffssteuerung verwenden, können Sie den Zugriff weiter einschränken, den Benutzer auf Ihre Daten haben, indem Sie temporäre Sicherheitsanmeldeinformationen verwenden. Die rollenbasierte Authentifizierung verwendet automatisch temporäre Anmeldeinformationen.
**Anmerkung**
Es wird nachdrücklich empfohlen, die [role-based access control](#copy-usage_notes-access-role-based.phrase) zu verwenden, statt temporäre Anmeldeinformationen zu erstellen und Zugriffsschlüssel-ID und einen geheimen Zugriffsschlüssel in Form von reinem Text bereitzustellen. Die rollenbasierte Zugriffssteuerung verwendet automatisch temporäre Anmeldeinformationen.
Temporäre Sicherheitsanmeldeinformationen bieten erweiterte Sicherheit, da sie nur kurzlebig sind und nach ihrem Ablauf nicht erneut verwendet werden können. Die Zugriffsschlüssel-ID und der geheime Zugriffsschlüssel, die mit dem Token generiert werden, können nicht ohne das Token verwendet werden. Ein Benutzer, der diese temporären Sicherheitsanmeldeinformationen besitzt, kann auf Ihre Ressourcen nur solange zugreifen, bis die Anmeldeinformationen ablaufen.
Um Benutzern temporären Zugriff auf Ihre Ressourcen zu gewähren, rufen Sie AWS -Security-Token-Service (AWS STS) API-Operationen auf. Die AWS STS API-Operationen geben temporäre Sicherheitsanmeldeinformationen zurück, die aus einem Sicherheitstoken, einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel bestehen. Sie geben die temporären Sicherheitsanmeldeinformationen an die Benutzer aus, die temporären Zugriff auf Ihre Ressourcen benötigen. Bei diesen Benutzern kann es sich um vorhandene IAM-Benutzer oder um Benutzer außerhalb von AWS handeln. Weitere Informationen zum Erstellen temporärer Sicherheitsanmeldeinformationen finden Sie unter [Temporäre Sicherheitsanmeldeinformationen](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) im IAM-Benutzerhandbuch.
Sie können die [Verwenden der Parameter ACCESS\$1KEY\$1ID und SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id)-Parameter zusammen mit dem Parameter [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token) oder dem Parameter [Verwenden des Parameters CREDENTIALS](copy-parameters-authorization.md#copy-credentials) verwenden. Sie müssen auch die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel bereitstellen, die mit dem Token bereitgestellt wurden.
Um sich mit ACCESS\$1KEY\$1ID, SECRET\$1ACCESS\$1KEY und SESSION\$1TOKEN zu authentifizieren, ersetzen Sie, und wie im Folgenden gezeigt. ** ** **
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
Um die Authentifizierung mittels CREDENTIALS durchzuführen, fügen Sie `session_token=` in die Anmeldezeichenfolge ein wie im Folgenden gezeigt.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;session_token=';
```
Im folgenden Beispiel wird ein COPY-Befehl mit temporären Sicherheitsanmeldeinformationen gezeigt.
```
copy table-name
from 's3://objectpath'
access_key_id ''
secret_access_key ''
session_token '';
```
Im folgenden Beispiel wird die Tabelle LISTING unter Verwendung temporärer Anmeldeinformationen und Dateiverschlüsselung geladen.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
access_key_id ''
secret_access_key ''
session_token ''
master_symmetric_key ''
encrypted;
```
Im folgenden Beispiel wird die Tabelle LISTING unter Verwendung des Parameters CREDENTIALS mit temporären Anmeldeinformationen und Dateiverschlüsselung geladen.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
credentials
'aws_access_key_id=;aws_secret_access_key=;session_token=;master_symmetric_key='
encrypted;
```
**Wichtig**
Die temporären Sicherheitsanmeldeinformationen müssen für die gesamte Dauer der COPY- oder UNLOAD-Operation gültig sein. Wenn die temporären Sicherheitsanmeldeinformationen während der Operation ablaufen, schlägt der Befehl fehl und für die Transaktion wird ein Rollback ausgeführt. Wenn die temporären Sicherheitsanmeldeinformationen beispielsweise nach 15 Minuten ablaufen und die COPY-Operation eine Stunde benötigt, schlägt die Operation fehl, bevor sie abgeschlossen ist. Wenn Sie den rollenbasierten Zugriff verwenden, werden die temporären Sicherheitsanmeldeinformationen automatisch aktualisiert, bis die Operation abgeschlossen ist.
## IAM-Berechtigungen für COPY, UNLOAD und CREATE LIBRARY
Die IAM-Rolle oder der Benutzer, die bzw. der durch den Parameter CREDENTIALS referenziert wird, muss mindestens die folgenden Berechtigungen besitzen:
+ Für COPY aus Amazon S3 die LIST-Berechtigung für Amazon-S3-Buckets und die GET-Berechtigung für Amazon-S3-Objekte, die geladen werden, sowie die Manifestdatei, falls eine solche verwendet wird.
+ Für COPY von Amazon S3, Amazon EMR und Remote-Hosts (SSH) mit JSON-formatierten Daten die Berechtigung, die JSONPaths Datei auf Amazon S3 aufzulisten und abzurufen, falls eine verwendet wird.
+ Für COPY aus DynamoDB, SCAN- und DESCRIBE-Berechtigung für die DynamoDB-Tabelle, die geladen wird.
+ Für COPY aus einem Amazon-EMR-Cluster die Berechtigung für die `ListInstances`-Aktion auf dem Amazon EMR-Cluster.
+ Für UNLOAD zu Amazon S3, GET-, LIST- und PUT-Berechtigungen für den Amazon-S3-Bucket, in den die Datendateien entladen werden.
+ Für CREATE LIBRARY aus Amazon S3 die LIST-Berechtigung für Amazon-S3-Buckets und die GET-Berechtigung für die zu importierenden Amazon-S3-Objekte.
**Anmerkung**
Wenn Sie bei Ausführung eines COPY-, UNLOAD- oder CREATE LIBRARY-Befehls die Fehlermeldung `S3ServiceException: Access Denied` erhalten, besitzt Ihr Cluster nicht die korrekten Zugriffsberechtigungen für Amazon S3.
Sie können IAM-Berechtigungen verwalten, indem Sie einer IAM-Rolle, die Ihrem Cluster angefügt ist, Ihrem Benutzer oder der Gruppe, zu der Ihr Benutzer gehört, eine IAM-Richtlinie anfügen. Beispielsweise gewährt die verwaltete `AmazonS3ReadOnlyAccess`-Richtlinie LIST- und GET-Berechtigungen in Bezug auf Amazon-S3-Ressourcen. Weitere Informationen zu IAM-Richtlinien finden Sie unter [Verwalten von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) im *IAM-Benutzerhandbuch*.
# Verwenden von COPY mit Amazon-S3-Zugriffspunkt-Aliasen
COPY 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*.
# Laden von Multibyte-Daten aus Amazon S3
Wenn Ihre Daten Multibyte-Zeichen enthalten, die andere als ASCII-Zeichen verwenden (beispielsweise chinesische oder kyrillische Zeichen), müssen Sie die Daten in VARCHAR-Spalten laden. Der VARCHAR-Datentyp unterstützt UTF-8-Zeichen mit vier Bytes. Der CHAR-Datentyp unterstützt jedoch nur ASCII-Zeichen mit einem Byte. Sie können keine Zeichen mit fünf Bytes oder mehr in Amazon-Redshift-Tabellen laden. Weitere Informationen finden Sie unter [Multibyte-Zeichen](c_Supported_data_types.md#c_Supported_data_types-multi-byte-characters).
# Laden einer Spalte des Datentyps GEOMETRY oder GEOGRAPHY
COPY in `GEOMETRY`- oder `GEOGRAPHY`-Spalten funktioniert nur aus Daten in einer zeichengetrennten Textdatei, z. B. einer CSV-Datei. Die Daten müssen in hexadezimaler Form des Well-Known-Binary-Formats (WKB oder EWKB) oder des Well-Known-Text-Formats (WKT oder EWKT) vorliegen und der maximalen Größe einer einzelnen Eingabezeile im COPY-Befehl angepasst sein. Weitere Informationen finden Sie unter [COPY](r_COPY.md).
Weitere Informationen zum Laden aus einem Shapefile finden Sie unter [Laden eines Shapefile in Amazon Redshift](spatial-copy-shapefile.md).
Weitere Informationen zum `GEOMETRY`- oder `GEOGRAPHY`-Datentyp finden Sie unter [Abfrage von Geodaten in Amazon Redshift](geospatial-overview.md).
# Laden des Datentyps HLLSKETCH
Sie können HLL-Skizzen nur im Sparse- oder Dense-Format kopieren, das von Amazon Redshift unterstützt wird. Um den Befehl COPY für HyperLogLog Skizzen zu verwenden, verwenden Sie das Base64-Format für dichte Skizzen und das JSON-Format für HyperLogLog Skizzen mit geringer Dichte. HyperLogLog Weitere Informationen finden Sie unter [HyperLogLog Funktionen](hyperloglog-functions.md).
Das folgende Beispiel importiert Daten aus einer CSV-Datei in eine Tabelle mit CREATE TABLE und COPY. Im Beispiel wird zunächst die Tabelle `t1` mit CREATE TABLE erstellt.
```
CREATE TABLE t1 (sketch hllsketch, a bigint);
```
Dann werden mit COPY Daten aus einer CSV-Datei in die Tabelle importiert `t1`.
```
COPY t1 FROM s3://amzn-s3-demo-bucket/unload/' IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole' NULL AS 'null' CSV;
```
# Laden einer Spalte des Datentyps VARBYTE
Sie können Daten aus einer Datei im CSV-, Parquet- und ORC-Format laden. Bei Verwendung des CSV-Formats werden die Daten aus einer Datei in hexadezimaler Darstellung der VARBYTE-Daten geladen. Sie können keine VARBYTE-Daten mit der `FIXEDWIDTH`-Option laden. Die COPY-Optionen `ADDQUOTES` und `REMOVEQUOTES` werden nicht unterstützt. VARBYTE-Spalten können nicht als Partitionsspalten verwendet werden.
# Fehler beim Lesen mehrerer Dateien
Der COPY-Befehl ist atomisch und transaktional. Mit anderen Worten, der gesamte Prozess wird als einzelne Transaktion behandelt, auch wenn der COPY-Befehl Daten aus mehreren Dateien liest. Wenn COPY beim Lesen einer Datei auf einen Fehler trifft, wird der Vorgang automatisch wiederholt, bis die Prozesszeit abläuft (siehe [statement\$1timeout](r_statement_timeout.md)) oder wenn über einen längeren Zeitraum (zwischen 15 und 30 Minuten) keine Daten aus Amazon S3 heruntergeladen werden können. Dabei wird sichergestellt, dass jede Datei nur einmal geladen wird. Wenn der COPY-Befehl fehlschlägt, wird die gesamte Transaktion abgebrochen und es wird ein Rollback für alle Änderungen ausgeführt. Weitere Informationen zur Handhabung von Fehlern beim Laden finden Sie unter [Fehlerbehebung bei Datenladevorgängen](t_Troubleshooting_load_errors.md).
Wenn ein COPY-Befehl erfolgreich gestartet wurde, schlägt er nicht fehl, wenn die Sitzung beendet wird, beispielsweise, wenn die Verbindung des Clients getrennt wird. Wenn sich der COPY-Befehl jedoch innerhalb eines BEGIN … END-Transaktionsblocks befindet, der nicht abgeschlossen wird, weil die Sitzung beendet wird, wird für die gesamte Transaktion einschließlich der COPY-Operation ein Rollback ausgeführt. Weitere Informationen Transaktionen finden Sie unter [BEGIN](r_BEGIN.md).
# COPY von JSON-Format
Die JSON-Datenstruktur besteht aus einem Satz von Objekten oder Arrays. Ein JSON-*Objekt* beginnt und endet mit geschweiften Klammern und enthält eine nicht geordnete Sammlung von Name-Wert-Paaren. Jeder Name und jeder Wert werden durch einen Doppelpunkt getrennt und die Paare werden durch Kommas getrennt. Der Name ist eine Zeichenfolge in doppelten Anführungszeichen. Bei den Anführungszeichen muss es sich um normale Anführungszeichen (0x22) handeln. Es dürfen keine schrägen oder „smarte“ doppelte Anführungszeichen sein.
Ein JSON-*Array* beginnt und endet mit eckigen Klammern und enthält eine geordnete Sammlung von Werten, getrennt durch Kommas. Ein Wert kann eine Zeichenfolge in doppelten Anführungszeichen, eine Zahl, ein boolescher Wert (wahr oder falsch), null, ein JSON-Objekt oder ein Array sein.
JSON-Objekte und -Arrays können verschachtelt sein, was eine hierarchische Datenstruktur ermöglicht. Im folgenden Beispiel wird eine JSON-Datenstruktur mit zwei gültigen Objekten gezeigt.
```
{
"id": 1006410,
"title": "Amazon Redshift Database Developer Guide"
}
{
"id": 100540,
"name": "Amazon Simple Storage Service User Guide"
}
```
Im Folgenden werden dieselben Daten als zwei JSON-Arrays gezeigt.
```
[
1006410,
"Amazon Redshift Database Developer Guide"
]
[
100540,
"Amazon Simple Storage Service User Guide"
]
```
## COPY-Optionen für JSON
Sie können die folgenden Optionen angeben, wenn Sie COPY mit Daten im JSON-Format verwenden:
+ `'auto' ` – COPY lädt automatisch Felder aus der JSON-Datei.
+ `'auto ignorecase'` – COPY lädt automatisch Felder aus der JSON-Datei, die Groß-/Kleinschreibung von Feldnamen wird ignoriert.
+ `s3://jsonpaths_file`— COPY verwendet eine JSONPaths Datei, um die JSON-Quelldaten zu analysieren. Eine *JSONPaths Datei* ist eine Textdatei, die ein einzelnes JSON-Objekt enthält, dessen Name mit einer Reihe von JSONPath Ausdrücken `"jsonpaths"` gepaart ist. Handelt es sich bei dem Namen um eine andere Zeichenfolge als`"jsonpaths"`, verwendet COPY das `'auto'` Argument anstelle der JSONPaths Datei.
Beispiele, die zeigen, wie Daten mithilfe von`'auto'`, oder einer JSONPaths Datei geladen werden`'auto ignorecase'`, wobei entweder JSON-Objekte oder Arrays verwendet werden, finden Sie unter[Beispiele für die COPY-Operation aus JSON](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json).
## JSONPath Option
In der Amazon Redshift COPY-Syntax gibt ein JSONPath Ausdruck den expliziten Pfad zu einem einzelnen Namenselement in einer hierarchischen JSON-Datenstruktur an, wobei entweder Klammern oder Punkte verwendet werden. Amazon Redshift unterstützt keine JSONPath Elemente wie Platzhalterzeichen oder Filterausdrücke, die zu einem mehrdeutigen Pfad oder mehreren Namenselementen aufgelöst werden könnten. Daher kann Amazon Redshift keine komplexen Datenstrukturen mit mehreren Ebenen analysieren.
Im Folgenden finden Sie ein Beispiel für eine JSONPaths Datei mit JSONPath Ausdrücken, die die Klammernotation verwenden. Das Dollarzeichen (\$1) stellt die Stammebenenstruktur dar.
```
{
"jsonpaths": [
"$['id']",
"$['store']['book']['title']",
"$['location'][0]"
]
}
```
Im vorherigen Beispiel referenziert `$['location'][0]` das erste Element in einem Array. JSON verwendet eine nullbasierte Array-Indizierung. Bei Array-Indizes muss es sich um positive Ganzzahlen handeln (größer als oder gleich null).
Das folgende Beispiel zeigt die vorherige JSONPaths Datei in Punktnotation.
```
{
"jsonpaths": [
"$.id",
"$.store.book.title",
"$.location[0]"
]
}
```
Sie können Klammer- und Punktnotierung im `jsonpaths`-Array nicht mischen. Eckige Klammern können sowohl in der Klammer- als auch in der Punktnotierung verwendet werden, um ein Array-Element zu referenzieren.
Bei Verwendung der Punktnotation dürfen die JSONPath Ausdrücke die folgenden Zeichen nicht enthalten:
+ Einfache gerade Anführungszeichen (')
+ Punkt (.)
+ Eckige Klammern ([]), es sei denn, sie werden verwendet, um ein Array-Element zu referenzieren
Wenn es sich bei dem Wert in dem Name-Wert-Paar, auf das ein JSONPath Ausdruck verweist, um ein Objekt oder ein Array handelt, wird das gesamte Objekt oder die Matrix als Zeichenfolge geladen, einschließlich der geschweiften Klammern. Angenommen, Ihre JSON-Daten enthalten das folgende Objekt.
```
{
"id": 0,
"guid": "84512477-fa49-456b-b407-581d0d851c3c",
"isActive": true,
"tags": [
"nisi",
"culpa",
"ad",
"amet",
"voluptate",
"reprehenderit",
"veniam"
],
"friends": [
{
"id": 0,
"name": "Martha Rivera"
},
{
"id": 1,
"name": "Renaldo"
}
]
}
```
Der JSONPath Ausdruck gibt `$['tags']` dann den folgenden Wert zurück.
```
"["nisi","culpa","ad","amet","voluptate","reprehenderit","veniam"]"
```
Der JSONPath Ausdruck gibt `$['friends'][1]` dann den folgenden Wert zurück.
```
"{"id": 1,"name": "Renaldo"}"
```
Jeder JSONPath Ausdruck im `jsonpaths` Array entspricht einer Spalte in der Amazon Redshift Redshift-Zieltabelle. Die Reihenfolge der `jsonpaths`-Array-Elemente muss der Reihenfolge der Spalten in der Zieltabelle oder Spaltenliste entsprechen, wenn eine Spaltenliste verwendet wird.
Beispiele, die zeigen, wie Daten entweder mit dem `'auto'` Argument oder einer JSONPaths Datei geladen werden und dabei entweder JSON-Objekte oder Arrays verwendet werden, finden Sie unter. [Beispiele für die COPY-Operation aus JSON](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json)
Informationen zum Kopieren mehrerer JSON-Dateien finden Sie unter [Verwenden eines Manifests für die Angabe von Datendateien](loading-data-files-using-manifest.md).
## Escape-Zeichen in JSON
COPY lädt `\n` als Zeichen für neue Zeilen und `\t` als Tabulatorzeichen. Um einen Backslash zu laden, muss ein Backslash als Escape-Zeichen verwendet werden ( `\\` ).
Angenommen, es gibt die folgenden JSON-Daten in einer Datei namens `escape.json` im Bucket `s3://amzn-s3-demo-bucket/json/`.
```
{
"backslash": "This is a backslash: \\",
"newline": "This sentence\n is on two lines.",
"tab": "This sentence \t contains a tab."
}
```
Führen Sie die folgenden Befehle aus, um die Tabelle ESCAPES zu erstellen und JSON zu laden.
```
create table escapes (backslash varchar(25), newline varchar(35), tab varchar(35));
copy escapes from 's3://amzn-s3-demo-bucket/json/escape.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as json 'auto';
```
Führen Sie eine Abfrage für die Tabelle ESCAPES aus, um die Ergebnisse anzuzeigen.
```
select * from escapes;
backslash | newline | tab
------------------------+-------------------+----------------------------------
This is a backslash: \ | This sentence | This sentence contains a tab.
: is on two lines.
(1 row)
```
## Verlust der numerischen Präzision
Wenn Sie Zahlen aus Datendateien im JSON-Format in eine Spalte laden, die als numerischer Datentyp formatiert ist, geht möglicherweise die Präzision verloren. Einige Gleitpunktwerte werden in Rechnersystemen nicht genau dargestellt. Dies hat zur Folge, dass aus einer JSON-Datei kopierte Daten nicht wie von Ihnen erwartet gerundet werden. Um einen Verlust der Präzision zu vermeiden, raten wir zur Verwendung einer der folgenden Alternativen:
+ Stellen Sie die Zahl als eile Zeichenfolge dar, deren Wert in doppelte Anführungszeichen gesetzt wird.
+ Verwenden Sie [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec), um die Zahl zu runden, anstatt sie zu kürzen.
+ Verwenden Sie anstelle von JSON- oder Avro-Dateien CSV-, durch Zeichen begrenzte oder Textdateien fester Breite.
# COPY aus spaltenbasierten Datenformaten
COPY kann Daten aus Amazon S3 in folgenden spaltenbasierten Formaten laden:
+ ORC
+ Parquet
Beispiele für die Verwendung von COPY aus spaltenbasierten Datenformaten finden Sie unter [Beispiele für COPY](r_COPY_command_examples.md).
COPY unterstützt Daten im Spaltenformat unter Berücksichtigung der folgenden Überlegungen:
+ Der Amazon S3 S3-Bucket muss sich in derselben AWS Region wie die Amazon Redshift Redshift-Datenbank befinden.
+ Um über einen VPC-Endpunkt auf Ihre Amazon-S3-Daten zugreifen zu können, richten Sie den Zugriff mithilfe von IAM-Richtlinien und IAM-Rollen ein, wie unter [Verwendung von Amazon Redshift Spectrum mit Enhanced VPC-Routing](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html) im *Amazon-Redshift-Verwaltungshandbuch* beschrieben.
+ COPY wendet Kompressionskodierungen nicht automatisch an.
+ Es werden nur die folgenden COPY-Parameter unterstützt:
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars) beim Kopieren aus einer ORC- oder Parquet-Datei.
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials)
+ [STATUPDATE ](copy-parameters-data-load.md#copy-statupdate)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [EXPLICIT\$1IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ Tritt beim Laden ein Fehler auf, schlägt der COPY-Befehl fehl. ACCEPTANYDATE und MAXERROR werden für spaltenbasierte Datentypen nicht unterstützt.
+ Fehlermeldungen werden an den SQL-Client gesendet. Einige Fehler werden in STL\$1LOAD\$1ERRORS und STL\$1ERROR protokolliert.
+ COPY fügt Werte in derselben Reihenfolge in die Spalten der Zieltabelle ein, in der die Spalten in den spaltenbasierten Datendateien vorkommen. Die Anzahl der Spalten in der Zieltabelle und die Anzahl der Spalten in der Datendatei müssen übereinstimmen.
+ Wenn die Datei, die Sie für die COPY-Operation angeben, eine der folgenden Erweiterungen besitzt, werden die Daten dekomprimiert, ohne dass Parameter hinzugefügt werden müssen:
+ `.gz`
+ `.snappy`
+ `.bz2`
+ COPY aus den Dateiformaten Parquet und ORC verwendet Redshift Spectrum und den Bucket-Zugriff. Um COPY für diese Formate zu verwenden, stellen Sie sicher, dass es keine IAM-Richtlinien gibt, die die Verwendung von Amazon S3 URLs vorsigniert blockieren. Die von Amazon Redshift URLs generierten vorsignierten Dateien sind 1 Stunde gültig, sodass Amazon Redshift genügend Zeit hat, um alle Dateien aus dem Amazon S3 S3-Bucket zu laden. Für jede von COPY gescannte Datei aus spaltenbasierten Datenformaten wird eine eindeutige vorsignierte URL generiert. Sie müssen bei Bucket-Richtlinien, die die Aktion `s3:signatureAge` enthalten, den Wert auf mindestens 3.600.000 Millisekunden festlegen. Weitere Informationen finden Sie unter [Verwenden von Amazon Redshift Spectrum mit Enhanced VPC Routing](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html).
+ Der Parameter REGION wird bei COPY aus spaltenbasierten Datenformaten nicht unterstützt. Selbst wenn sich Ihr Amazon S3 S3-Bucket und Ihre Datenbank im selben Ordner befinden AWS-Region, kann es zu einem Fehler kommen, z. B. dass das Argument REGION für das PARQUET-basierte COPY nicht unterstützt wird.
+ COPY aus Spaltenformaten unterstützt jetzt die Parallelitätsskalierung. Informationen zur Aktivierung der Parallelitätsskalierung finden Sie unter [Konfigurieren von Warteschlangen mit Parallelitätsskalierung](https://docs.aws.amazon.com/redshift/latest/dg/concurrency-scaling.html#concurrency-scaling-queues).
# DATEFORMAT- und TIMEFORMAT-Zeichenfolgen
Der COPY-Befehl verwendet die Optionen DATEFORMAT und TIMEFORMAT zur Analyse von Datums- und Zeitwerten in Ihren Quelldaten. DATEFORMAT und TIMEFORMAT sind formatierte Zeichenfolgen, die dem Format der Datums- und Zeitwerte Ihrer Quelldaten entsprechen müssen. Ein COPY-Befehl, der Quelldaten mit dem Datumswert `Jan-01-1999` lädt, muss beispielsweise die folgende DATEFORMAT-Zeichenfolge enthalten:
```
COPY ...
DATEFORMAT AS 'MON-DD-YYYY'
```
Weitere Informationen zur Verwaltung von COPY-Datenkonvertierungen finden Sie unter [Datenkonvertierungsparameter](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html).
Die DATEFORMAT- oder TIMEFORMAT-Zeichenfolgen können Datums-/Uhrzeittrennzeichen (wie „`-`“, „`/`“ oder „`:`“) sowie die Datumsteil– und Zeitteilformate in der folgenden Tabelle enthalten.
**Anmerkung**
Wenn Sie das Format Ihrer Datums- oder Zeitwerte nicht mit den folgenden Datumsteilen und Zeitteilen abgleichen können oder wenn Ihre Datums- und Zeitwerte unterschiedliche Formate aufweisen, verwenden Sie das Argument `'auto'` mit dem Parameter DATEFORMAT oder TIMEFORMAT. Das Argument `'auto'` erkennt verschiedene Formate, die bei der Verwendung einer DATEFORMAT- oder TIMEFORMAT-Zeichenfolge nicht unterstützt werden. Weitere Informationen finden Sie unter [Verwenden der automatischen Erkennung bei DATEFORMAT und TIMEFORMAT](automatic-recognition.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
Das Standard-Datumsformat ist. YYYY-MM-DD Das Standardformat für Zeitstempel ohne Zeitzone (TIMESTAMP) ist YYYY-MM-DD HH:MI:SS. Der Standardzeitstempel im Zeitzonenformat (TIMESTAMPTZ) ist YYYY-MM-DD HH:MI:SSOF, wobei OF der UTC-Wert ist (z. B. - 8:00). Sie können keinen Zeitzonenbezeichner (TZ, tz oder OF) in die timeformat\$1string aufnehmen. Das Feld Sekunden (SS) unterstützt auch Sekundenbruchteile bis zu einer Detailgenauigkeit von Mikrosekunden. Um TIMESTAMPTZ-Daten zu laden, die sich in einem anderen Format als dem Standardformat befinden, geben Sie 'auto' an.
Im Folgenden finden Sie einige Beispiele für Datumsangaben oder Uhrzeiten, die Sie in Ihren Quelldaten finden können, sowie die entsprechenden DATEFORMAT- oder TIMEFORMAT-Zeichenfolgen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
## Beispiel
Ein Beispiel für die Verwendung von TIMEFORMAT finden Sie unter [Laden eines Zeit- oder Datumsstempels](r_COPY_command_examples.md#r_COPY_command_examples-load-a-time-datestamp).
# Verwenden der automatischen Erkennung bei DATEFORMAT und TIMEFORMAT
Wenn Sie `'auto'` als Argument für den Parameter DATEFORMAT oder TIMEFORMAT angeben, erkennt Amazon Redshift automatisch das Datums- oder Zeitformat in Ihren Quelldaten und konvertiert es. Es folgt ein Beispiel.
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
dateformat 'auto';
```
Wenn COPY mit dem Argument `'auto'` für DATEFORMAT und TIMEFORMAT verwendet wird, erkennt COPY die Datums- und Zeitformate, die in der Tabelle in [DATEFORMAT- und TIMEFORMAT-ZeichenfolgenBeispiel](r_DATEFORMAT_and_TIMEFORMAT_strings.md) aufgelistet sind. Zusätzlich erkennt das Argument `'auto'` die folgenden Formate, die bei Verwendung einer DATEFORMAT- und TIMEFORMAT-Zeichenfolge nicht unterstützt werden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/automatic-recognition.html)
Die automatische Erkennung unterstützt keine Epochensekunden und Epochenmillisekunden.
Um herauszufinden, ob ein Datums- oder Zeitstempelwert automatisch konvertiert wird, verwenden Sie eine CAST-Funktion, um zu versuchen, die Zeichenfolge in einen Datums- oder Zeitstempelwert zu konvertieren. Mit den folgenden Befehlen wird beispielsweise der Zeitstempelwert getestet `'J2345678 04:05:06.789'`:
```
create table formattest (test char(21));
insert into formattest values('J2345678 04:05:06.789');
select test, cast(test as timestamp) as timestamp, cast(test as date) as date from formattest;
test | timestamp | date
----------------------+---------------------+------------
J2345678 04:05:06.789 1710-02-23 04:05:06 1710-02-23
```
Wenn die Quelldaten für eine DATE-Spalte Zeitinformationen enthalten, wird die Zeitkomponente abgeschnitten. Wenn die Quelldaten für eine TIMESTAMP-Spalte Zeitinformationen auslassen, wird für die Zeitkomponente 00:00:00 verwendet.
# Beispiele für COPY
**Anmerkung**
In den folgenden Beispielen werden aus Gründen der Lesbarkeit Zeilenumbrüche verwendet. Verwenden Sie in Ihrer Zeichenfolge *credentials-args* keine Zeilenumbrüche oder Leerzeichen.
**Topics**
+ [Laden von FAVORITEMOVIES aus einer DynamoDB-Tabelle](#r_COPY_command_examples-load-favoritemovies-from-an-amazon-dynamodb-table)
+ [Laden von LISTING aus einem Amazon-S3-Bucket](#r_COPY_command_examples-load-listing-from-an-amazon-s3-bucket)
+ [Laden von LISTING aus einem Amazon-EMR-Cluster](#copy-command-examples-emr)
+ [Example: COPY from Amazon S3 using a manifest](#copy-command-examples-manifest)
+ [Laden von LISTING aus einer Datei mit Pipe-Zeichen als Trennzeichen (Standardtrennzeichen)](#r_COPY_command_examples-load-listing-from-a-pipe-delimited-file-default-delimiter)
+ [Laden von LISTING unter Verwendung von Spaltendaten im Parquet-Format](#r_COPY_command_examples-load-listing-from-parquet)
+ [Laden von LISTING unter Verwendung von Spaltendaten im ORC-Format](#r_COPY_command_examples-load-listing-from-orc)
+ [Laden von EVENT mit Optionen](#r_COPY_command_examples-load-event-with-options)
+ [Laden von VENUE aus einer Datendatei mit festen Spaltenbreiten](#r_COPY_command_examples-load-venue-from-a-fixed-width-data-file)
+ [Laden von CATEGORY aus einer CSV-Datei](#load-from-csv)
+ [Laden von VENUE mit expliziten Werte für eine IDENTITY-Spalte](#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column)
+ [Laden von TIME aus einer GZIP-Datei mit Pipe-Zeichen als Trennzeichen](#r_COPY_command_examples-load-time-from-a-pipe-delimited-gzip-file)
+ [Laden eines Zeit- oder Datumsstempels](#r_COPY_command_examples-load-a-time-datestamp)
+ [Laden von Daten aus einer Datei mit Standardwerten](#r_COPY_command_examples-load-data-from-a-file-with-default-values)
+ [COPY-Operation für Daten mit der Option ESCAPE](#r_COPY_command_examples-copy-data-with-the-escape-option)
+ [Beispiele für die COPY-Operation aus JSON](#r_COPY_command_examples-copy-from-json)
+ [Beispiele für die Kopie aus Avro](#r_COPY_command_examples-copy-from-avro)
+ [Vorbereiten von Dateien auf die COPY-Operation mit der Option ESCAPE](#r_COPY_preparing_data)
+ [Laden eines Shapefile in Amazon Redshift](#copy-example-spatial-copy-shapefile)
+ [COPY-Befehl mit der Option NOLOAD](#r_COPY_command_examples-load-noload-option)
+ [Befehl COPY mit Multibyte-Trennzeichen und Option ENCODING](#r_COPY_command_examples-load-encoding-multibyte-delimiter-option)
## Laden von FAVORITEMOVIES aus einer DynamoDB-Tabelle
*Sie AWS SDKs enthalten ein einfaches Beispiel für die Erstellung einer DynamoDB-Tabelle namens Movies.* (Informationen zu diesem Beispiel finden Sie unter [Erste Schritte mit DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.html).) Im folgenden Beispiel wird die Amazon-Redshift-Tabelle MOVIES mit Daten aus der DynamoDB-Tabelle geladen. Die Amazon-Redshift-Tabelle muss in der Datenbank bereits vorhanden sein.
```
copy favoritemovies from 'dynamodb://Movies'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
## Laden von LISTING aus einem Amazon-S3-Bucket
Im folgenden Beispiel wird LISTING aus einem Amazon-S3-Bucket geladen. Der COPY-Befehl lädt alle Dateien im Ordner `/data/listing/`.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listing/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Laden von LISTING aus einem Amazon-EMR-Cluster
Im folgenden Beispiel wird die Tabelle SALES mit durch Tabulatoren getrennten Daten aus lzop-komprimierten Dateien in einem Amazon-EMR-Cluster geladen. COPY lädt jede Datei im Ordner `myoutput/`, die mit `part-` beginnt.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '\t' lzop;
```
Im folgenden Beispiel wird die Tabelle SALES mit JSON-formatierten Daten in einem Amazon-EMR-Cluster geladen. COPY lädt jede Datei im Ordner `myoutput/json/`.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/json/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
JSON 's3://amzn-s3-demo-bucket/jsonpaths.txt';
```
## Verwenden eines Manifests für die Angabe von Datendateien
Sie können ein Manifest verwenden, um sicherzustellen, dass der COPY-Befehl alle erforderlichen Dateien aus Amazon S3 und nur diese lädt. Sie können ein Manifest auch verwenden, wenn Sie mehrere Dateien aus verschiedenen Buckets laden müssen oder Dateien, die nicht dasselbe Präfix besitzen.
Angenommen, Sie müssen die folgenden drei Dateien laden: `custdata1.txt`, `custdata2.txt` und `custdata3.txt`. Sie könnten den folgenden Befehl verwenden, um alle Dateien in `amzn-s3-demo-bucket` zu laden, die mit `custdata` beginnen, indem Sie ein Präfix angeben:
```
copy category
from 's3://amzn-s3-demo-bucket/custdata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Wenn aufgrund eines Fehlers nur zwei der Dateien vorhanden sind, lädt COPY nur diese beiden Dateien und wird erfolgreich abgeschlossen. Dies führt zu einem unvollständigen Datenladevorgang. Wenn der Bucket auch eine nicht erwünschte Datei enthält, die zufällig dasselbe Präfix verwendet, beispielsweise eine Datei namens `custdata.backup`, lädt COPY diese Datei ebenfalls. Dies führt dazu, dass nicht erwünschte Daten geladen werden.
Um sicherzustellen, dass alle erforderlichen Dateien geladen werden, und zu verhindern, dass nicht erwünschte Dateien geladen werden, können Sie eine Manifestdatei verwenden. Die Manifestdatei ist eine JSON formatierte Textdatei, die die Dateien auflistet, die durch den COPY-Befehl verarbeitet werden sollen. Beispielsweise lädt das folgende Manifest die drei Dateien aus dem vorherigen Beispiel.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket/custdata.1",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.2",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.3",
"mandatory":true
}
]
}
```
Das optionale `mandatory`-Flag gibt an, ob COPY beendet werden soll, wenn die Datei nicht vorhanden ist. Der Standardwert ist `false`. Unabhängig von obligatorischen Einstellungen wird COPY beendet, wenn keine Dateien gefunden werden. In diesem Beispiel gibt COPY einen Fehler zurück, wenn eine der Dateien nicht gefunden wird. Nicht erwünschte Dateien, die möglicherweise geladen werden, wenn Sie nur ein Schlüsselpräfix angeben, beispielsweise `custdata.backup`, werden ignoriert, da sie nicht im Manifest aufgelistet werden.
Beim Laden aus Datendateien im ORC- oder Parquet-Format ist ein `meta`-Feld erforderlich, wie im folgenden Beispiel gezeigt.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
Im folgenden Beispiel wird ein Manifest namens verwendet `cust.manifest`.
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc
manifest;
```
Sie können ein Manifest verwenden, um Dateien aus verschiedenen Buckets hochzuladen oder Dateien, die nicht das gleiche Präfix verwenden. Das folgende Beispiel zeigt das JSON-Format, um Daten aus Dateien zu laden, deren Namen mit einem Datumsstempel beginnen.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket/2013-10-04-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-05-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-06-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-07-custdata.txt","mandatory":true}
]
}
```
Das Manifest kann Dateien auflisten, die sich in verschiedenen Buckets befinden, sofern sich die Buckets in derselben AWS Region wie der Cluster befinden.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata2.txt","mandatory":false}
]
}
```
## Laden von LISTING aus einer Datei mit Pipe-Zeichen als Trennzeichen (Standardtrennzeichen)
Das folgende Beispiel stellt einen sehr einfachen Fall dar, in dem keine Optionen angegeben sind und die Eingabedatei das Standardtrennzeichen enthält, ein Pipe-Zeichen (\$1).
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Laden von LISTING unter Verwendung von Spaltendaten im Parquet-Format
Im folgenden Beispiel werden Daten aus einem Ordner in einem von Amazon S3 benannten Parquet geladen.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/parquet/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as parquet;
```
## Laden von LISTING unter Verwendung von Spaltendaten im ORC-Format
Im folgenden Beispiel werden Daten aus einem Ordner in Amazon S3 mit dem Namen `orc` geladen.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/orc/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc;
```
## Laden von EVENT mit Optionen
Im folgenden Beispiel werden durch Pipe-Zeichen getrennte Daten in die Tabelle EVENT geladen und anschließend die folgenden Regeln angewendet:
+ Wenn Zeichenfolgen durch Paare von Angebotszeichen eingeschlossen werden, werden sie entfernt.
+ Sowohl leere Zeichenfolgen als auch Zeichenfolgen, die Leerzeichen enthalten, werden als NULL-Werte geladen.
+ Der Ladevorgang schlägt fehl, wenn mehr als 5 Fehler zurückgegeben werden.
+ Zeitstempelwerte müssen das angegebene Format einhalten. Ein gültiger Zeitstempel ist beispielsweise `2008-09-26 05:43:12`.
```
copy event
from 's3://amzn-s3-demo-bucket/data/allevents_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
removequotes
emptyasnull
blanksasnull
maxerror 5
delimiter '|'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
## Laden von VENUE aus einer Datendatei mit festen Spaltenbreiten
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue_fw.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
fixedwidth 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6';
```
Im vorherigen Beispiel wird angenommen, dass die Datendatei auf dieselbe Weise wie die gezeigten Beispieldateien formatiert ist. Im folgenden Beispiel dienen Leerzeichen als Platzhalter, sodass alle Spalten dieselbe Breite wie in der Spezifikation angegeben haben:
```
1 Toyota Park Bridgeview IL0
2 Columbus Crew Stadium Columbus OH0
3 RFK Stadium Washington DC0
4 CommunityAmerica BallparkKansas City KS0
5 Gillette Stadium Foxborough MA68756
```
## Laden von CATEGORY aus einer CSV-Datei
Angenommen, Sie möchten CATEGORY mit den Werten laden, die in der folgenden Tabelle gezeigt werden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_COPY_command_examples.html)
Im folgenden Beispiel werden die Inhalte einer Textdatei gezeigt, deren Feldwerte durch Kommas getrennt sind.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,All "non-musical" theatre
14,Shows,Opera,All opera, light, and "rock" opera
15,Concerts,Classical,All symphony, concerto, and choir concerts
```
Wenn Sie die Datei mit dem Parameter DELIMITER laden, um Eingabedaten mit Kommas als Trennzeichen anzugeben, schlägt der COPY-Befehl fehl, da einige Eingabefelder Kommas enthalten. Sie können dieses Problem beheben, indem Sie den Parameter CSV verwenden und die Felder, die Kommas enthalten, in Anführungszeichen einschließen. Wenn ein Anführungszeichen innerhalb einer Zeichenfolge vorkommt, die durch Anführungszeichen eingeschlossen wird, müssen Sie dieses mit einer Escape-Markierung versehen, indem Sie das Anführungszeichen verdoppeln. Das Standardanführungszeichen ist ein doppeltes Anführungszeichen. Daher müssen Sie jedes doppelte Anführungszeichen mit einem zusätzlichen doppelten Anführungszeichen als Escape-Zeichen verwenden. Ihre neue Eingabedatei sieht ungefähr wie folgt aus.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,"All ""non-musical"" theatre"
14,Shows,Opera,"All opera, light, and ""rock"" opera"
15,Concerts,Classical,"All symphony, concerto, and choir concerts"
```
Angenommen, der Dateiname ist `category_csv.txt`, dann können Sie die Datei mittels des folgenden COPY-Befehls laden:
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv;
```
Um die Notwendigkeit zu vermeiden, die doppelten Anführungszeichen in Ihrer Eingabe durch Escape-Zeichen zu markieren, können Sie ein anderes Anführungszeichen angeben, indem Sie den Parameter QUOTE AS verwenden. Beispielsweise verwendet die folgende Version von `category_csv.txt` '`%`' als Anführungszeichen:
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,%All "non-musical" theatre%
14,Shows,Opera,%All opera, light, and "rock" opera%
15,Concerts,Classical,%All symphony, concerto, and choir concerts%
```
Der folgende COPY-Befehl verwendet QUOTE AS, um zu laden `category_csv.txt`:
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv quote as '%';
```
## Laden von VENUE mit expliziten Werte für eine IDENTITY-Spalte
Im folgenden Beispiel wird angenommen, dass bei Erstellung der Tabelle VENUE mindestens eine Spalte (beispielsweise die Spalte `venueid`) als IDENTITY-Spalte angegeben wurde. Dieser Befehl überschreibt das IDENTITY-Standardverhalten, bei dem Werte für eine IDENTITY-Spalte automatisch generiert werden, und lädt stattdessen die expliziten Werte aus der Datei venue.txt. Amazon Redshift überprüft nicht, ob doppelte IDENTITY-Werte in die Tabelle geladen werden, wenn die Option EXLICIT\$1IDS verwendet wird.
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
explicit_ids;
```
## Laden von TIME aus einer GZIP-Datei mit Pipe-Zeichen als Trennzeichen
Im folgenden Beispiel wird die Tabelle TIME aus einer GZIP-Datei mit Pipe-Zeichen als Trennzeichen geladen:
```
copy time
from 's3://amzn-s3-demo-bucket/data/timerows.gz'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
gzip
delimiter '|';
```
## Laden eines Zeit- oder Datumsstempels
Im folgenden Beispiel werden Daten mit formatierten Zeitstempeln geladen.
**Anmerkung**
Das TIMEFORMAT von `HH:MI:SS` kann auch Bruchteile von Sekunden jenseits von `SS` bis zu einer Detailtiefe von Mikrosekunden unterstützen. Die in diesem Beispiel verwendete Datei `time.txt` enthält eine einzige Zeile, `2009-01-12 14:15:57.119568`.
```
copy timestamp1
from 's3://amzn-s3-demo-bucket/data/time.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
Das Ergebnis dieser COPY-Operation ist wie folgt:
```
select * from timestamp1;
c1
----------------------------
2009-01-12 14:15:57.119568
(1 row)
```
## Laden von Daten aus einer Datei mit Standardwerten
Im folgenden Beispiel wird eine Variante der Tabelle VENUE in der Datenbank TICKIT verwendet. Betrachten Sie die Tabelle VENUE\$1NEW, die mit der folgenden Anweisung definiert wird:
```
create table venue_new(
venueid smallint not null,
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
Betrachten Sie die Datendatei venue\$1noseats.txt, die keine Werte für die Spalte VENUESEATS enthält, wie im folgenden Beispiel gezeigt:
```
1|Toyota Park|Bridgeview|IL|
2|Columbus Crew Stadium|Columbus|OH|
3|RFK Stadium|Washington|DC|
4|CommunityAmerica Ballpark|Kansas City|KS|
5|Gillette Stadium|Foxborough|MA|
6|New York Giants Stadium|East Rutherford|NJ|
7|BMO Field|Toronto|ON|
8|The Home Depot Center|Carson|CA|
9|Dick's Sporting Goods Park|Commerce City|CO|
10|Pizza Hut Park|Frisco|TX|
```
Die folgende COPY-Anweisung lädt die Tabelle erfolgreich aus der Datei und wendet den Standardwert (1000) auf die ausgelassene Spalte an:
```
copy venue_new(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_noseats.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
Betrachten Sie nun die geladene Tabelle:
```
select * from venue_new order by venueid;
venueid | venuename | venuecity | venuestate | venueseats
---------+----------------------------+-----------------+------------+------------
1 | Toyota Park | Bridgeview | IL | 1000
2 | Columbus Crew Stadium | Columbus | OH | 1000
3 | RFK Stadium | Washington | DC | 1000
4 | CommunityAmerica Ballpark | Kansas City | KS | 1000
5 | Gillette Stadium | Foxborough | MA | 1000
6 | New York Giants Stadium | East Rutherford | NJ | 1000
7 | BMO Field | Toronto | ON | 1000
8 | The Home Depot Center | Carson | CA | 1000
9 | Dick's Sporting Goods Park | Commerce City | CO | 1000
10 | Pizza Hut Park | Frisco | TX | 1000
(10 rows)
```
Im folgenden Beispiel wird zusätzlich zur Annahme, dass in der Datei keine VENUESEATS-Daten enthalten sind, auch angenommen, dass keine VENUENAME-Daten enthalten sind:
```
1||Bridgeview|IL|
2||Columbus|OH|
3||Washington|DC|
4||Kansas City|KS|
5||Foxborough|MA|
6||East Rutherford|NJ|
7||Toronto|ON|
8||Carson|CA|
9||Commerce City|CO|
10||Frisco|TX|
```
Bei Verwendung derselben Tabellendefinition schlägt die COPY-Anweisung fehl, da für VENUENAME kein DEFAULT-Wert angegeben wurde und VENUENAME eine NOT NULL-Spalte ist:
```
copy venue(venueid, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
Betrachten Sie nun eine Variante der Tabelle VENUE, die eine IDENTITY-Spalte verwendet:
```
create table venue_identity(
venueid int identity(1,1),
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
Nehmen Sie wie im vorherigen Beispiel an, dass es für die Spalte VENUESEATS keine entsprechenden Werte in der Quelldatei gibt. Die folgende COPY-Anweisung lädt die Tabelle erfolgreich einschließlich der vordefinierten IDENTITY-Datenwerte, anstatt diese Werte automatisch zu generieren:
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
Diese Anweisung schlägt fehl, da sie die Spalte IDENTITY nicht enthält (VENUEID fehlt in der Spaltenliste), aber den Parameter EXPLICIT\$1IDS einschließt:
```
copy venue(venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
Diese Anweisung schlägt fehl, da sie den Parameter EXPLICIT\$1IDS nicht enthält:
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
## COPY-Operation für Daten mit der Option ESCAPE
Im folgenden Beispiel wird gezeigt, wie Zeichen geladen werden, die mit dem Trennzeichen übereinstimmen (in diesem Fall dem Pipe-Zeichen). Stellen Sie sicher, dass in der Eingabedatei alle Pipe-Zeichen (\$1), die Sie laden möchten, mit dem Backslash-Zeichen (\$1) als Escape-Zeichen markiert sind. Laden Sie die Datei anschließend unter Verwendung des Parameters ESCAPE.
```
$ more redshiftinfo.txt
1|public\|event\|dwuser
2|public\|sales\|dwuser
create table redshiftinfo(infoid int,tableinfo varchar(50));
copy redshiftinfo from 's3://amzn-s3-demo-bucket/data/redshiftinfo.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' escape;
select * from redshiftinfo order by 1;
infoid | tableinfo
-------+--------------------
1 | public|event|dwuser
2 | public|sales|dwuser
(2 rows)
```
Ohne den Parameter ESCAPE schlägt dieser COPY-Befehl mit dem Fehler `Extra column(s) found` fehl.
**Wichtig**
Wenn Sie Ihre Daten mittels einer COPY-Operation mit dem Parameter ESCAPE laden, müssen Sie den Parameter ESCAPE auch für Ihren UNLOAD-Befehl angeben, um die reziproke Ausgabedatei zu generieren. Wenn Sie UNLOAD unter Verwendung des Parameters ESCAPE ausführen, müssen Sie ESCAPE verwenden, um eine COPY-Operation für diese Daten auszuführen.
## Beispiele für die COPY-Operation aus JSON
In den folgenden Beispielen wird die Tabelle CATEGORY mit den folgenden Daten geladen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ [Laden von JSON-Daten unter Verwendung der Option „auto“](#copy-from-json-examples-using-auto)
+ [Laden von JSON-Daten unter Verwendung der Option „auto ignorecase“](#copy-from-json-examples-using-auto-ignorecase)
+ [Aus JSON-Daten mithilfe einer Datei laden JSONPaths](#copy-from-json-examples-using-jsonpaths)
+ [Aus JSON-Arrays mithilfe einer JSONPaths Datei laden](#copy-from-json-examples-using-jsonpaths-arrays)
### Laden von JSON-Daten unter Verwendung der Option „auto“
Um JSON-Daten unter Verwendung der Option `'auto'` zu laden, müssen die JSON-Daten aus einem Satz von Objekten bestehen. Die Schlüsselnamen müssen mit den Spaltennamen übereinstimmen. In diesem Fall spielt die Reihenfolge jedoch keine Rolle. Im folgenden werden die Inhalte einer Datei namens gezeigt `category_object_auto.json`.
```
{
"catdesc": "Major League Baseball",
"catid": 1,
"catgroup": "Sports",
"catname": "MLB"
}
{
"catgroup": "Sports",
"catid": 2,
"catname": "NHL",
"catdesc": "National Hockey League"
}
{
"catid": 3,
"catname": "NFL",
"catgroup": "Sports",
"catdesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"catid": 4,
"catgroup": "Sports",
"catname": "NBA",
"catdesc": "National Basketball Association"
}
{
"catid": 5,
"catgroup": "Shows",
"catname": "Musicals",
"catdesc": "All symphony, concerto, and choir concerts"
}
```
Um Daten aus der JSON-Datei im vorherigen Beispiel zu laden, führen Sie den folgenden COPY-Befehl aus.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto';
```
### Laden von JSON-Daten unter Verwendung der Option „auto ignorecase“
Um JSON-Daten unter Verwendung der Option `'auto ignorecase'` zu laden, müssen die JSON-Daten aus einem Satz von Objekten bestehen. Die Groß- und Kleinschreibung der Schlüsselnamen muss nicht mit den Spaltennamen übereinstimmen und die Reihenfolge spielt keine Rolle. Im folgenden werden die Inhalte einer Datei namens gezeigt `category_object_auto-ignorecase.json`.
```
{
"CatDesc": "Major League Baseball",
"CatID": 1,
"CatGroup": "Sports",
"CatName": "MLB"
}
{
"CatGroup": "Sports",
"CatID": 2,
"CatName": "NHL",
"CatDesc": "National Hockey League"
}
{
"CatID": 3,
"CatName": "NFL",
"CatGroup": "Sports",
"CatDesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"CatID": 4,
"CatGroup": "Sports",
"CatName": "NBA",
"CatDesc": "National Basketball Association"
}
{
"CatID": 5,
"CatGroup": "Shows",
"CatName": "Musicals",
"CatDesc": "All symphony, concerto, and choir concerts"
}
```
Um Daten aus der JSON-Datei im vorherigen Beispiel zu laden, führen Sie den folgenden COPY-Befehl aus.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto ignorecase.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto ignorecase';
```
### Aus JSON-Daten mithilfe einer Datei laden JSONPaths
Wenn die JSON-Datenobjekte nicht direkt den Spaltennamen entsprechen, können Sie eine JSONPaths Datei verwenden, um die JSON-Elemente den Spalten zuzuordnen. Die Reihenfolge in den JSON-Quelldaten spielt keine Rolle, aber die Reihenfolge der JSONPaths Dateiausdrücke muss mit der Reihenfolge der Spalten übereinstimmen. Angenommen, Sie verwenden die folgende Datendatei mit dem Namen `category_object_paths.json`.
```
{
"one": 1,
"two": "Sports",
"three": "MLB",
"four": "Major League Baseball"
}
{
"three": "NHL",
"four": "National Hockey League",
"one": 2,
"two": "Sports"
}
{
"two": "Sports",
"three": "NFL",
"one": 3,
"four": "National Football League"
}
{
"one": 4,
"two": "Sports",
"three": "NBA",
"four": "National Basketball Association"
}
{
"one": 6,
"two": "Shows",
"three": "Musicals",
"four": "All symphony, concerto, and choir concerts"
}
```
Die folgende JSONPaths Datei mit dem Namen `category_jsonpath.json` ordnet die Quelldaten den Tabellenspalten zu.
```
{
"jsonpaths": [
"$['one']",
"$['two']",
"$['three']",
"$['four']"
]
}
```
Um Daten aus der JSON-Datei im vorherigen Beispiel zu laden, führen Sie den folgenden COPY-Befehl aus.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_jsonpath.json';
```
### Aus JSON-Arrays mithilfe einer JSONPaths Datei laden
Um Daten aus JSON zu laden, die aus einer Reihe von Arrays bestehen, müssen Sie eine JSONPaths Datei verwenden, um die Array-Elemente den Spalten zuzuordnen. Angenommen, Sie verwenden die folgende Datendatei mit dem Namen `category_array_data.json`.
```
[1,"Sports","MLB","Major League Baseball"]
[2,"Sports","NHL","National Hockey League"]
[3,"Sports","NFL","National Football League"]
[4,"Sports","NBA","National Basketball Association"]
[5,"Concerts","Classical","All symphony, concerto, and choir concerts"]
```
Die folgende JSONPaths Datei mit dem Namen `category_array_jsonpath.json` ordnet die Quelldaten den Tabellenspalten zu.
```
{
"jsonpaths": [
"$[0]",
"$[1]",
"$[2]",
"$[3]"
]
}
```
Um Daten aus der JSON-Datei im vorherigen Beispiel zu laden, führen Sie den folgenden COPY-Befehl aus.
```
copy category
from 's3://amzn-s3-demo-bucket/category_array_data.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_array_jsonpath.json';
```
## Beispiele für die Kopie aus Avro
In den folgenden Beispielen wird die Tabelle CATEGORY mit den folgenden Daten geladen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ [Laden von Avro-Daten unter Verwendung der Option „auto“](#copy-from-avro-examples-using-auto)
+ [Laden von Avro-Daten unter Verwendung der Option „auto ignorecase“](#copy-from-avro-examples-using-auto-ignorecase)
+ [Aus Avro-Daten mithilfe einer JSONPaths Datei laden](#copy-from-avro-examples-using-avropaths)
### Laden von Avro-Daten unter Verwendung der Option „auto“
Um Daten aus Avro-Datendateien unter Verwendung des Arguments `'auto'` zu laden, müssen die Feldnamen im Avro-Schema mit den Spaltennamen übereinstimmen. Bei Verwendung des Arguments `'auto'` spielt die Reihenfolge keine Rolle. Im folgenden wird das Schema für eine Datei namens gezeigt `category_auto.avro`.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "catid", "type": "int"},
{"name": "catdesc", "type": "string"},
{"name": "catname", "type": "string"},
{"name": "catgroup", "type": "string"},
}
```
Die Daten in einer Avro-Datei liegen im binären Format vor. Sie können daher nicht von Menschen gelesen werden. Im folgenden Beispiel wird eine JSON-Darstellung der Daten in der `category_auto.avro`-Datei gezeigt.
```
{
"catid": 1,
"catdesc": "Major League Baseball",
"catname": "MLB",
"catgroup": "Sports"
}
{
"catid": 2,
"catdesc": "National Hockey League",
"catname": "NHL",
"catgroup": "Sports"
}
{
"catid": 3,
"catdesc": "National Basketball Association",
"catname": "NBA",
"catgroup": "Sports"
}
{
"catid": 4,
"catdesc": "All symphony, concerto, and choir concerts",
"catname": "Classical",
"catgroup": "Concerts"
}
```
Um Daten aus der Avro-Datei im vorherigen Beispiel zu laden, führen Sie den folgenden COPY-Befehl aus.
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto';
```
### Laden von Avro-Daten unter Verwendung der Option „auto ignorecase“
Um Daten aus Avro-Datendateien unter Verwendung des Arguments `'auto ignorecase'` zu laden, muss die Groß-/Kleinschreibung der Feldnamen im Avro-Schema nicht mit den Spaltennamen übereinstimmen. Bei Verwendung des Arguments `'auto ignorecase'` spielt die Reihenfolge keine Rolle. Im folgenden wird das Schema für eine Datei namens gezeigt `category_auto-ignorecase.avro`.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "CatID", "type": "int"},
{"name": "CatDesc", "type": "string"},
{"name": "CatName", "type": "string"},
{"name": "CatGroup", "type": "string"},
}
```
Die Daten in einer Avro-Datei liegen im binären Format vor. Sie können daher nicht von Menschen gelesen werden. Im folgenden Beispiel wird eine JSON-Darstellung der Daten in der `category_auto-ignorecase.avro`-Datei gezeigt.
```
{
"CatID": 1,
"CatDesc": "Major League Baseball",
"CatName": "MLB",
"CatGroup": "Sports"
}
{
"CatID": 2,
"CatDesc": "National Hockey League",
"CatName": "NHL",
"CatGroup": "Sports"
}
{
"CatID": 3,
"CatDesc": "National Basketball Association",
"CatName": "NBA",
"CatGroup": "Sports"
}
{
"CatID": 4,
"CatDesc": "All symphony, concerto, and choir concerts",
"CatName": "Classical",
"CatGroup": "Concerts"
}
```
Um Daten aus der Avro-Datei im vorherigen Beispiel zu laden, führen Sie den folgenden COPY-Befehl aus.
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto-ignorecase.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto ignorecase';
```
### Aus Avro-Daten mithilfe einer JSONPaths Datei laden
Wenn die Feldnamen im Avro-Schema nicht direkt den Spaltennamen entsprechen, können Sie eine JSONPaths Datei verwenden, um die Schemaelemente den Spalten zuzuordnen. Die Reihenfolge der JSONPaths Dateiausdrücke muss mit der Reihenfolge der Spalten übereinstimmen.
Angenommen, Sie verwenden eine Datendatei namens `category_paths.avro`, die dieselben Daten wie im vorherigen Beispiel enthält, jedoch mit dem folgenden Schema.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "desc", "type": "string"},
{"name": "name", "type": "string"},
{"name": "group", "type": "string"},
{"name": "region", "type": "string"}
]
}
```
Die folgende JSONPaths Datei mit dem Namen `category_path.avropath` ordnet die Quelldaten den Tabellenspalten zu.
```
{
"jsonpaths": [
"$['id']",
"$['group']",
"$['name']",
"$['desc']"
]
}
```
Um Daten aus der Avro-Datei im vorherigen Beispiel zu laden, führen Sie den folgenden COPY-Befehl aus.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format avro 's3://amzn-s3-demo-bucket/category_path.avropath ';
```
## Vorbereiten von Dateien auf die COPY-Operation mit der Option ESCAPE
Im folgenden Beispiel wird beschrieben, wie Sie Daten vorbereiten können, damit Zeichen für neue Zeilen mit Escape-Zeichen markiert werden, bevor die Daten unter Verwendung des COPY-Befehls mit dem Parameter ESCAPE in eine Amazon-Redshift-Tabelle geladen werden. Wenn die Zeichen für neue Zeilen in den Daten nicht mit Escape-Zeichen markiert werden, gibt Amazon Redshift Ladefehler zurück, sobald Sie den COPY-Befehl ausführen, da die Zeichen für neue Zeilen normalerweise als Datensatztrennzeichen verwendet werden.
Betrachten Sie beispielsweise eine Datei oder eine Spalte in einer externen Tabelle, die Sie in eine Amazon-Redshift-Tabelle kopieren möchten. Wenn die Datei oder Spalte XML-formatierte Inhalte oder ähnliche Daten enthält, müssen Sie sicherstellen, dass alle Zeichen für neue Zeilen (\$1n), die Teil des Inhalts sind, mit dem Backslash-Zeichen (\$1) als Escape-Zeichen markiert werden.
Eine Datei oder Tabelle, die eingebettete Zeichen für Zeilenumbrüche enthält, bietet ein vergleichsweise einfaches Muster für den Vergleich. Die eingebetteten Zeichen für neue Zeilen folgen wahrscheinlich meistens einem `>`-Zeichen, wobei sich dazwischen möglicherweise einige Leerstellen (`' '` oder Tabulatorzeichen) befinden, wie Sie im folgenden Beispiel für eine Textdatei namens `nlTest1.txt` sehen können.
```
$ cat nlTest1.txt
|1000
|2000
```
Im folgenden Beispiel können Sie ein Textverarbeitungsprogramm ausführen, um die Quelldatei vorab zu bearbeiten und an den nötigen Stellen Escape-Zeichen einzufügen. (Das Zeichen `|` soll als Trennzeichen verwendet werden, um Spaltendaten beim Kopieren in eine Amazon-Redshift-Tabelle zu trennen).
```
$ sed -e ':a;N;$!ba;s/>[[:space:]]*\n/>\\\n/g' nlTest1.txt > nlTest2.txt
```
Ähnlich können Sie Perl verwenden, um eine vergleichbare Operation auszuführen:
```
cat nlTest1.txt | perl -p -e 's/>\s*\n/>\\\n/g' > nlTest2.txt
```
Um die Daten aus der Datei `nlTest2.txt` in Amazon Redshift laden zu können, wurde in eine Tabelle mit zwei Spalten erstellt. Die erste Spalte c1 ist eine Zeichenspalte, die XML-formatierte Inhalte aus der Datei `nlTest2.txt` aufnimmt. Die zweite Spalte c2 enthält Ganzzahlwerte, die aus derselben Datei geladen wurden.
Nach Ausführung des Befehls `sed` können Sie Daten unter Verwendung des Parameters ESCAPE korrekt aus der Datei `nlTest2.txt` in eine Amazon-Redshift-Tabelle laden.
**Anmerkung**
Wenn Sie den COPY-Befehl zusammen mit dem Parameter ESCAPE verwenden, wird eine Reihe von Sonderzeichen mit dem Escape-Zeichen markiert, zu denen auch das Backslash-Zeichen gehört (einschließlich des Zeichens für neue Zeilen).
```
copy t2 from 's3://amzn-s3-demo-bucket/data/nlTest2.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
escape
delimiter as '|';
select * from t2 order by 2;
c1 | c2
-------------+------
| 1000
| 2000
(2 rows)
```
Sie können Datendateien, die aus externen Datenbanken exportiert wurden, auf ähnliche Weise vorbereiten. Im Fall einer Oracle-Datenbank können Sie beispielsweise die Funktion REPLACE auf alle betroffenen Spalten in einer Tabelle anwenden, die Sie zu Amazon Redshift kopieren möchten.
```
SELECT c1, REPLACE(c2, \n',\\n' ) as c2 from my_table_with_xml
```
Zusätzlich stellen zahlreiche Tools für den Export sowie das Extrahieren, das Transformieren und das Laden (Extract, Transform, Load, ETL) von Datenbanken, die routinemäßig große Datenmengen verarbeiten, Optionen für die Angabe von Escape- und Trennzeichen bereit.
## Laden eines Shapefile in Amazon Redshift
In den folgenden Beispielen wird gezeigt, wie Sie ein Esri-Shapefile mit COPY laden. Weitere Informationen zum Laden von Shapefiles finden Sie unter [Laden eines Shapefile in Amazon Redshift](spatial-copy-shapefile.md).
### Laden eines Shapefile
Die folgenden Schritte zeigen, wie Sie mit dem Befehl COPY OpenStreetMap Daten aus Amazon S3 aufnehmen. In diesem Beispiel wird davon ausgegangen, dass das Norwegen Shapefile-Archiv von [der Download-Site von Geofabrik](https://download.geofabrik.de/europe.html) in einen privaten Amazon S3 S3-Bucket in Ihrer Region hochgeladen wurde. AWS Die Dateien `.shp`, `.shx` und`.dbf` müssen dasselbe Amazon-S3-Präfix und denselben Dateinamen haben.
#### Erfassung von Daten ohne Vereinfachung
Mit den folgenden Befehlen werden Tabellen erstellt und Daten erfasst, die ohne Vereinfachung in die maximale Geometriegröße passen. Öffnen Sie `gis_osm_natural_free_1.shp` in Ihrer bevorzugten GIS-Software und überprüfen Sie die Spalten in diesem Layer. Standardmäßig werden entweder IDENTITY- oder GEOMETRY-Spalten zuerst angezeigt. Wenn eine GEOMETRY-Spalte zuerst angezeigt wird, können Sie die Tabelle wie folgt erstellen.
```
CREATE TABLE norway_natural (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Wenn eine IDENTITY-Spalte an erster Stelle steht, können Sie die Tabelle wie folgt erstellen.
```
CREATE TABLE norway_natural_with_id (
fid INT IDENTITY(1,1),
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Jetzt können Sie die Daten mit COPY erfassen.
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully
```
Oder Sie können die Daten wie folgt erfassen.
```
COPY norway_natural_with_id FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_with_id' completed, 83891 record(s) loaded successfully.
```
#### Erfassung von Daten mit Vereinfachung
Mit den folgenden Befehlen wird eine Tabelle erstellt und es wird versucht, Daten zu erfassen, die ohne Vereinfachung nicht in die maximale Geometriegröße passen. Untersuchen Sie das `gis_osm_water_a_free_1.shp`-Shapefile und erstellen Sie die entsprechende Tabelle wie folgt.
```
CREATE TABLE norway_water (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Wenn der Befehl COPY ausgeführt wird, führt dies zu einem Fehler.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
ERROR: Load into table 'norway_water' failed. Check 'stl_load_errors' system table for details.
```
Eine Abfrage von `STL_LOAD_ERRORS` zeigt an, dass die Geometrie zu groß ist.
```
SELECT line_number, btrim(colname), btrim(err_reason) FROM stl_load_errors WHERE query = pg_last_copy_id();
line_number | btrim | btrim
-------------+--------------+-----------------------------------------------------------------------
1184705 | wkb_geometry | Geometry size: 1513736 is larger than maximum supported size: 1048447
```
Zur Vereinfachung der Geometrien wird der Parameter `SIMPLIFY AUTO` zum COPY-Befehl hinzugefügt.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989196 record(s) loaded successfully.
```
Um die Zeilen und Geometrien anzuzeigen, die vereinfacht wurden, fragen Sie ab `SVL_SPATIAL_SIMPLIFY`.
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
Die Verwendung von SIMPLIFY AUTO *max\$1tolerance* mit einer Toleranz, die niedriger ist als die automatisch berechnete, führt wahrscheinlich zu einem Einlesefehler. In diesem Fall sollten Sie MAXERROR verwenden, um Fehler zu ignorieren.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO 1.1E-05
MAXERROR 2
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989195 record(s) loaded successfully.
INFO: Load into table 'norway_water' completed, 1 record(s) could not be loaded. Check 'stl_load_errors' system table for details.
```
Fragen Sie `SVL_SPATIAL_SIMPLIFY` erneut ab, um den Datensatz zu identifizieren, den COPY nicht laden konnte.
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+-----------------
29 | 1184704 | 1.1e-05 | 1513736 | f | 0 | 0
29 | 1664115 | 1.1e-05 | 1233456 | t | 794432 | 1.1e-05
```
In diesem Beispiel konnte der erste Datensatz nicht eingefügt werden, sodass die Spalte `simplified` falsch angezeigt wird. Der zweite Datensatz wurde innerhalb der vorgegebenen Toleranz geladen. Die endgültige Größe ist jedoch größer als bei Verwendung der automatisch berechneten Toleranz ohne Angabe der maximalen Toleranz.
### Laden aus einem komprimierten Shapefile
Die COPY-Funktion von Amazon Redshift unterstützt die Erfassung von Daten aus einem komprimierten Shapefile. Alle Shapefile-Komponenten müssen dasselbe Amazon-S3-Präfix und dasselbe Komprimierungssuffix aufweisen. Nehmen wir an, Sie möchten die Daten aus dem vorherigen Beispiel laden. In diesem Fall müssen sich die Dateien `gis_osm_water_a_free_1.shp.gz`, `gis_osm_water_a_free_1.dbf.gz` und `gis_osm_water_a_free_1.shx.gz` das gleiche Amazon-S3-Verzeichnis teilen. Der COPY-Befehl erfordert die Option GZIP, und in der FROM-Klausel muss die richtige komprimierte Datei angegeben werden, wie im Folgenden gezeigt.
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/compressed/gis_osm_natural_free_1.shp.gz'
FORMAT SHAPEFILE
GZIP
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully.
```
### Laden von Daten in eine Tabelle mit einer anderen Spaltenreihenfolge
Wenn Sie eine Tabelle haben, die nicht `GEOMETRY` als erste Spalte hat, können Sie die Spalten-Mapping verwenden, um die Spalten der Zieltabelle zuzuordnen. Erstellen Sie z. B. eine Tabelle mit `osm_id` als erste Spalte.
```
CREATE TABLE norway_natural_order (
osm_id BIGINT,
wkb_geometry GEOMETRY,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Laden Sie dann ein Shapefile unter Verwendung des Spalten-Mappings.
```
COPY norway_natural_order(wkb_geometry, osm_id, code, fclass, name)
FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_order' completed, 83891 record(s) loaded successfully.
```
### Laden von Daten in eine Tabelle mit einer Geografiespalte
Wenn Sie eine Tabelle mit einer `GEOGRAPHY`-Spalte haben, erfassen Sie zuerst in eine `GEOMETRY`-Spalte und wandeln dann die Objekte in `GEOGRAPHY`-Objekte um. Zum Beispiel: Nachdem Sie Ihr Shapefile in eine `GEOMETRY`-Spalte kopiert haben, ändern Sie die Tabelle, um eine Spalte mit dem Datentyp `GEOGRAPHY` hinzuzufügen.
```
ALTER TABLE norway_natural ADD COLUMN wkb_geography GEOGRAPHY;
```
Dann konvertieren Sie die Geometrien in Geografien.
```
UPDATE norway_natural SET wkb_geography = wkb_geometry::geography;
```
Optional können Sie auch die `GEOMETRY`-Spalte entfernen.
```
ALTER TABLE norway_natural DROP COLUMN wkb_geometry;
```
## COPY-Befehl mit der Option NOLOAD
Verwenden Sie die Option NOLOAD mit dem COPY-Befehl, um Datendateien zu validieren, bevor sie tatsächlich geladen werden. Amazon Redshift analysiert die Eingabedatei und zeigt alle auftretenden Fehler an. Das folgende Beispiel verwendet die Option NOLOAD und es werden tatsächlich keine Zeilen in die Tabelle geladen.
```
COPY public.zipcode1
FROM 's3://amzn-s3-demo-bucket/mydata/zipcode.csv'
DELIMITER ';'
IGNOREHEADER 1 REGION 'us-east-1'
NOLOAD
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/myRedshiftRole';
Warnings:
Load into table 'zipcode1' completed, 0 record(s) loaded successfully.
```
## Befehl COPY mit Multibyte-Trennzeichen und Option ENCODING
Das folgende Beispiel wird LATIN1 aus einer Amazon S3 S3-Datei geladen, die Multibyte-Daten enthält. Der Befehl COPY gibt das Trennzeichen im Oktalformat `\302\246\303\254` an, um die Felder in einer Eingabedatei zu trennen, codiert als ISO-8859-1. Um dasselbe Trennzeichen in UTF-8 anzugeben, geben Sie `DELIMITER '¦ì'` an.
```
COPY latin1
FROM 's3://amzn-s3-demo-bucket/multibyte/myfile'
IAM_ROLE 'arn:aws:iam::123456789012:role/myRedshiftRole'
DELIMITER '\302\246\303\254'
ENCODING ISO88591
```
# CREATE DATABASE
Erstellt eine neue Datenbank.
Sie müssen ein Superuser sein oder über die CREATEDB-Berechtigung verfügen, um eine Datenbank zu erstellen. Sie müssen ein Superuser sein oder sowohl über die Berechtigung CREATEDB als auch die Berechtigung CREATEUSER verfügen, um eine Datenbank zu erstellen, die mit einer Null-ETL-Integration verknüpft ist.
CREATE DATABASE kann nicht innerhalb eines Transaktionsblocks (BEGIN ... END). Weitere Informationen Transaktionen finden Sie unter [Isolierungsstufen in Amazon Redshift](c_serial_isolation.md).
## Syntax
```
CREATE DATABASE database_name
[ { [
FROM INTEGRATION ''[ DATABASE '' ]
[ SET ]
[ ACCEPTINVCHARS [=] { TRUE | FALSE }]
[ QUERY_ALL_STATES [=] { TRUE | FALSE }]
[ REFRESH_INTERVAL ]
[ TRUNCATECOLUMNS [=] { TRUE | FALSE } ]
[ HISTORY_MODE [=] {TRUE | FALSE} ]
]
[ WITH ]
[ OWNER [=] db_owner ]
[ CONNECTION LIMIT { limit | UNLIMITED } ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ]
[ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ]
}
| { FROM { { ARN '' } { WITH DATA CATALOG SCHEMA '' | WITH NO DATA CATALOG SCHEMA } } }
| { IAM_ROLE {default | 'SESSION' | 'arn:aws:iam:::role/' } }
| { [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid }
]
```
## Parameters
*database\$1name*
Name der neuen Datenbank. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
FROM INTEGRATION '' [ DATABASE '' ]
Gibt an, ob die Datenbank mit einer ID für eine Null-ETL-Integration erstellt werden soll. Sie können die `integration_id` aus der Systemansicht SVV\$1INTEGRATION abrufen. Bei Null-ETL-Integrationen für Aurora PostgreSQL müssen Sie auch einen Namen für `source_database` angeben, der auch aus SVV\$1INTEGRATION abgerufen werden kann.
Ein Beispiel finden Sie unter [Erstellen von Datenbanken zum Erhalt von Ergebnissen von Null-ETL-Integrationen](#r_CREATE_DATABASE-integration). Weitere Informationen zum Erstellen von Datenbanken mit Null-ETL-Integrationen finden Sie unter [Erstellen von Zieldatenbanken in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html) im *Managementleitfaden zu Amazon Redshift*.
SET
Optionales Schlüsselwort.
ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1
Die ACCEPTINVCHARS-Klausel legt fest, ob Null-ETL-Integrationstabellen mit der Aufnahme fortfahren, wenn ungültige Zeichen für den VARCHAR-Datentyp erkannt werden. Wenn ungültige Zeichen gefunden werden, wird das ungültige Zeichen durch ein standardmäßiges `?`-Zeichen ersetzt.
QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1
Die QUERY\$1ALL\$1STATES-Klausel legt fest, ob Null-ETL-Integrationstabellen in allen Status (`Synced`, `Failed`, `ResyncRequired` und `ResyncInitiated`) abgefragt werden können. Standardmäßig kann eine Null-ETL-Integrationstabelle nur im Status `Synced` abgefragt werden.
REFRESH\$1INTERVAL
Die REFRESH\$1INTERVAL-Klausel legt das ungefähre Zeitintervall in Sekunden für die Aktualisierung von Daten aus der Zero-ETL-Quelle in der Zieldatenbank fest. Der Wert für Null-ETL-Integrationen mit dem Quelltyp Aurora MySQL, Aurora PostgreSQL oder RDS for MySQL kann auf 0–432 000 Sekunden (5 Tage) festgelegt werden. Bei Null-ETL-Integrationen für Amazon DynamoDB kann der Wert auf 900–432.000 Sekunden (15 Minuten bis 5 Tage) festgelegt werden. Die Standardeinstellung für `interval` ist null (0) Sekunden für Null-ETL-Integrationen, deren Quelltyp Aurora MySQL, Aurora PostgreSQL oder RDS für MySQL ist. Bei Null-ETL-Integrationen für Amazon DynamoDB beträgt die Standardeinstellung für `interval` 900 Sekunden (15 Minuten).
TRUNCATECOLUMNS [=] \$1 TRUE \$1 FALSE \$1
Die TRUNCATECOLUMNS-Klausel legt fest, ob Null-ETL-Integrationstabellen mit der Aufnahme fortfahren, wenn die Werte für die VARCHAR-Spalten- oder SUPER-Spaltenattribute den Grenzwert überschreiten. Wenn `TRUE`, werden die Werte gekürzt, sodass sie in die Spalte passen, und die Werte von JSON-Attributen, die den verfügbaren Platz überschreiten, werden gekürzt, damit sie in die SUPER-Spalte passen.
HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1
Eine Klausel, die angibt, ob Amazon Redshift den Verlaufsmodus für alle neuen Tabellen in der angegebenen Datenbank festlegt. Diese Option gilt nur für Datenbanken, die für die Null-ETL-Integration erstellt wurden.
Die HISTORY\$1MODE-Klausel kann auf `TRUE` oder `FALSE` gesetzt werden. Der Standardwert ist `FALSE`. Informationen zu HISTORY\$1MODE finden Sie unter [Verlaufsmodus](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html) im *Managementleitfaden zu Amazon Redshift*.
WITH
Optionales Schlüsselwort.
OWNER [=] db\$1owner
Gibt den Benutzernamen des Datenbankbesitzers an.
CONNECTION LIMIT \$1 *Limit* \$1 UNLIMITED \$1
Die maximale Zahl von Datenbankverbindungen, die Benutzer gleichzeitig geöffnet haben dürfen. Das Limit wird für Superuser nicht durchgesetzt. Mithilfe des Schlüsselworts UNLIMITED können Sie die maximale Zahl gleichzeitiger Verbindungen festlegen. Möglicherweise gilt auch ein Limit für die Zahl der Verbindungen für die einzelnen Benutzer. Weitere Informationen finden Sie unter [CREATE USER](r_CREATE_USER.md). Der Standardwert ist UNLIMITED. Um die aktuellen Verbindungen anzuzeigen, führen Sie eine Abfrage für die Systemansicht [STV\$1SESSIONS](r_STV_SESSIONS.md) aus.
Wenn sowohl für Benutzer- als auch für Datenbankverbindungen Limits gelten, muss ein ungenutzter Verbindungsplatz verfügbar sein, der sich innerhalb beider Grenzen befindet, wenn ein Benutzer versucht, eine Verbindung herzustellen.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Eine Klausel, die angibt, ob beim Suchen oder Vergleichen von Zeichenfolgen zwischen Groß- und Kleinschreibung unterschieden wird oder nicht. Die Standardeinstellung ist die Unterscheidung zwischen Groß- und Kleinschreibung.
COLLATE wird nicht unterstützt, wenn Sie eine Datenbank aus einem Datashare erstellen.
CASE\$1SENSITIVE und CS sind austauschbar und liefern dieselben Ergebnisse. Ebenso sind CASE\$1INSENSITIVE und CI austauschbar und führen zu denselben Ergebnissen.
ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1
Eine Klausel, die die verwendete Isolationsstufe bei Abfragen für eine Datenbank angibt. Weitere Informationen zu Isolationsstufen finden Sie unter [Isolierungsstufen in Amazon Redshift](c_serial_isolation.md).
+ SNAPSHOT-Isolation – bietet eine Isolationsstufe mit Schutz vor Aktualisierungs- und Löschkonflikten. Dies ist der Standardwert für eine Datenbank, die in einem bereitgestellten Cluster oder in einem Serverless-Namespace erstellt wurde.
+ SERIALIZABLE-Isolation (serialisierbare Isolation) – bietet volle Serialisierbarkeit für gleichzeitige Transaktionen.
FROM ARN ''
Der AWS Glue Datenbank-ARN, der zum Erstellen der Datenbank verwendet werden soll.
\$1 WITH DATA CATALOG SCHEMA '' \$1 WITH NO DATA CATALOG SCHEMA \$1
Dieser Parameter ist nur anwendbar, wenn Ihr CREATE DATABASE-Befehl auch den FROM ARN-Parameter verwendet.
Gibt an, ob die Datenbank unter Verwendung eines Schemas zur Unterstützung des Zugriffs in AWS Glue Data Catalog erstellt werden soll.
IAM\$1ROLE \$1Standard \$1 'SESSION' \$1 'arn:aws:iam: :role/ '\$1 ** **
Dieser Parameter ist nur anwendbar, wenn Ihr CREATE DATABASE-Befehl auch den FROM ARN-Parameter verwendet.
Wenn Sie beim Ausführen des CREATE DATABASE-Befehls eine IAM-Rolle angeben, die dem Cluster zugeordnet ist, verwendet Amazon Redshift die Anmeldeinformationen der Rolle, wenn Sie Abfragen in der Datenbank ausführen.
Die Angabe des Schlüsselworts `default` bedeutet, die IAM-Rolle zu verwenden, die als Standard festgelegt und mit dem Cluster verknüpft ist.
Verwenden Sie `'SESSION'`, wenn Sie über eine Verbundidentität eine Verbindung zu Ihrem Amazon-Redshift-Cluster herstellen und über das mit diesem Befehl erstellte externe Schema auf die Tabellen zugreifen. Ein Beispiel zur Verwendung einer Verbundidentität finden Sie unter [Verwenden einer Verbundidentitä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). Darin wird erläutert, wie Sie eine Verbundidentität konfigurieren.
Verwenden Sie den Amazon-Ressourcennamen (ARN) für eine IAM-Rolle, die von Ihrem Cluster für Authentifizierung und Autorisierung verwendet wird. Die IAM-Rolle muss mindestens die Berechtigung besitzen, eine LIST-Operation für den Amazon-S3-Bucket auszuführen, auf den zugegriffen werden soll, und eine GET-Operation für die Amazon-S3-Objekte, die der Bucket enthält. Weitere Informationen zur Verwendung von IAM\$1ROLE beim Erstellen einer Datenbank mithilfe von AWS Glue Data Catalog For Datashares finden Sie unter [Working with Lake Formation-managed](https://docs.aws.amazon.com/redshift/latest/dg/lake-formation-getting-started-consumer.html) datashares as a consumer.
Nachfolgend ist die Syntax für die IAM\$1ROLE-Parameterzeichenfolge für einen einzelnen ARN aufgeführt.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
Sie können Rollen miteinander verketten. Auf diese Weise kann der Cluster eine andere IAM-Rolle annehmen, die möglicherweise zu einem anderen Konto gehört. Es können bis zu 10 Rollen miteinander verkettet werden. Weitere Informationen finden Sie unter [Verketten von IAM-Rollen in Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
Fügen Sie dieser IAM-Rolle eine IAM-Berechtigungsrichtlinie ähnlich der folgenden an:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessSecret",
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds"
],
"Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword",
"secretsmanager:ListSecrets"
],
"Resource": "*"
}
]
}
```
Informationen zu den Schritten für das Erstellen einer IAM-Rolle zur Verwendung mit der Verbundabfrage finden Sie unter [Erstellen eines Secrets und einer IAM-Rolle für die Verwendung von Verbundabfragen](federated-create-secret-iam-role.md).
Fügen Sie keine Leerzeichen in die Liste der verketteten Rollen ein.
Nachfolgend finden Sie die Syntax für die Verkettung von drei Rollen.
```
IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
## Syntax für die Verwendung von CREATE DATABASE mit einem Datashare
Die folgende Syntax beschreibt den Befehl CREATE DATABASE, der verwendet wird, um Datenbanken aus einem Datashare für die gemeinsame Nutzung von Daten innerhalb desselben Kontos zu erstellen. AWS
```
CREATE DATABASE database_name
[ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid
```
Die folgende Syntax beschreibt den Befehl CREATE DATABASE, der verwendet wird, um Datenbanken aus einem Datashare für die gemeinsame Nutzung von Daten zwischen Konten zu erstellen. AWS
```
CREATE DATABASE database_name
[ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF ACCOUNT account_id NAMESPACE namespace_guid
```
### Parameter für die Verwendung von CREATE DATABASE mit einem Datashare
VOM DATASHARE
Ein Schlüsselwort, das angibt, wo sich das Datashare befindet.
*datashare\$1name*
Der Name des Datashares,in dem die Consumer-Datenbank erstellt wird.
WITH PERMISSIONS
Gibt an, dass für die aus dem Datashare erstellte Datenbank für den Zugriff auf einzelne Datenbankobjekte Berechtigungen auf Objektebene erforderlich sind. Ohne diese Klausel haben Benutzer oder Rollen, denen die USAGE-Berechtigung für die Datenbank erteilt wurde, automatisch Zugriff auf alle Datenbankobjekte in der Datenbank.
NAMESPACE *namespace\$1guid*
Ein Wert, der den Produzenten-Namespace angibt, zu dem das Datashare gehört.
ACCOUNT *account\$1id*
Ein Wert, der das Produzenten-Konto angibt, zu dem das Datashare gehört.
## Verwendungshinweise für CREATE DATABASE in Verbindung mit Datashares
Wenn Sie als Datenbank-Superuser CREATE DATABASE verwenden, um Datenbanken aus Datenfreigaben innerhalb des AWS Kontos zu erstellen, geben Sie die Option NAMESPACE an. Die Option ACCOUNT ist optional. Wenn Sie CREATE DATABASE verwenden, um Datenbanken aus AWS -kontenübergreifenden Datashares zu erstellen, geben Sie sowohl ACCOUNT als auch NAMESPACE vom Produzenten an.
Sie können nur eine Konsumentendatenbank für ein Datashare in einem Konsumenten-Cluster erstellen. Sie können nicht mehrere Konsumentendatenbanken erstellen, die auf dasselbe Datashare verweisen.
## DATENBANK ERSTELLEN von AWS Glue Data Catalog
Um eine Datenbank mit einem AWS Glue Datenbank-ARN zu erstellen, geben Sie den ARN in Ihrem CREATE DATABASE-Befehl an.
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA;
```
Optional können Sie auch einen Wert im IAM\$1ROLE-Parameter eingeben. Weitere Informationen zu Parametern und zulässigen Werten finden Sie unter [Parameter](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html#r_CREATE_DATABASE-parameters).
Die folgenden Beispiele veranschaulichen, wie Sie mithilfe einer IAM-Rolle eine Datenbank aus einem ARN erstellen.
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE
```
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE default;
```
Sie können eine Datenbank auch mithilfe eines DATA CATALOG SCHEMA erstellen.
```
CREATE DATABASE sampledb FROM ARN WITH DATA CATALOG SCHEMA IAM_ROLE default;
```
## Erstellen von Datenbanken zum Erhalt von Ergebnissen von Null-ETL-Integrationen
Um eine Datenbank mit einer Null-ETL-Integration zu erstellen, geben Sie die `integration_id` in Ihrem Befehl CREATE DATABASE an.
```
CREATE DATABASE destination_db_name FROM INTEGRATION 'integration_id';
```
Sie können beispielsweise zunächst die Integrations-IDs aus SVV\$1INTEGRATION ab.
```
SELECT integration_id FROM SVV_INTEGRATION;
```
Verwenden Sie dann eine der abgerufenen Integrations-IDs, um die Datenbank zu erstellen, die Null-ETL-Integrationen erhält.
```
CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111';
```
Wenn die Quelldatenbank für Null-ETL-Integrationen benötigt wird, geben Sie beispielsweise Folgendes an.
```
CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' DATABASE sourcedb;
```
Sie können auch ein Aktualisierungsintervall für die Datenbank festlegen. So legen Sie beispielsweise das Aktualisierungsintervall für Daten aus einer Null-ETL-Integrationsquelle auf 7.200 Sekunden fest:
```
CREATE DATABASE myacct_mysql FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET REFRESH_INTERVAL 7200;
```
Fragen Sie die Katalogsicht SVV\$1INTEGRATION nach Informationen zu einer Null-ETL-Integration ab, z. B. integration\$1id, target\$1database, source, refresh\$1interval und mehr.
```
SELECT * FROM svv_integration;
```
Im folgenden Beispiel wird eine Datenbank aus einer Integration bei aktiviertem Verlaufsmodus erstellt.
```
CREATE DATABASE sample_integration_db FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET HISTORY_MODE = true;
```
## Limits für CREATE DATABASE
Amazon Redshift setzt diese Limits für Datenbanken durch:
+ Pro Cluster sind höchstens 60 benutzerdefinierte Datenbanken zulässig.
+ Datenbanknamen dürfen höchstens 127 Bytes enthalten.
+ Ein Datenbankname darf kein reserviertes Wort sein.
## Datenbanksortierung
Bei der Sortierung handelt es sich um einen Regelsatz, der definiert, wie das Datenbankmodul die Zeichentypdaten in SQL vergleicht und sortiert. Die Sortierung ohne Berücksichtigung der Groß-/Kleinschreibung ist die am häufigsten verwendete Methode. Amazon Redshift verwendet eine groß-/kleinschreibungsneutrale Sortierung, um die Migration von anderen Data-Warehouse-Systemen zu erleichtern. Amazon Redshift unterstützt nativ die groß-/kleinschreibungsneutrale Sortierung und verwendet weiterhin zentrale Optimierungsmethoden wie Verteilungsschlüssel, Sortierschlüssel oder bereichsbeschränkte Scans.
Die COLLATE-Klausel legt die Standardsortierung für alle CHAR- und VARCHAR-Spalten in der Datenbank fest. Wenn CASE\$1INSENSITIVE angegeben ist, verwenden alle CHAR- oder VARCHAR-Spalten eine groß-/kleinschreibungsneutrale Sortierung. Weitere Informationen zur Sortierung finden Sie unter [Sortierreihenfolgen](c_collation_sequences.md).
Daten, die in Spalten ohne Berücksichtigung der Groß-/Kleinschreibung eingefügt oder übernommen werden, behalten ihre ursprüngliche Groß-/Kleinschreibung bei. Bei allen vergleichsbasierten Zeichenfolgenoperationen, einschließlich Sortieren und Gruppieren, wird die Groß- und Kleinschreibung nicht berücksichtigt. Mustervergleichsoperationen wie LIKE-Prädikate, „ähnlich wie“ und Funktionen für reguläre Ausdrücke sind ebenfalls unabhängig von der Groß- und Kleinschreibung.
Die folgenden SQL-Operationen unterstützen die geltende Sortiersemantik:
+ Vergleichsoperatoren: =, <>, <, <=, >, >=.
+ LIKE-Operator
+ ORDER BY-Klauseln
+ GROUP BY-Klauseln
+ Aggregatfunktionen, die einen String-Vergleich verwenden, wie MIN und MAX und LISTAGG
+ Fensterfunktionen, wie PARTITION BY-Klauseln und ORDER BY-Klauseln
+ Skalare Funktionen greatest() und least(), STRPOS(), REGEXP\$1COUNT(), REGEXP\$1REPLACE(), REGEXP\$1INSTR(), REGEXP\$1SUBSTR()
+ Distinct-Klausel
+ UNION, INTERSECT und EXCEPT
+ IN LIST
Bei externen Abfragen, einschließlich Verbundabfragen in Amazon Redshift Spectrum und Aurora PostgreSQL, ist die Sortierung der VARCHAR- oder CHAR-Spalte die gleiche wie die aktuelle Sortierung auf Datenbankebene.
Im folgenden Beispiel wird eine Amazon-Redshift-Spectrum-Tabelle abgefragt:
```
SELECT ci_varchar FROM spectrum.test_collation
WHERE ci_varchar = 'AMAZON';
ci_varchar
----------
amazon
Amazon
AMAZON
AmaZon
(4 rows)
```
Weitere Informationen zur Erstellung von Tabellen mit der Datenbanksortierung finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Weitere Informationen über die COLLATE-Funktionen finden Sie unter [Funktion COLLATE](r_COLLATE.md).
### Einschränkungen bei der Datenbanksortierung
Die folgenden Einschränkungen gelten für die Verwendung der Datenbanksortierung in Amazon Redshift:
+ Bei allen Systemtabellen oder -ansichten, einschließlich PG-Katalogtabellen und Amazon-Redshift-Systemtabellen, wird die Groß- und Kleinschreibung beachtet.
+ Wenn Consumer- und Producer-Datenbank auf Datenbankebene unterschiedliche Sortierungen verwenden, unterstützt Amazon Redshift keine datenbank- und clusterübergreifenden Abfragen.
+ Amazon Redshift unterstützt keine groß-/kleinschreibungsneutrale Sortierung in Abfragen, die ausschließlich für Führungsknoten gelten.
Das folgende Beispiel zeigt eine nicht unterstützte groß-/kleinschreibungsneutrale Abfrage und den Fehler, den Amazon Redshift sendet:
```
SELECT collate(usename, 'case_insensitive') FROM pg_user;
ERROR: Case insensitive collation is not supported in leader node only query.
```
+ Amazon Redshift unterstützt keine Interaktion zwischen Spalten mit und ohne Unterscheidung zwischen Groß-/Kleinschreibung, wie z. B. Vergleichs-, Funktions-, Join- oder Set-Operationen.
Die folgenden Beispiele zeigen Fehler bei der Interaktion von Spalten mit und ohne Unterscheidung zwischen Groß-/Kleinschreibung:
```
CREATE TABLE test
(ci_col varchar(10) COLLATE case_insensitive,
cs_col varchar(10) COLLATE case_sensitive,
cint int,
cbigint bigint);
```
```
SELECT ci_col = cs_col FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT concat(ci_col, cs_col) FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT ci_col FROM test UNION SELECT cs_col FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT * FROM test a, test b WHERE a.ci_col = b.cs_col;
ERROR: Query with different collations is not supported yet.
```
```
Select Coalesce(ci_col, cs_col) from test;
ERROR: Query with different collations is not supported yet.
```
```
Select case when cint > 0 then ci_col else cs_col end from test;
ERROR: Query with different collations is not supported yet.
```
Damit diese Abfragen funktionieren, können Sie mit der Funktion COLLATE die Sortierung der einen Spalte an die andere anpassen. Weitere Informationen finden Sie unter [Funktion COLLATE](r_COLLATE.md).
## Beispiele
**Erstellen einer Datenbank**
Im folgenden Beispiel wird eine Datenbank namens TICKIT erstellt und der Benutzer DWUSER ist der Besitzer:
```
create database tickit
with owner dwuser;
```
Führen Sie eine Abfrage für die Katalogtabelle PG\$1DATABASE\$1INFO aus, um Details zu Datenbanken anzuzeigen.
```
select datname, datdba, datconnlimit
from pg_database_info
where datdba > 1;
datname | datdba | datconnlimit
-------------+--------+-------------
admin | 100 | UNLIMITED
reports | 100 | 100
tickit | 100 | 100
```
Im folgenden Beispiel wird eine Datenbank namens **sampledb** mit der Isolationsstufe SNAPSHOT erstellt.
```
CREATE DATABASE sampledb ISOLATION LEVEL SNAPSHOT;
```
Im folgenden Beispiel wird die Datenbank sales\$1db aus dem Datashare salesshare erstellt.
```
CREATE DATABASE sales_db FROM DATASHARE salesshare OF NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d';
```
### Beispiele für die Datenbanksortierung
**Erstellen einer groß-/kleinschreibungsneutralen Datenbank**
Im folgenden Beispiel wird die Datenbank `sampledb` und die Tabelle `T1` erstellt und anschließend werden Daten in die Tabelle `T1` eingefügt.
```
create database sampledb collate case_insensitive;
```
Stellen Sie mit Ihrem SQL-Client eine Verbindung mit der neuen Datenbank her, die Sie gerade erstellt haben. Wenn Sie den Amazon Redshift Query Editor v2 verwenden, wählen Sie `sampledb` im **Editor** aus. Wenn Sie RSQL nutzen, verwenden Sie einen ähnlichen Befehl wie den folgenden.
```
\connect sampledb;
```
```
CREATE TABLE T1 (
col1 Varchar(20) distkey sortkey
);
```
```
INSERT INTO T1 VALUES ('bob'), ('john'), ('Mary'), ('JOHN'), ('Bob');
```
Die Abfrage findet dann Ergebnisse mit dem Inhalt `John`.
```
SELECT * FROM T1 WHERE col1 = 'John';
col1
------
john
JOHN
(2 row)
```
**Groß-/kleinschreibungsneutrale Sortierung**
Das folgende Beispiel zeigt eine groß-/kleinschreibungsneutrale Sortierung mit Tabelle T1. Die Reihenfolge von *Bob* und *bob* oder *John* und *john* ist nicht deterministisch, da sie in einer Spalte gleich sind, die nicht zwischen Groß- und Kleinschreibung unterscheidet.
```
SELECT * FROM T1 ORDER BY 1;
col1
------
bob
Bob
JOHN
john
Mary
(5 rows)
```
In ähnlicher Weise zeigt das folgende Beispiel eine Sortierung ohne Berücksichtigung der Groß- und Kleinschreibung mit der GROUP BY-Klausel. *Bob* und *bob* sind gleich und gehören zur gleichen Gruppe. Es ist nicht deterministisch, was im Ergebnis auftaucht.
```
SELECT col1, count(*) FROM T1 GROUP BY 1;
col1 | count
-----+------
Mary | 1
bob | 2
JOHN | 2
(3 rows)
```
**Abfragen von groß-/kleinschreibungsneutralen Spalten mit einer Fensterfunktion**
Im folgenden Beispiel wird eine Fensterfunktion zur Abfrage einer Spalte verwendet, in der die Groß- und Kleinschreibung nicht berücksichtigt wird.
```
SELECT col1, rank() over (ORDER BY col1) FROM T1;
col1 | rank
-----+------
bob | 1
Bob | 1
john | 3
JOHN | 3
Mary | 5
(5 rows)
```
**Abfragen mit dem Schlüsselwort DISTINCT**
Im folgenden Beispiel wird die Tabelle `T1` mit dem Schlüsselwort DISTINCT abgefragt.
```
SELECT DISTINCT col1 FROM T1;
col1
------
bob
Mary
john
(3 rows)
```
**Abfrage mit der UNION-Klausel**
Das folgende Beispiel zeigt die Ergebnisse der UNION der Tabellen `T1` und `T2`.
```
CREATE TABLE T2 AS SELECT * FROM T1;
```
```
SELECT col1 FROM T1 UNION SELECT col1 FROM T2;
col1
------
john
bob
Mary
(3 rows)
```
# DATASHARE ERSTELLEN
Erzeugt ein neues Datashare in der aktuellen Datenbank. Der Besitzer dieses Datashares ist derjenige, der den Befehl CREATE DATASHARE eingegeben hat.
Amazon Redshift verknüpft jedes Datashare mit einer einzelnen Amazon-Redshift-Datenbank. Sie können nur Objekte aus dieser Datenbank dem zugeordneten Datashare hinzufügen. Sie können mehrere Datashares in derselben Amazon-Redshift-Datenbank erstellen.
Weitere Informationen zu Datashares finden Sie unter [Datenfreigabe in Amazon Redshift](datashare-overview.md).
Verwenden Sie zum Anzeigen von Informationen zu Datashares [SHOW DATASHARES](r_SHOW_DATASHARES.md).
## Erforderliche Berechtigungen
Im Folgenden sind die erforderlichen Berechtigungen für CREATE DATASHARE aufgeführt:
+ Superuser
+ Benutzer mit der Berechtigung CREATE DATASHARE
+ Datenbankbesitzer
## Syntax
```
CREATE DATASHARE datashare_name
[[SET] PUBLICACCESSIBLE [=] TRUE | FALSE ];
```
## Parameters
*datashare\$1name*
Der Name des Datashares. Der Name des Datashares muss im Cluster-Namespace eindeutig sein.
[[SET] PUBLICACCESSIBLE]
Eine Klausel, die angibt, ob das Datashare für öffentlich zugängliche Cluster freigegeben werden kann.
Der Standardwert für den `SET PUBLICACCESSIBLE` beträgt `FALSE`.
## Nutzungshinweise
Standardmäßig hat der Besitzer des Datashares Rechte nur für die Freigabe, nicht aber für die Objekte innerhalb der Freigabe.
Nur Superuser und der Datenbankbesitzer können CREATE DATASHARE verwenden und ALTER-Berechtigungen an andere Benutzer oder Gruppen delegieren.
## Beispiele
Im folgenden Beispiel wird das Datashare `salesshare` erstellt.
```
CREATE DATASHARE salesshare;
```
Im folgenden Beispiel wird das Datashare `demoshare` erstellt, der von AWS Data Exchange verwaltet wird.
```
CREATE DATASHARE demoshare SET PUBLICACCESSIBLE TRUE, MANAGEDBY ADX;
```
# CREATE EXTERNAL FUNCTION
Erstellt eine skalare benutzerdefinierte Funktion (UDF), die auf AWS Lambda Amazon Redshift basiert. Weitere Informationen zu benutzerdefinierten Lambda-Funktionen finden Sie unter [Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md).
## Erforderliche Berechtigungen
Für CREATE EXTERNAL FUNCTION sind folgende Berechtigungen erforderlich:
+ Superuser
+ Benutzer mit der Berechtigung CREATE [OR REPLACE] EXTERNAL FUNCTION
## Syntax
```
CREATE [ OR REPLACE ] EXTERNAL FUNCTION external_fn_name ( [data_type] [, ...] )
RETURNS data_type
{ VOLATILE | STABLE }
LAMBDA 'lambda_fn_name'
IAM_ROLE { default | ‘arn:aws:iam:::role/’
RETRY_TIMEOUT milliseconds
MAX_BATCH_ROWS count
MAX_BATCH_SIZE size [ KB | MB ];
```
## Parameters
OR REPLACE
Die Klausel gibt an, dass die vorhandene Funktion ersetzt wird, wenn eine Funktion mit demselben Namen und denselben Eingabeargument-Datentypen bzw. derselben *Signatur* vorhanden ist. Sie können eine Funktion nur durch eine neue Funktion ersetzen, wenn diese einen identischen Satz von Datentypen definiert. Sie müssen Superuser sein, um eine Funktion zu ersetzen.
Wenn Sie eine Funktion definieren, die den gleichen Namen wie eine vorhandene Funktion, aber eine andere Signatur besitzt, erstellen Sie eine neue Funktion. Der Funktionsname wird also überladen. Weitere Informationen finden Sie unter [Überladen von Funktionsnamen](udf-naming-udfs.md#udf-naming-overloading-function-names).
*external\$1fn\$1name*
Der Name der externen Funktion. Wenn Sie einen Schemanamen angeben (z. B. myschema.myfunction), wird die Funktion unter Verwendung des angegebenen Schemas erstellt. Andernfalls wird die Funktion im aktuellen Schema erstellt. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
Es wird empfohlen, dass Sie alle UDFs mit dem Präfix benennen `f_`. Amazon Redshift reserviert das Präfix `f_` für UDF-Namen. Durch die Verwendung des `f_`-Präfixes stellen Sie sicher, dass Ihr UDF-Name nicht mit den SQL-Funktionsnamen für Amazon Redshift kollidiert, weder jetzt noch in Zukunft. Weitere Informationen finden Sie unter [Verhindern von UDF-Namenskonflikten](udf-naming-udfs.md).
*data\$1type*
Der Datentyp der Eingabeargumente. Weitere Informationen erhalten Sie unter [Skalares Python UDFs](udf-creating-a-scalar-udf.md) und [Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md).
RETURNS *data\$1type*
Der Datentyp des Werts, der von der Funktion zurückgegeben wird. Der RETURNS-Datentyp kann ein beliebiger Standard-Amazon-Redshift-Datentyp sein. Weitere Informationen erhalten Sie unter [Skalares Python UDFs](udf-creating-a-scalar-udf.md) und [Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md).
VOLATILE \$1 STABLE
Informiert den Abfragenoptimierer über die Volatilität der Funktion.
Um die beste Optimierung zu erzielen, kennzeichnen Sie Ihre Funktion mit der strengsten Volatilitätskategorie, die für sie gültig ist. Beginnend mit der Volatilitätskategorie mit der geringsten Strenge sind dies die Volatilitätskategorien:
+ VOLATILE
+ STABLE
VOLATILE
Bei gleichen Argumenten kann die Funktion unterschiedliche Ergebnisse für aufeinanderfolgende Aufrufe zurückgeben, auch für die Zeilen in einer einzelnen Anweisung. Der Abfrageoptimierer kann keine Annahmen über das Verhalten einer volatilen Funktion treffen. Eine Abfrage, die eine volatile Funktion verwendet, muss die Funktion für jede Eingabe neu auswerten.
STABLE
Bei gleichen Argumenten gibt die Funktion garantiert die gleichen Ergebnisse für alle aufeinderfolgenden Aufrufe zurück, die innerhalb einer einzelnen Anweisung verarbeitet werden. Die Funktion kann unterschiedliche Ergebnisse zurückgeben, wenn sie in unterschiedlichen Anweisungen aufgerufen wird. Diese Kategorie ermöglicht es dem Optimierer, die Häufigkeit zu reduzieren, mit der die Funktion innerhalb einer einzigen Anweisung aufgerufen wird.
Beachten Sie, dass, wenn die ausgewählte Strenge für die Funktion nicht gültig ist, das Risiko besteht, dass der Optimierer aufgrund dieser Strenge einige Aufrufe überspringt. Dies kann zu einer falschen Ergebnismenge führen.
Die IMMUTABLE-Klausel wird derzeit für UDFs Lambda nicht unterstützt.
LAMBDA *'lambda\$1fn\$1name'*
Der Name der Funktion, die Amazon Redshift aufruft.
Schritte zum Erstellen einer AWS Lambda Funktion finden Sie unter [Erstellen einer Lambda-Funktion mit der Konsole](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html) im *AWS Lambda Entwicklerhandbuch*.
Informationen zu den für die Lambda-Funktion erforderlichen Berechtigungen finden Sie unter [AWS Lambda -Berechtigungen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html) im *AWS Lambda -Entwicklerhandbuch*.
IAM\$1ROLE \$1default \$1 'arn:aws:iam: ::role/ '****
Verwenden Sie das Standardstichwort, damit Amazon Redshift die IAM-Rolle verwendet, die als Standard festgelegt und mit dem Cluster verknüpft ist, wenn der CREATE EXTERNAL FUNCTION-Befehl ausgeführt wird.
Verwenden Sie den Amazon-Ressourcennamen (ARN) für eine IAM-Rolle, die von Ihrem Cluster für Authentifizierung und Autorisierung verwendet wird. Der Befehl CREATE EXTERNAL FUNCTION ist berechtigt, über diese IAM-Rolle Lambda-Funktionen aufzurufen. Wenn Ihr Cluster über eine bestehende IAM-Rolle mit Berechtigungen zum Aufrufen von Lambda-Funktionen verfügt, können Sie den ARN Ihrer Rolle ersetzen. Weitere Informationen finden Sie unter [Konfiguration des Autorisierungsparameters für Lambda UDFs](udf-creating-a-lambda-sql-udf.md#udf-lambda-authorization).
Im Folgenden wird die Syntax für den Parameter IAM\$1ROLE gezeigt.
```
IAM_ROLE 'arn:aws:iam::aws-account-id:role/role-name'
```
RETRY\$1TIMEOUT *Millisekunden*
Die Gesamtzeit in Millisekunden, die Amazon Redshift für die Verzögerungen bei Wiederholungs-Backoffs verwendet.
Anstatt es bei fehlgeschlagenen Abfragen sofort erneut zu versuchen, führt Amazon Redshift Backoffs durch und wartet eine bestimmte Zeit zwischen den Wiederholungsversuchen. Dann wiederholt Amazon Redshift die Anfrage, um die fehlgeschlagene Abfrage erneut auszuführen, bis die Summe aller Verzögerungen gleich oder größer als der von Ihnen angegebene RETRY\$1TIMEOUT-Wert ist. Der Standardwert ist 20 000 Millisekunden.
Wenn eine Lambda-Funktion aufgerufen wird, wiederholt Amazon Redshift Abfragen, bei denen Fehler wie `TooManyRequestsException`, `EC2ThrottledException` und `ServiceException` auftreten.
Sie können den Parameter RETRY\$1TIMEOUT auf 0 Millisekunden setzen, um Wiederholungsversuche für eine Lambda-UDF zu verhindern.
MAX\$1BATCH\$1ROWS *Anzahl*
Die maximale Zeilenanzahl, die Amazon Redshift in einer einzelnen Batch-Anforderung für einen einzelnen Lambda-Aufruf sendet.
Der Mindestwert für diesen Parameter ist 1. Der maximale Wert lautet INT\$1MAX oder 2 147 483 647.
Dieser Parameter ist optional. Der Standardwert lautet INT\$1MAX oder 2 147 483 647.
MAX\$1BATCH\$1SIZE *Größe* [ KB \$1 MB ]
Die maximale Größe der Datennutzlast, die Amazon Redshift in einer einzelnen Batch-Anforderung für einen einzelnen Lambda-Aufruf sendet.
Der Mindestwert für diesen Parameter ist 1 KB. Der maximale Wert ist 5 MB.
Der Standardwert für diesen Parameter ist 5 MB.
KB und MB sind optional. Wenn Sie die Maßeinheit nicht festlegen, verwendet Amazon Redshift standardmäßig KB.
## Nutzungshinweise
Beachten Sie bei der Erstellung von Lambda UDFs Folgendes:
+ Die Reihenfolge der Lambda-Funktionsaufrufe für die Eingabeargumente ist nicht festgelegt oder garantiert. Dies kann je nach Cluster-Konfiguration von Instance zu Instance variieren, für die Abfragen ausgeführt werden.
+ Es wird nicht garantiert, dass die Funktionen tatsächlich nur einmal auf jedes Eingabeargument angewendet werden. Die Interaktion zwischen Amazon Redshift und AWS Lambda kann zu wiederholten Aufrufen mit denselben Eingaben führen.
## Beispiele
Im Folgenden finden Sie Beispiele für die Verwendung skalarer benutzerdefinierter Lambda-Funktionen (). UDFs
### Skalares Lambda-UDF-Beispiel mit einer Node.js-Lambda-Funktion
Im folgenden Beispiel wird eine externe Funktion namens `exfunc_sum` erstellt, die zwei Ganzzahlen als Eingabeargumente benötigt. Diese Funktion gibt die Summe als Ganzzahl aus. Der Name der aufzurufenden Lambda-Funktion lautet `lambda_sum`. Die für diese Lambda-Funktion verwendete Sprache ist Node.js 12.x. Stellen Sie sicher, dass Sie die IAM-Rolle angeben. Das Beispiel verwendet `'arn:aws:iam::123456789012:user/johndoe'` als IAM-Rolle.
```
CREATE EXTERNAL FUNCTION exfunc_sum(INT,INT)
RETURNS INT
VOLATILE
LAMBDA 'lambda_sum'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
```
Die Lambda-Funktion verarbeitet die Nutzlast der Anfrage und iteriert über jede Zeile. Alle Werte in einer einzelnen Zeile werden addiert, um die Summe für diese Zeile zu berechnen, die im Antwort-Array gespeichert wird. Die Anzahl der Zeilen im Ergebnis-Array entspricht der Anzahl der in der Nutzlast der Anfrage empfangenen Zeilen.
Die JSON-Antwort-Nutzlast muss die Ergebnisdaten im Feld „results“ enthalten, damit sie von der externen Funktion erkannt werden kann. Das Feld „arguments“ in der Anforderung, die an die Lambda Funktion gesendet wird, enthält die Datennutzlast. Bei einer Batch-Anforderung können mehrere Zeilen in den Nutzdaten vorhanden sein. Die folgende Lambda-Funktion iteriert über alle Zeilen in der Nutzlast der Anfragedaten. Sie durchläuft zudem alle Werte innerhalb einer einzelnen Zeile.
```
exports.handler = async (event) => {
// The 'arguments' field in the request sent to the Lambda function contains the data payload.
var t1 = event['arguments'];
// 'len(t1)' represents the number of rows in the request payload.
// The number of results in the response payload should be the same as the number of rows received.
const resp = new Array(t1.length);
// Iterating over all the rows in the request payload.
for (const [i, x] of t1.entries())
{
var sum = 0;
// Iterating over all the values in a single row.
for (const y of x) {
sum = sum + y;
}
resp[i] = sum;
}
// The 'results' field should contain the results of the lambda call.
const response = {
results: resp
};
return JSON.stringify(response);
};
```
Im folgenden Beispiel wird die externe Funktion mit Literalwerten aufgerufen.
```
select exfunc_sum(1,2);
exfunc_sum
------------
3
(1 row)
```
Im folgenden Beispiel wird eine Tabelle namens t\$1sum mit zwei Spalten, c1 und c2, vom Datentyp Ganzzahl erstellt und zwei Datenzeilen werden eingefügt. Dann wird die externe Funktion aufgerufen, indem die Spaltennamen dieser Tabelle übergeben werden. Die beiden Tabellenzeilen werden in einer Batch-Anforderung in der Anforderungsnutzlast als einzelner Lambda-Aufruf gesendet.
```
CREATE TABLE t_sum(c1 int, c2 int);
INSERT INTO t_sum VALUES (4,5), (6,7);
SELECT exfunc_sum(c1,c2) FROM t_sum;
exfunc_sum
---------------
9
13
(2 rows)
```
### Skalares Lambda-UDF-Beispiel unter Verwendung des RETRY\$1TIMEOUT-Attributs
Im folgenden Abschnitt finden Sie ein Beispiel für die Verwendung des RETRY\$1TIMEOUT-Attributs in Lambda. UDFs
AWS Lambda Funktionen haben Parallelitätsgrenzen, die Sie für jede Funktion festlegen können. Weitere Informationen zu Parallelitätslimits finden Sie unter [Managing Concurrency for a Lambda function](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html) im *AWS Lambda Developer Guide* und im Beitrag [Managing AWS Lambda Function Concurrency](https://aws.amazon.com/blogs/compute/managing-aws-lambda-function-concurrency) im Compute-Blog. AWS
Wenn die Anzahl der Anfragen, die von einer Lambda-UDF bedient werden, die Nebenläufigkeitslimits überschreitet, wird bei neuen Anfragen der Fehler `TooManyRequestsException` ausgegeben. Die Lambda-UDF versucht es bei diesem Fehler so lange erneut, bis die Summe aller Verzögerungen zwischen den an die Lambda-Funktion gesendeten Anforderungen dem von Ihnen festgelegten Wert RETRY\$1TIMEOUT entspricht oder diesen überschreitet. Der Standardwert für RETRY\$1TIMEOUT ist 20 000 Millisekunden.
Im folgenden Beispiel wird die Lambda-Funktion mit dem Namen erstellt `exfunc_sleep_3`. Diese Funktion verarbeitet die Nutzdaten der Anfrage, iteriert über jede Zeile und konvertiert die Eingabe in Großbuchstaben. Dann wartet sie 3 Sekunden und gibt das Ergebnis zurück. Die für diese Lambda-Funktion verwendete Sprache ist Python 3.8.
Die Anzahl der Zeilen im Ergebnis-Array entspricht der Anzahl der in der Nutzlast der Anfrage empfangenen Zeilen. Die JSON-Antwort-Nutzlast muss die Ergebnisdaten im Feld `results` enthalten, damit sie von der externen Funktion erkannt werden kann. Das Feld `arguments` in der Anforderung, die an die Lambda Funktion gesendet wird, enthält die Datennutzlast. Bei einer Batch-Anforderung können mehrere Zeilen in den Nutzdaten enthalten sein.
Das Nebenläufigkeitslimit für diese Funktion ist speziell auf 1 für die reservierte Nebenläufigkeit festgelegt, um die Verwendung des Attributs RETRY\$1TIMEOUT zu demonstrieren. Wenn das Attribut auf 1 gesetzt ist, kann die Lambda-Funktion jeweils nur eine Anfrage bedienen.
```
import json
import time
def lambda_handler(event, context):
t1 = event['arguments']
# 'len(t1)' represents the number of rows in the request payload.
# The number of results in the response payload should be the same as the number of rows received.
resp = [None]*len(t1)
# Iterating over all rows in the request payload.
for i, x in enumerate(t1):
# Iterating over all the values in a single row.
for j, y in enumerate(x):
resp[i] = y.upper()
time.sleep(3)
ret = dict()
ret['results'] = resp
ret_json = json.dumps(ret)
return ret_json
```
Im Folgenden werden zwei weitere Beispiele für das RETRY\$1TIMEOUT-Attribut beschrieben. Sie rufen jeweils eine einzelne Lambda-UDF auf. Beim Aufrufen der Lambda-UDF wird in jedem Beispiel dieselbe SQL-Abfrage ausgeführt, um die Lambda-UDF von zwei nebenläufigen Datenbanksitzungen aus aufzurufen. Wenn die erste Abfrage, die die Lambda-UDF aufruft, von der UDF bedient wird, wird für die zweite Abfrage der Fehler `TooManyRequestsException` angezeigt. Dieses Ergebnis tritt auf, weil Sie die reservierte Nebenläufigkeit in der UDF speziell auf 1 gesetzt haben. Informationen zum Festlegen der reservierten Nebenläufigkeit für Lambda-Funktionen finden Sie unter [Konfigurieren reservierter Gleichzeitigkeit](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html#configuration-concurrency-reservedconfiguration-concurrency-reserved).
Im folgenden ersten Beispiel wird das RETRY\$1TIMEOUT-Attribut für die Lambda-UDF auf 0 Millisekunden gesetzt. Wenn die Lambda-Anforderung eine Ausnahme von der Lambda-Funktion erhält, führt Amazon Redshift keine Wiederholungsversuche durch. Dieses Ergebnis tritt auf, weil das Attribut RETRY\$1TIMEOUT auf 0 gesetzt ist.
```
CREATE OR REPLACE EXTERNAL FUNCTION exfunc_upper(varchar)
RETURNS varchar
VOLATILE
LAMBDA 'exfunc_sleep_3'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'
RETRY_TIMEOUT 0;
```
Wenn RETRY\$1TIMEOUT auf 0 gesetzt ist, können Sie die folgenden zwei Abfragen in verschiedenen Datenbanksitzungen ausführen, um unterschiedliche Ergebnisse zu erhalten.
Die erste SQL-Abfrage, die die Lambda-UDF verwendet, wird erfolgreich ausgeführt.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
Für die zweite Abfrage, die in einer separaten Datenbanksitzung zur gleichen Zeit ausgeführt wird, wird der Fehler `TooManyRequestsException` angezeigt.
```
select exfunc_upper('Varchar');
ERROR: Rate Exceeded.; Exception: TooManyRequestsException; ShouldRetry: 1
DETAIL:
-----------------------------------------------
error: Rate Exceeded.; Exception: TooManyRequestsException; ShouldRetry: 1
code: 32103
context:query: 0
location: exfunc_client.cpp:102
process: padbmaster [pid=26384]
-----------------------------------------------
```
Im folgenden zweiten Beispiel wird das RETRY\$1TIMEOUT-Attribut für die Lambda-UDF auf 3 000 Millisekunden gesetzt. Selbst wenn die zweite Abfrage gleichzeitig ausgeführt wird, wiederholt die Lambda-UDF den Vorgang, bis die Gesamtverzögerung 3 000 Millisekunden beträgt. Daher werden beide Abfragen erfolgreich ausgeführt.
```
CREATE OR REPLACE EXTERNAL FUNCTION exfunc_upper(varchar)
RETURNS varchar
VOLATILE
LAMBDA 'exfunc_sleep_3'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'
RETRY_TIMEOUT 3000;
```
Wenn RETRY\$1TIMEOUT auf 3 000 Millisekunden eingestellt ist, können Sie die folgenden beiden Abfragen in verschiedenen Datenbanksitzungen ausführen, um dieselben Ergebnisse zu erhalten.
Die erste SQL-Abfrage, die die Lambda-UDF verwendet, wird erfolgreich ausgeführt.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
Die zweite Abfrage wird gleichzeitig ausgeführt, und die Lambda-UDF versucht es erneut, bis die Gesamtverzögerung 3 000 Millisekunden beträgt.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
### Skalares Lambda-UDF-Beispiel mit einer Python-Lambda-Funktion
Im folgenden Beispiel wird eine externe Funktion namens `exfunc_multiplication` erstellt, die Zahlen multipliziert und eine Ganzzahl zurückgibt. In diesem Beispiel sind die Erfolgs- und `error_msg`-Felder in der Lambda-Antwort enthalten. Das Erfolgsfeld wird auf false gesetzt, wenn ein Ganzzahlüberlauf im Multiplikationsergebnis vorliegt, und die Meldung `error_msg` wird auf `Integer multiplication overflow` gesetzt. Die `exfunc_multiplication`-Funktion nimmt drei Ganzzahlen als Eingabeargumente und gibt die Summe als Ganzzahl aus.
Der Name der Lambda-Funktion, die aufgerufen wird, lautet `lambda_multiplication`. Die für diese Lambda-Funktion verwendete Sprache ist Python 3.8. Stellen Sie sicher, dass Sie die IAM-Rolle angeben.
```
CREATE EXTERNAL FUNCTION exfunc_multiplication(int, int, int)
RETURNS INT
VOLATILE
LAMBDA 'lambda_multiplication'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
```
Die Lambda-Funktion verarbeitet die Nutzlast der Anfrage und iteriert über jede Zeile. Die Werte in einer einzelnen Zeile werden multipliziert, um das Ergebnis für diese Zeile zu berechnen, das dann in der Antwortliste gespeichert wird. In diesem Beispiel wird ein boolescher Erfolgswert verwendet, der standardmäßig auf true gesetzt ist. Wenn das Multiplikationsergebnis für eine Zeile einen Ganzzahlüberlauf aufweist, wird der Erfolgswert auf false gesetzt. Dann bricht die Iterationsschleife ab.
Wenn der Erfolgswert beim Erstellen der Antwort-Nutzdaten falsch ist, fügt die folgende Lambda-Funktion das Feld `error_msg` in die Nutzdaten ein. Es setzt auch die Fehlermeldung auf `Integer multiplication overflow`. Wenn der Erfolgswert true ist, werden die Ergebnisdaten in das Ergebnisfeld eingefügt. Die Anzahl der Zeilen im Ergebnis-Array, sofern vorhanden, entspricht der Anzahl der in der Nutzlast der Anfrage empfangenen Zeilen.
Das Feld „arguments“ in der Anforderung, die an die Lambda Funktion gesendet wird, enthält die Datennutzlast. Bei einer Batch-Anforderung können mehrere Zeilen in den Nutzdaten vorhanden sein. Die folgende Lambda-Funktion iteriert über alle Zeilen in der Nutzlast der Anfragedaten und iteriert einzeln über alle Werte innerhalb einer einzelnen Zeile.
```
import json
def lambda_handler(event, context):
t1 = event['arguments']
# 'len(t1)' represents the number of rows in the request payload.
# The number of results in the response payload should be the same as the number of rows received.
resp = [None]*len(t1)
# By default success is set to 'True'.
success = True
# Iterating over all rows in the request payload.
for i, x in enumerate(t1):
mul = 1
# Iterating over all the values in a single row.
for j, y in enumerate(x):
mul = mul*y
# Check integer overflow.
if (mul >= 9223372036854775807 or mul <= -9223372036854775808):
success = False
break
else:
resp[i] = mul
ret = dict()
ret['success'] = success
if not success:
ret['error_msg'] = "Integer multiplication overflow"
else:
ret['results'] = resp
ret_json = json.dumps(ret)
return ret_json
```
Im folgenden Beispiel wird die externe Funktion mit Literalwerten aufgerufen.
```
SELECT exfunc_multiplication(8, 9, 2);
exfunc_multiplication
---------------------------
144
(1 row)
```
Im folgenden Beispiel wird eine Tabelle mit dem Namen t\$1multi mit drei Spalten, c1, c2 und c3, vom Datentyp Ganzzahl erstellt. Dann wird die externe Funktion aufgerufen, indem die Spaltennamen dieser Tabelle übergeben werden. Die Daten werden so eingefügt, dass sie einen Ganzzahlüberlauf verursachen, um zu zeigen, wie der Fehler verteilt ist.
```
CREATE TABLE t_multi (c1 int, c2 int, c3 int);
INSERT INTO t_multi VALUES (2147483647, 2147483647, 4);
SELECT exfunc_multiplication(c1, c2, c3) FROM t_multi;
DETAIL:
-----------------------------------------------
error: Integer multiplication overflow
code: 32004context:
context:
query: 38
location: exfunc_data.cpp:276
process: query2_16_38 [pid=30494]
-----------------------------------------------
```
# ERSTELLEN EINES EXTERNEN MODELLS
**Topics**
+ [Voraussetzungen für CREATE EXTERNAL MODEL](#r_create_external_model_prereqs)
+ [Erforderliche Berechtigungen](#r_simple_create_model-privileges)
+ [Kontrolle der Kosten](#r_create_model_cost)
+ [Syntax für CREATE EXTERNAL MODEL](#r_create_external_model_syntax)
+ [Parameter und Einstellungen für CREATE EXTERNAL MODEL](#r_create_external_model_parameters_settings)
+ [Inferenzfunktionsparameter für CREATE EXTERNAL MODEL](#r_create_external_model_if_parameters)
## Voraussetzungen für CREATE EXTERNAL MODEL
Bevor Sie die Anweisung CREATE EXTERNAL MODEL verwenden, müssen Sie die Voraussetzungen in [Cluster-Einrichtung für die Verwendung von Amazon Redshift ML](getting-started-machine-learning.md#cluster-setup) erfüllen. Im Folgenden finden Sie eine Übersicht über die Voraussetzungen.
+ Erstellen Sie einen Amazon Redshift Redshift-Cluster mit der AWS Management Console oder der AWS Befehlszeilenschnittstelle (AWS CLI).
+ Fügen Sie beim Erstellen des Clusters die AWS Identity and Access Management (IAM) -Richtlinie an.
+ Weisen Sie der IAM-Rolle die richtige Vertrauensrichtlinie hinzu, damit Amazon Redshift und Amazon Bedrock mit anderen Services interagieren können.
+ Aktivieren Sie den Zugriff auf das spezifische LLMs , das Sie verwenden möchten, von der Amazon Bedrock-Konsole aus.
+ (Optional) Wenn Sie auf Drosselungsausnahmen von Amazon Bedrock stoßen, z. B. `Too many requests, please wait before trying again`, auch bei kleinen Datenmengen, überprüfen Sie die Kontingente unter **Service Quotas** in Ihrem Amazon-Bedrock-Konto. Vergewissern Sie sich, dass das angewendete Kontingent auf Kontoebene mindestens dem AWS Standardkontingentwert für die **InvokeModel**Anfragen für das von Ihnen verwendete Modell entspricht.
Einzelheiten zur IAM-Rolle, zur Vertrauensrichtlinie und zu anderen Voraussetzungen finden Sie unter [Cluster-Einrichtung für die Verwendung von Amazon Redshift ML](getting-started-machine-learning.md#cluster-setup).
## Erforderliche Berechtigungen
Im Folgenden finden Sie die erforderlichen Berechtigungen für CREATE EXTERNAL MODEL:
+ Superuser
+ Benutzer mit der Berechtigung CREATE MODEL
+ Rollen mit der Berechtigung GRANT CREATE MODEL
## Kontrolle der Kosten
Amazon Redshift ML verwendet vorhandene Cluster-Ressourcen, um Vorhersagemodelle zu erstellen, so dass Sie keine zusätzlichen Kosten bezahlen müssen. Die AWS Gebühren für die Nutzung von Amazon Bedrock richten sich jedoch nach dem von Ihnen ausgewählten Modell. Weitere Informationen finden Sie unter [Kosten für die Verwendung von Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html).
## Syntax für CREATE EXTERNAL MODEL
Im Folgenden finden Sie die vollständige Syntax der Anweisung CREATE EXTERNAL MODEL.
```
CREATE EXTERNAL MODEL model_name
FUNCTION function_name
IAM_ROLE {default/'arn:aws:iam:::role/'}
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID model_id
[, PROMPT 'prompt prefix']
[, SUFFIX 'prompt suffix']
[, REQUEST_TYPE {RAW|UNIFIED}]
[, RESPONSE_TYPE {VARCHAR|SUPER}]
);
```
Der Befehl `CREATE EXTERNAL MODEL` erstellt eine Inferenzfunktion, die Sie zum Generieren von Inhalten verwenden.
Im Folgenden finden Sie die Syntax einer Inferenzfunktion, die `CREATE EXTERNAL MODEL` unter Verwendung eines `REQUEST_TYPE` von `RAW` erstellt:
```
SELECT inference_function_name(request_super)
[FROM table];
```
Im Folgenden finden Sie die Syntax einer Inferenzfunktion, die `CREATE EXTERNAL MODEL` unter Verwendung eines `REQUEST_TYPE` von `UNIFIED` erstellt:
```
SELECT inference_function_name(input_text, [, inference_config [, additional_model_request_fields]])
[FROM table];
```
Weitere Informationen zur Verwendung der Inferenzfunktion finden Sie unter [Verwenden eines externen Modells für die Integration von Amazon Redshift ML mit Amazon Bedrock](machine-learning-br.md#machine-learning-br-use).
## Parameter und Einstellungen für CREATE EXTERNAL MODEL
In diesem Abschnitt werden die Parameter und Einstellungen für den Befehl `CREATE EXTERNAL MODEL` beschrieben.
**Topics**
+ [Parameter für CREATE EXTERNAL MODEL](#r_create_external_model_parameters)
+ [Einstellungen für CREATE EXTERNAL MODEL](#r_create_external_model_settings)
### Parameter für CREATE EXTERNAL MODEL
model\$1name
Der Name für das externe Modell. Der Modellname in einem Schema muss eindeutig sein.
FUNCTION *function\$1name (data\$1type [,...] )*
Der Name für die Inferenzfunktion, die `CREATE EXTERNAL MODEL` erstellt. Sie verwenden die Inferenzfunktion, um Anfragen an Amazon Bedrock zu senden und ML-generierten Text abzurufen.
IAM\$1ROLE * \$1 default \$1 'arn:aws:iam:::role/' \$1*
Die IAM-Rolle, die Amazon Redshift für den Zugriff auf Amazon Bedrock verwendet. Weitere Information zur IAM-Rolle finden Sie unter [Erstellen oder Aktualisieren einer IAM-Rolle für die Integration von Amazon Redshift ML mit Amazon Bedrock](machine-learning-br.md#machine-learning-br-iam).
MODEL\$1TYPE BEDROCK
Gibt den Modelltyp an. Der einzige gültige Wert ist `BEDROCK`.
SETTINGS ( MODEL\$1ID model\$1id [,...] )
Definiert die Einstellungen für das externe Modell. Weitere Informationen finden Sie im folgenden Abschnitt.
### Einstellungen für CREATE EXTERNAL MODEL
MODEL\$1ID model\$1id
Der Bezeichner für das externe Modell, zum Beispiel `anthropic.claude-v2`. Informationen zum Amazon Bedrock-Modell finden Sie IDs unter [Amazon Bedrock-Modell](https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html). IDs
PROMPT 'prompt prefix'
Gibt eine statische Eingabeaufforderung an, die Amazon Redshift am Anfang jeder Inferenzanforderung hinzufügt. Wird nur mit einem `REQUEST_TYPE` von `UNIFIED` unterstützt.
SUFFIX 'prompt suffix'
Gibt eine statische Eingabeaufforderung an, die Amazon Redshift am Ende jeder Inferenzanforderung hinzufügt. Wird nur mit einem `REQUEST_TYPE` von `UNIFIED` unterstützt.
REQUEST\$1TYPE \$1 RAW \$1 UNIFIED \$1
Gibt das Format der an Amazon Bedrock gesendeten Anfrage an. Gültige Werte sind z. B. die Folgenden:
+ **RAW**: Die Inferenzfunktion erfasst die Eingabe als einzelnen Super-Wert und gibt stets einen Super-Wert zurück. Das Format des Super-Werts ist für das ausgewählte Amazon-Bedrock-Modell spezifisch. Ein Super-Modell ist ein Vorhersagemodell, das mehrere Algorithmen kombiniert, um eine einzige, verbesserte Vorhersage zu erstellen.
+ **UNIFIED**: Die Inferenzfunktion verwendet die einheitliche API. Alle Modelle verfügen über eine einheitliche und konsistente Schnittstelle mit Amazon Bedrock. Dies funktioniert für alle Modelle, die Nachrichten unterstützen. Dieser Wert ist der Standard.
Weitere Informationen finden Sie in der [Converse-API-Dokumentation](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) in der *Dokumentation zur Amazon-Bedrock-API*.
RESPONSE\$1TYPE \$1 VARCHAR \$1 SUPER \$1
Gibt das Format der Antwort an. Wenn der `REQUEST_TYPE` `RAW` ist, ist der `RESPONSE_TYPE` erforderlich und der einzige gültige Wert ist `SUPER`. Für alle anderen `REQUEST TYPE`-Werte ist `VARCHAR` der Standardwert und `RESPONSE_TYPE` ist optional. Gültige Werte sind z. B. die Folgenden:
+ **VARCHAR**: Amazon Redshift gibt nur die vom Modell generierte Textantwort zurück.
+ **SUPER**: Amazon Redshift gibt das gesamte vom Modell generierte Antwort-JSON als Super-Wert zurück. Dies umfasst die Textantwort sowie Informationen wie den Grund für den Stopp und die Nutzung des Tokens für Modelleingabe und -ausgabe. Ein Super-Modell ist ein Vorhersagemodell, das mehrere Algorithmen kombiniert, um eine einzige, verbesserte Vorhersage zu erstellen.
## Inferenzfunktionsparameter für CREATE EXTERNAL MODEL
In diesem Abschnitt werden gültige Parameter für die Inferenzfunktion beschrieben, die der Befehl `CREATE EXTERNAL MODEL` erstellt.
### CREATE EXTERNAL MODEL-Inferenzfunktionsparameter für `REQUEST_TYPE` von `RAW`
Eine mit einem `REQUEST_TYPE` von `RAW` erstellte Inferenzfunktion hat ein einzelnes Super-Eingabeargument und gibt stets einen Super-Datentyp zurück. Die Syntax des Super-Eingabearguments folgt der Syntax der Anfrage des spezifischen Modells, das aus Amazon Bedrock ausgewählt wurde.
### Inferenzfunktionsparameter für CREATE EXTERNAL MODEL für `REQUEST_TYPE` von `UNIFIED`
input\$1text
Der Text, den Amazon Redshift an Amazon Bedrock sendet.
inference\$1config
Ein Super-Wert, der optionale Parameter enthält, die Amazon Redshift an Amazon Bedrock sendet. Dies kann u. a. Folgendes umfassen:
+ maxTokens
+ stopSequences
+ temperature
+ topP
Diese Parameter sind alle optional und unterscheiden alle zwischen Groß- und Kleinschreibung. Informationen zu diesen Parametern finden Sie [ InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html)in der *Amazon Bedrock API-Referenz.*
# CREATE EXTERNAL SCHEMA
Erstellt ein neues externes Schema in der aktuellen Datenbank. Sie können dieses externe Schema verwenden, um sich mit Amazon-RDS-for-PostgreSQL- oder mit Amazon-Aurora-for-PostgreSQL-kompatible-Edition-Datenbanken zu verbinden. Sie können auch ein externes Schema erstellen, das auf eine Datenbank in einem externen Datenkatalog wie AWS Glue Athena oder auf eine Datenbank in einem Apache Hive-Metastore wie Amazon EMR verweist.
Der Besitzer dieses Schemas gibt den Befehl CREATE EXTERNAL SCHEMA aus. Mit dem Befehl [ALTER SCHEMA](r_ALTER_SCHEMA.md) können Sie den Besitzer eines externen Schemas ändern. Mit dem Befehl [GRANT](r_GRANT.md) gewähren Sie anderen Benutzern oder Benutzergruppen Zugriff auf das Schema.
Sie können die Befehle GRANT oder REVOKE nicht für Berechtigungen in einer externen Tabelle verwenden. Gewähren oder widerrufen Sie stattdessen die Berechtigungen für das externe Schema.
**Anmerkung**
Wenn Sie derzeit externe Redshift-Spectrum-Tabellen im Amazon-Athena-Datenkatalog haben, können Sie Ihren Athena-Datenkatalog zu einem -Datenkatalog migrieren AWS Glue Data Catalog. Um den AWS Glue Datenkatalog mit Redshift Spectrum zu verwenden, müssen Sie möglicherweise Ihre AWS Identity and Access Management (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*.
Um Details zu externen Schemata anzuzeigen, führen Sie eine Abfrage für die Systemansicht [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md) aus.
## Syntax
Die folgende Syntax beschreibt den Befehl CREATE EXTERNAL SCHEMA, der verwendet wird, um Daten mithilfe eines externen Datenkatalogs zu referenzieren. Weitere Informationen finden Sie unter [Amazon Redshift Spectrum](c-using-spectrum.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM [ [ DATA CATALOG ] | HIVE METASTORE | POSTGRES | MYSQL | KINESIS | MSK | REDSHIFT | KAFKA ]
[ DATABASE 'database_name' ]
[ SCHEMA 'schema_name' ]
[ REGION 'aws-region' ]
[ IAM_ROLE [ default | 'SESSION' | 'arn:aws:iam:::role/' ] ]
[ AUTHENTICATION [ none | iam | mtls] ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'ssm-secret- arn' ]
[ URI ['hive_metastore_uri' [ PORT port_number ] | 'hostname' [ PORT port_number ] | 'Kafka bootstrap URL'] ]
[ CLUSTER_ARN 'arn:aws:kafka:::cluster/msk/' ]
[ CATALOG_ROLE [ 'SESSION' | 'catalog-role-arn-string' ] ]
[ CREATE EXTERNAL DATABASE IF NOT EXISTS ]
[ CATALOG_ID 'Amazon Web Services account ID containing Glue or Lake Formation database' ]
```
Die folgende Syntax beschreibt den Befehl CREATE EXTERNAL SCHEMA, der verwendet wird, um Daten mithilfe einer Verbundabfrage an RDS POSTGRES oder Aurora PostgreSQL zu referenzieren. Sie können auch ein externes Schema erstellen, das auf Streaming-Quellen wie Kinesis Data Streams verweist. Weitere Informationen finden Sie unter [Abfragen von Daten mit Verbundabfragen in Amazon Redshift](federated-overview.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM POSTGRES
DATABASE 'federated_database_name' [SCHEMA 'schema_name']
URI 'hostname' [ PORT port_number ]
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
SECRET_ARN 'ssm-secret-arn'
```
Die folgende Syntax beschreibt den Befehl CREATE EXTERNAL SCHEMA, der verwendet wird, um Daten mithilfe einer Verbundabfrage an RDS MySQL oder Aurora MySQL zu referenzieren. Weitere Informationen finden Sie unter [Abfragen von Daten mit Verbundabfragen in Amazon Redshift](federated-overview.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM MYSQL
DATABASE 'federated_database_name'
URI 'hostname' [ PORT port_number ]
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
SECRET_ARN 'ssm-secret-arn'
```
Die folgende Syntax beschreibt den Befehl CREATE EXTERNAL SCHEMA, der verwendet wird, um Daten in einem Kinesis-Stream zu referenzieren. Weitere Informationen finden Sie unter [Streaming-Aufnahme in eine materialisierte Ansicht](materialized-view-streaming-ingestion.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name
FROM KINESIS
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
```
Die folgende Syntax beschreibt den Befehl CREATE EXTERNAL SCHEMA, der verwendet wird, um auf den Cluster von Amazon Managed Streaming für Apache Kafka oder Confluent Cloud und die zugehörigen Themen zu verweisen, aus denen Daten erfasst werden sollen. Um eine Verbindung herzustellen, geben Sie den Broker-URI an. Weitere Informationen finden Sie unter [Streaming-Aufnahme in eine materialisierte Ansicht](materialized-view-streaming-ingestion.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name
FROM KAFKA
[ IAM_ROLE [ default | 'arn:aws:iam:::role/' ] ]
URI 'Kafka bootstrap URI'
AUTHENTICATION [ none | iam | mtls ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'ssm-secret- arn' ];
```
Die folgende Syntax beschreibt den Befehl CREATE EXTERNAL SCHEMA, der verwendet wird, um Daten mithilfe einer datenbankübergreifenden Abfrage zu referenzieren.
```
CREATE EXTERNAL SCHEMA local_schema_name
FROM REDSHIFT
DATABASE 'redshift_database_name' SCHEMA 'redshift_schema_name'
```
## Parameters
IF NOT EXISTS
Eine Klausel, die angibt, dass der Befehl keine Änderungen ausführen und die Meldung zurückgeben soll, dass das Schema vorhanden ist, statt mit einem Fehler beendet zu werden, wenn das angegebene Schema bereits vorhanden ist. Diese Klausel ist beim Scripting nützlich, damit das Skript nicht fehlschlägt, wenn CREATE EXTERNAL SCHEMA versucht, ein Schema zu erstellen, das bereits vorhanden ist.
local\$1schema\$1name
Der Name des neuen externen Schemas. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
FROM [ DATA CATALOG ] \$1 HIVE METASTORE \$1 POSTGRES \$1 MYSQL \$1 KINESIS \$1 MSK \$1 REDSHIFT
Ein Schlüsselwort, das angibt, wo sich die externe Datenbank befindet.
DATA CATALOG gibt an, dass die externe Datenbank im Athena-Datenkatalog oder dem definiert ist AWS Glue Data Catalog.
Wenn die externe Datenbank in einem externen Datenkatalog in einer anderen AWS -Region definiert ist, ist der Parameter REGION erforderlich. DATA CATALOG ist der Standardwert.
HIVE METASTORE gibt an, dass die externe Datenbank in einem Apache Hive-Metastore definiert ist. Wenn HIVE METASTORE angegeben ist, ist der URI erforderlich.
POSTGRES gibt an, dass die externe Datenbank in RDS PostgreSQL oder Aurora PostgreSQL definiert ist.
MYSQL zeigt an, dass die externe Datenbank in RDS MySQL oder Aurora MySQL definiert ist.
KINESIS gibt an, dass die Datenquelle ein Stream aus dem Kinesis Data Streams ist.
MSK gibt an, dass die Datenquelle ein von Amazon MSK bereitgestellter oder Serverless-Cluster ist.
KAFKA gibt an, dass die Datenquelle ein Kafka-Cluster ist. Sie können dieses Schlüsselwort sowohl für Amazon MSK als auch für Confluent Cloud verwenden.
VON REDSHIFT
Ein Schlüsselwort, das angibt, dass sich die Datenbank in Amazon Redshift befindet.
DATABASE '*redshift\$1database\$1name*' SCHEMA '*redshift\$1schema\$1name*'
Der Name der Amazon-Redshift-Datenbank.
Der *redshift\$1schema\$1name* gibt das Schema in Amazon Redshift an. Standardmäßig lautet der *redshift\$1schema\$1name* auf `public`.
DATABASE '*federated\$1database\$1name*'
Ein Schlüsselwort, das den Namen der externen Datenbank in einer unterstützten PostgreSQL- oder MySQL-Datenbank-Engine angibt.
[SCHEMA '*schema\$1name*']
Der *schema\$1name* gibt das Schema in einer unterstützten PostgreSQL-Datenbank-Engine an. Der Standard-*schema\$1name* ist `public`.
Sie können kein SCHEMA angeben, wenn Sie eine Verbundabfrage an eine unterstützte MySQL-Datenbank-Engine einrichten.
REGION „*aws-region*“
Wenn die externe Datenbank in einem Athena-Datenkatalog oder in der AWS Region definiert ist AWS Glue Data Catalog, in der sich die Datenbank befindet. Dieser Parameter ist erforderlich, wenn die Datenbank in einem externen Datenkatalog definiert ist.
URI [ 'hive\$1metastore\$1uri' [ PORT port\$1number ] \$1 'hostname' [ PORT port\$1number ] \$1 'Kafka bootstrap URI' ]
Der Hostname-URI und die Portnummer einer unterstützten PostgreSQL- oder MySQL-Datenbank-Engine. Der *Hostname* ist der Haarknoten des Replikatsatzes. Der Endpunkt muss vom Amazon-Redshift-Cluster aus erreichbar (routingfähig) sein. Der Standardwert für port\$1number von PostgreSQL lautet 5432. Die Standarwert für port\$1number von MySQL lautet 3306.
Die unterstützte PostgreSQL- oder MySQL-Datenbank-Engine muss sich in der gleichen VPC befinden wie Ihr Amazon-Redshift-Cluster und eine Sicherheitsgruppe besitzen, die Amazon Redshift und RDS url-rsPostgreSQL oder Aurora PostgreSQL verknüpft. Darüber hinaus können Sie ein erweitertes VPC-Routing verwenden, um einen VPC-übergreifenden Anwendungsfall zu konfigurieren. Weitere Informationen finden Sie unter [Redshift-verwaltete VPC-Endpunkte](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-cross-vpc.html).
**Angeben eines Hive-Metastore-URI**
Wenn sich die Datenbank in einem Hive-Metastore befindet, geben Sie den URI und optional die Portnummer des Metastore an. Die Standard-Portnummer ist 9083.
Ein URI enthält keine Protokollspezifikation („http://“). Beispiel für einen gültigen URI: `uri '172.10.10.10'`.
**Angeben eines Broker-URI zur Streaming-Aufnahme**
Die Einbindung des Bootstrap-Broker-URI ermöglicht die Herstellung einer Verbindung zu einem Amazon-MSK- oder Confluent-Cloud-Cluster und den Erhalt gestreamter Daten. Weitere Informationen und ein Beispiel finden Sie unter [Erste Schritte mit der Streaming-Erfassung aus Amazon Managed Streaming für Apache Kafka](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-streaming-ingestion-getting-started-MSK.html).
IAM\$1ROLE [Standard \$1 'SESSION' \$1 'arn:aws:iam: :role/ '] ** **
Verwenden Sie das Standardstichwort, damit Amazon Redshift die IAM-Rolle verwendet, die als Standard festgelegt und mit dem Cluster verknüpft ist, wenn der CREATE EXTERNAL SCHEMA-Befehl ausgeführt wird.
Verwenden Sie `'SESSION'`, wenn Sie über eine Verbundidentität eine Verbindung zu Ihrem Amazon-Redshift-Cluster herstellen und über das mit diesem Befehl erstellte externe Schema auf die Tabellen zugreifen. Weitere Informationen finden Sie unter [Verwenden einer Verbundidentitä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). Darin wird erläutert, wie Sie eine Verbundidentität konfigurieren. Beachten Sie, dass diese Konfiguration (`'SESSION'` anstelle des ARN zu verwenden) nur verwendet werden kann, wenn das Schema mit `DATA CATALOG` erstellt wurde.
Verwenden Sie den Amazon-Ressourcennamen (ARN) für eine IAM-Rolle, die von Ihrem Cluster für Authentifizierung und Autorisierung verwendet wird. Die IAM-Rolle muss mindestens die Berechtigung besitzen, eine LIST-Operation für den Amazon-S3-Bucket auszuführen, auf den zugegriffen werden soll, und eine GET-Operation für die Amazon-S3-Objekte, die der Bucket enthält.
Nachfolgend ist die Syntax für die IAM\$1ROLE-Parameterzeichenfolge für einen einzelnen ARN aufgeführt.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
Sie können Rollen miteinander verketten. Auf diese Weise kann der Cluster eine andere IAM-Rolle annehmen, die möglicherweise zu einem anderen Konto gehört. Es können bis zu 10 Rollen miteinander verkettet werden. Ein Beispiel für die Verkettung von Rollen finden Sie unter [Verketten von IAM-Rollen in Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
Fügen Sie dieser IAM-Rolle eine IAM-Berechtigungsrichtlinie ähnlich der folgenden an:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessSecret",
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds"
],
"Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword",
"secretsmanager:ListSecrets"
],
"Resource": "*"
}
]
}
```
Informationen zu den Schritten für das Erstellen einer IAM-Rolle zur Verwendung mit der Verbundabfrage finden Sie unter [Erstellen eines Secrets und einer IAM-Rolle für die Verwendung von Verbundabfragen](federated-create-secret-iam-role.md).
Fügen Sie keine Leerzeichen in die Liste der verketteten Rollen ein.
Nachfolgend finden Sie die Syntax für die Verkettung von drei Rollen.
```
IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
*ssm-secret-arn*SECRET\$1ARN ''
Der Amazon-Ressourcenname (ARN) eines unterstützten PostgreSQL- oder MySQL-Datenbank-Engine-Geheimnisses, das mit erstellt wurde. AWS Secrets Manager Informationen zum Erstellen und Abrufen eines ARN für ein Secret finden Sie unter [Secrets mit AWS Secrets Manager verwalten](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) im *AWS Secrets Manager -Benutzerhandbuch* und [Abrufen des Amazon-Ressourcennamens (ARN) des Secrets in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration-retrieving-secret.html).
CATALOG\$1ROLE ['SITZUNG' \$1] *catalog-role-arn-string*
Verwenden Sie `'SESSION'`, um mithilfe einer Verbundidentität eine Verbindung mit Ihrem Amazon-Redshift-Cluster herzustellen, um den Datenkatalog zu authentifizieren und zu autorisieren. Weitere Informationen zur Durchführung der Schritte für eine Verbundidentität finden Sie unter [Verwenden einer Verbundidentitä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). Beachten Sie, dass die `'SESSION'`-Rolle nur verwendet werden kann, wenn das Schema in DATA CATALOG erstellt wurde.
Verwenden Sie den Amazon-Ressourcenname (ARN) für eine IAM-Rolle, die von Ihrem Cluster für Authentifizierung und Autorisierung für den Datenkatalog verwendet wird.
Wenn CATALOG\$1ROLE nicht angegeben wird, verwendet Amazon Redshift die angegebene IAM\$1ROLE. Die Katalogrolle muss über die Berechtigung verfügen, auf den Datenkatalog in AWS Glue oder Athena zuzugreifen. Weitere Informationen finden Sie unter [IAM-Richtlinien für Amazon Redshift Spectrum](c-spectrum-iam-policies.md).
Nachfolgend ist die Syntax für die CATALOG\$1ROLE-Parameterzeichenfolge für einen einzelnen ARN aufgeführt.
```
CATALOG_ROLE 'arn:aws:iam:::role/'
```
Sie können Rollen miteinander verketten. Auf diese Weise kann der Cluster eine andere IAM-Rolle annehmen, die möglicherweise zu einem anderen Konto gehört. Es können bis zu 10 Rollen miteinander verkettet werden. Weitere Informationen finden Sie unter [Verketten von IAM-Rollen in Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
Die Liste der verketteten Rollen darf keine Leerstellen enthalten.
Nachfolgend finden Sie die Syntax für die Verkettung von drei Rollen.
```
CATALOG_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
CREATE EXTERNAL DATABASE IF NOT EXISTS
Eine Klausel, die eine externe Datenbank mit dem Namen erstellt, der im DATABASE-Argument angegeben ist, wenn die angegebene externe Datenbank nicht vorhanden ist. Wenn die angegebene externe Datenbank vorhanden ist, führt der Befehl keine Änderungen aus. In diesem Fall gibt der Befehl die Meldung zurück, dass die externe Datenbank vorhanden ist, statt mit einem Fehler beendet zu werden.
CREATE EXTERNAL DATABASE IF NOT EXISTS kann nicht mit HIVE METASTORE verwendet werden.
Um CREATE EXTERNAL DATABASE IF NOT EXISTS mit einem für AWS Lake Formation aktivierten Datenkatalog zu verwenden, benötigen Sie die Berechtigung `CREATE_DATABASE` für den Datenkatalog.
CATALOG\$1ID ‚*Amazon-Web-Services-Konto-ID mit Glue- oder Lake-Formation-Datenbank*'
Die Konto-ID, in der die Datenkatalogdatenbank gespeichert ist.
`CATALOG_ID` kann nur angegeben werden, wenn Sie planen, für die Authentifizierung und Autorisierung beim Datenkatalog mithilfe einer Verbundidentität eine Verbindung mit Ihrem Amazon-Redshift-Cluster oder Amazon Redshift Serverless herzustellen, indem Sie eine der folgenden Einstellungen festlegen:
+ `CATALOG_ROLE` auf `'SESSION'`
+ `IAM_ROLE` auf `'SESSION'` und `'CATALOG_ROLE'` auf die Standardeinstellung festgelegt
Weitere Informationen zur Durchführung der Schritte für Verbundidentität finden Sie unter [Verwenden einer Verbundidentitä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)
AUTHENTICATION
Der für die Streaming-Erfassung definierte Authentifizierungstyp. Die Streaming-Erfassung mit Authentifizierungstypen kann mit Amazon Managed Streaming for Apache Kafka verwendet werden. Es stehen folgende `AUTHENTICATION`-Typen zur Verfügung:
+ **none** – Gibt an, dass keine Authentifizierung erforderlich ist. Dies entspricht dem nicht authentifizierten Zugriff in MSK oder Klartext mit TLS in Apache Kafka.
+ **iam**: Gibt an, dass eine IAM-Authentifizierung erfolgt. Stellen Sie bei Auswahl dieser Option sicher, dass die IAM-Rolle über Berechtigungen für die IAM-Authentifizierung verfügt. Weitere Informationen über die Definition des externen Schemas finden Sie unter [Erste Schritte mit der Streaming-Aufnahme aus Apache-Kafka-Quellen](materialized-view-streaming-ingestion-getting-started-MSK.md).
+ **mtls** – Gibt an, dass Mutual Transport Layer Security die sichere Kommunikation durch Authentifizierung zwischen einem Client und einem Server ermöglicht. In diesem Fall ist der Client Redshift und der Server ist Amazon MSK. Weitere Informationen zum Konfigurieren der Streaming-Erfassung mit mTLS finden Sie unter [Authentifizierung mit mTLS für Redshift-Streaming-Aufnahme aus Apache Kafka-Quellen](materialized-view-streaming-ingestion-mtls.md).
AUTHENTICATION\$1ARN
Der ARN des AWS Certificate Manager Zertifikats, das von Amazon Redshift für die MTLS-Authentifizierung mit Amazon MSK verwendet wird. Der ARN ist in der ACM-Konsole verfügbar, wenn Sie das ausgegebene Zertifikat auswählen.
CLUSTER\$1ARN
Für die Streaming-Erfassung ist der CLUSTER\$1ARN die Cluster-ID für den Cluster in Amazon Managed Streaming für Apache Kafka, von dem Sie streamen. Wenn Sie CLUSTER\$1ARN verwenden, ist eine IAM-Rollenrichtlinie erforderlich, die die Berechtigung `kafka:GetBootstrapBrokers` umfasst. Diese Option wird für die Abwärtskompatibilität bereitgestellt. Derzeit empfehlen wir die Verwendung der URI-Option bootstrap-broker, um eine Verbindung zu Clustern in Amazon Managed Streaming für Apache Kafka herzustellen. Weitere Informationen finden Sie unter [Streaming-Erfassung](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-streaming-ingestion.html).
## Nutzungshinweise
Informationen über Beschränkungen bei der Verwendung des Athena-Datenkatalogs finden Sie unter [Athena-Limits](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#amazon-athena-limits) in der Allgemeine AWS-Referenz.
Informationen zu den Beschränkungen bei der AWS Glue Data Catalog Verwendung von finden Sie unter [AWS Glue Grenzwerte](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_glue) in der. Allgemeine AWS-Referenz
Diese Begrenzungen gelten nicht für einen Hive-Metastore.
Pro Datenbank sind höchstens 9 900 Schemata zulässig. Weitere Informationen finden Sie unter [Kontingente und Einschränkungen](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) im *Amazon-Redshift-Verwaltungshandbuch*.
Verwenden Sie den [DROP SCHEMA](r_DROP_SCHEMA.md)-Befehl, um die Registrierung des Schemas aufzuheben.
Um sich die Details zu externen Schemata anzeigen zu lassen, fragen Sie die folgenden Systemansichten ab:
+ [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md)
+ [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md)
+ [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md)
## Beispiele
Im folgenden Beispiel wird ein externes Schema unter Verwendung einer Datenbank in einem Athena-Datenkatalog namens `sampledb` in der Region USA West (Oregon) erstellt. Verwenden Sie dieses Beispiel mit einem Athena- oder AWS Glue -Datenkatalog.
```
create external schema spectrum_schema
from data catalog
database 'sampledb'
region 'us-west-2'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
```
Im folgenden Beispiel werden ein externes Schema und eine neue externe Datenbank namens erstellt `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;
```
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';
```
Im folgenden Beispiel miteinander verketteter Rollen wird die Rolle `myS3Role` für den Zugriff auf Amazon S3 und `myAthenaRole` für den Datenkatalogzugriff verwendet. Weitere Informationen finden Sie unter [Verketten von IAM-Rollen in Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
```
create external schema spectrum_schema
from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/myRedshiftRole,arn:aws:iam::123456789012:role/myS3Role'
catalog_role 'arn:aws:iam::123456789012:role/myAthenaRole'
create external database if not exists;
```
Im folgenden Beispiel wird ein externes Schema erstellt, das auf eine Aurora-PostgreSQL-Datenbank verweist.
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] myRedshiftSchema
FROM POSTGRES
DATABASE 'my_aurora_db' SCHEMA 'my_aurora_schema'
URI 'endpoint to aurora hostname' PORT 5432
IAM_ROLE 'arn:aws:iam::123456789012:role/MyAuroraRole'
SECRET_ARN 'arn:aws:secretsmanager:us-east-2:123456789012:secret:development/MyTestDatabase-AbCdEf'
```
Im folgenden Beispiel wird ein externes Schema erstellt, das auf die im Konsumenten-Cluster importierte sales\$1db verweist.
```
CREATE EXTERNAL SCHEMA sales_schema FROM REDSHIFT DATABASE 'sales_db' SCHEMA 'public';
```
Im folgenden Beispiel wird ein externes Schema erstellt, das auf eine Aurora-MySQL-Datenbank verweist.
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] myRedshiftSchema
FROM MYSQL
DATABASE 'my_aurora_db'
URI 'endpoint to aurora hostname'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyAuroraRole'
SECRET_ARN 'arn:aws:secretsmanager:us-east-2:123456789012:secret:development/MyTestDatabase-AbCdEf'
```
# CREATE EXTERNAL TABLE
Erstellt eine neue externe Tabelle im angegebenen Schema. Alle externen Tabellen müssen in einem externen Schema erstellt werden. Externe Schemata und externe Tabellen unterstützen keine Suchpfade. Weitere Informationen finden Sie unter [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
Zusätzlich zu externen Tabellen, die mit dem Befehl CREATE EXTERNAL TABLE erstellt wurden, kann Amazon Redshift auf externe Tabellen verweisen, die in einem AWS Lake Formation OR-Katalog AWS Glue oder einem Apache Hive-Metastore definiert sind. Verwenden Sie den Befehl [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md), um eine externe Datenbank zu registrieren, die im externen Katalog definiert ist, und um die externen Tabellen für die Verwendung in Amazon Redshift zur Verfügung zu stellen. Wenn die externe Tabelle in einem AWS Lake Formation Or-Katalog AWS Glue - oder Hive-Metastore vorhanden ist, müssen Sie die Tabelle nicht mit CREATE EXTERNAL TABLE erstellen. Um externe Tabellen anzuzeigen, führen Sie eine Abfrage für die Systemansicht [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) aus.
Durch das Ausführen des Befehls CREATE EXTERNAL TABLE AS können Sie eine externe Tabelle basierend auf der Spaltendefinition aus einer Abfrage erstellen und die Ergebnisse dieser Abfrage in Amazon S3 schreiben. Die Ergebnisse liegen im Apache Parquet- oder im Textformat mit Trennzeichen vor. Wenn die externe Tabelle über mindestens einen Partitionsschlüssel verfügt, partitioniert Amazon Redshift neue Dateien entsprechend diesen Partitionsschlüsseln und registriert neue Partitionen automatisch im externen Katalog. Weitere Hinweise zu CREATE EXTERNAL TABLE AS finden Sie unter [Nutzungshinweise](r_CREATE_EXTERNAL_TABLE_usage.md).
Sie können eine externe Tabelle mit der gleichen SELECT-Syntax abfragen, die Sie auch für andere Amazon-Redshift-Tabellen verwenden. Sie können auch die INSERT-Syntax verwenden, um neue Dateien in den Speicherort der externen Tabelle auf Amazon S3 zu schreiben. Weitere Informationen finden Sie unter [INSERT (externe Tabelle)](r_INSERT_external_table.md).
Zum Erstellen einer Ansicht mit einer externen Tabelle fügen Sie die Klausel WITH NO SCHEMA BINDING in die [CREATE VIEW](r_CREATE_VIEW.md)-Aussage ein.
CREATE EXTERNAL TABLE kann nicht innerhalb einer Transaktion (BEGIN … END) ausgeführt werden. Weitere Informationen Transaktionen finden Sie unter [Isolierungsstufen in Amazon Redshift](c_serial_isolation.md).
## Erforderliche Berechtigungen
Zum Erstellen externer Tabellen müssen Sie der Eigentümer des externen Schemas oder ein Superuser sein. Mit dem Befehl ALTER SCHEMA können Sie den Besitzer eines externen Schemas ändern. Der Zugriff auf externe Tabellen wird durch den Zugriff auf die externen Schemata gesteuert. Sie können für eine externe Tabelle keine Berechtigungen gewähren ([GRANT](r_GRANT.md)) oder widerrufen ([REVOKE](r_REVOKE.md)). Sie gewähren oder widerrufen stattdessen das Recht USAGE für das externe Schema.
Die [Nutzungshinweise](r_CREATE_EXTERNAL_TABLE_usage.md) enthalten zusätzliche Informationen zu spezifischen Berechtigungen für externe Tabellen.
## Syntax
```
CREATE EXTERNAL TABLE
external_schema.table_name
(column_name data_type [, …] )
[ PARTITIONED BY (col_name data_type [, … ] )]
[ { ROW FORMAT DELIMITED row_format |
ROW FORMAT SERDE 'serde_name'
[ WITH SERDEPROPERTIES ( 'property_name' = 'property_value' [, ...] ) ] } ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
```
Im Folgenden finden Sie die Syntax für CREATE EXTERNAL TABLE AS.
```
CREATE EXTERNAL TABLE
external_schema.table_name
[ PARTITIONED BY (col_name [, … ] ) ]
[ ROW FORMAT DELIMITED row_format ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
AS
{ select_statement }
```
## Parameters
*external\$1schema.table\$1name*
Der Name der Tabelle, die erstellt werden soll, qualifiziert durch einen externen Schemanamen. Externe Tabellen müssen in einem externen Schema erstellt werden. Weitere Informationen finden Sie unter [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
Die maximale Länge des Tabellennamens beträgt 127 Bytes; längere Namen werden bei 127 Bytes abgeschnitten. Sie können UTF-8-Multibyte-Zeichen bis zu einer Länge von vier Bytes verwenden. Amazon Redshift erzwingt ein Limit von 9.900 Tabellen pro Cluster, einschließlich benutzerdefinierter temporärer Tabellen und temporärer Tabellen, die von Amazon Redshift während der Abfrageverarbeitung oder Systemwartung erstellt werden. Optional können Sie die Tabelle mit dem Datenbanknamen qualifizieren. Im folgenden Beispiel ist der Datenbankname `spectrum_db`, der Name des externen Schemas `spectrum_schema` und der Tabellenname `test`.
```
create external table spectrum_db.spectrum_schema.test (c1 int)
stored as parquet
location 's3://amzn-s3-demo-bucket/myfolder/';
```
Wenn die angegebene Datenbank oder das angegebene Schema nicht vorhanden sind, wird die Tabelle nicht erstellt, und die Anweisung gibt einen Fehler zurück. Sie können in den Systemdatenbanken `template0`, `template1`, `padb_harvest` oder `sys:internal` keine Tabellen oder Ansichten erstellen.
Der Tabellenname muss für das angegebene Schema eindeutig sein.
Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
( *column\$1name* *data\$1type* )
Der Name und der Datentyp jeder Spalte, die erstellt wird.
Die maximale Länge des Spaltennamens beträgt 127 Bytes; längere Namen werden bei 127 Bytes abgeschnitten. Sie können UTF-8-Multibyte-Zeichen bis zu einer Länge von vier Bytes verwenden. Sie können keine Spaltennamen `"$path"` oder `"$size"` festlegen. Weitere Informationen zu gültigen Namen finden Sie unter [Namen und Kennungen](r_names.md).
Standardmäßig erstellt Amazon Redshift externe Tabellen mit den Pseudospalten `$path` und `$size`. Sie können die Erstellung von Pseudospalten für eine Sitzung deaktivieren, indem Sie den `spectrum_enable_pseudo_columns`-Konfigurationsparameter auf `false` setzen. Weitere Informationen finden Sie unter [Pseudospalten](r_CREATE_EXTERNAL_TABLE_usage.md#r_CREATE_EXTERNAL_TABLE_usage-pseudocolumns).
Falls Pseudospalten aktiviert sind, können Sie höchstens 1.598 Spalten in einer einzelnen Tabelle definieren. Wenn Pseudospalten nicht aktiviert sind, können Sie höchstens 1.600 Spalten in einer einzelnen Tabelle definieren.
Wenn Sie eine „breite Tabelle“ erstellen, achten Sie darauf, dass Ihre Spaltenliste nicht die Zeilenbreitengrenzen überschreitet, um während der Verarbeitung von Lasten und Abfragen sofort Ergebnisse bereitzustellen. Weitere Informationen finden Sie unter [Nutzungshinweise](r_CREATE_TABLE_NEW.md#r_CREATE_TABLE_usage).
Für den Befehl CREATE EXTERNAL TABLE AS ist keine Spaltenliste erforderlich, da Spalten von der Abfrage abgeleitet werden.
*data\$1type*
Die folgenden [Datentypen](c_Supported_data_types.md) werden unterstützt:
+ KLEINE ZAHL () INT2
+ GANZZAHL (INT, INT4)
+ GROSSE GANZZAHL () INT8
+ DECIMAL (NUMERIC)
+ ECHT () FLOAT4
+ DOPPELTE PRÄZISION (FLOAT8)
+ BOOLEAN (BOOL)
+ CHAR (CHARACTER)
+ VARCHAR (CHARACTER VARYING)
+ VARBYTE (CHARACTER VARYING) – kann mit Parquet- und ORC-Datendateien und nur mit nicht partitionierten Spalten benutzt werden.
+ DATE – kann nur mit Text-, Parquet- oder ORC-Datendateien oder als Partitionsspalte verwendet werden.
+ TIMESTAMP (ZEITSTEMPEL)
Für DATE können Sie die im Folgenden beschriebenen Formate verwenden. Für Monatswerte, die in Ziffern dargestellt werden, werden die folgenden Formate unterstützt:
+ `mm-dd-yyyy`, beispielsweise `05-01-2017`. Dies ist die Standardeinstellung.
+ `yyyy-mm-dd`, wenn das Jahr mit mehr als zwei Ziffern dargestellt werden soll. Beispiel, `2017-05-01`.
Für Monatswerte, die mit einer Abkürzung aus drei Buchstaben dargestellt werden, werden die folgenden Formate unterstützt:
+ `mmm-dd-yyyy`, beispielsweise `may-01-2017`. Dies ist die Standardeinstellung.
+ `dd-mmm-yyyy`, wenn das Jahr mit mehr als zwei Ziffern dargestellt werden soll. Beispiel, `01-may-2017`.
+ `yyyy-mmm-dd`, wenn das Jahr mit mehr als zwei Ziffern dargestellt werden soll. Beispiel, `2017-may-01`.
Für Jahreswerte, die konstant unter 100 liegen, wird das Jahr wie folgt berechnet:
+ Wenn das Jahr weniger als 70 beträgt, wird das Jahr als das Jahr plus 2000 berechnet. Im Format `mm-dd-yyyy` wird das Datum 05-01-17 beispielsweise zu `05-01-2017` konvertiert.
+ Wenn das Jahr weniger als 100 beträgt, aber mehr als 69, wird das Jahr als das Jahr plus 1900 berechnet. Im Format `mm-dd-yyyy` wird das Datum 05-01-89 beispielsweise zu `05-01-1989` konvertiert.
+ Für Jahreswerte, die mit zwei Ziffern dargestellt werden, müssen führende Nullen hinzugefügt werden, um das Jahr mit vier Ziffern darzustellen.
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`.
Die Länge einer VARCHAR-Spalte wird in Bytes definiert, nicht in Zeichen. Eine VARCHAR(12)-Spalte kann z. B. 12 Einzelbyte-Zeichen oder 6 Zeichen mit einer Länge von je 2 Bytes enthalten. Wenn Sie eine externe Tabelle abfragen, werden die Ergebnisse gekürzt, damit sie der definierten Spaltengröße entsprechen, ohne dass ein Fehler zurückgegeben wird. Weitere Informationen finden Sie unter [Speicherung und Bereiche](r_Character_types.md#r_Character_types-storage-and-ranges).
Um eine optimale Leistung zu erzielen, empfehlen wir, die kleinste Spaltengröße anzugeben, die ihren Daten entspricht. Verwenden Sie die Funktion [OCTET\$1LENGTH](r_OCTET_LENGTH.md), um die maximale Größe in Bytes für Werte in einer Spalte zu suchen. Das folgende Beispiel gibt die maximale Größe von Werten in der Spalte „E-Mail“ zurück.
```
select max(octet_length(email)) from users;
max
---
62
```
PARTITIONED BY (*col\$1name* *data\$1type* [, … ] )
Eine Klausel, die eine partitionierte Tabelle mit einer oder mehreren Partitionsspalten festlegt. Für jede angegebene Kombination wird ein eigenes Datenverzeichnis verwendet. Dies kann die Abfrageleistung in einigen Fällen verbessern. In den Tabellendaten selbst sind keine partitionierten Spalten vorhanden. Wenn Sie einen Wert für *col\$1name* verwenden, der mit einer Tabellenspalte identisch ist, erhalten Sie einen Fehler.
Nachdem Sie eine partitionierte Tabelle erstellt haben, ändern Sie die Tabelle mit der Anweisung [ALTER TABLE](r_ALTER_TABLE.md) ... ADD PARTITION, um neue Partitionen im externen Katalog zu registrieren. Wenn Sie eine Partition hinzufügen, definieren Sie den Speicherort des Unterordners auf Amazon S3, der die Partitionsdaten enthält.
Wenn die Tabelle `spectrum.lineitem_part` beispielsweise mit `PARTITIONED BY (l_shipdate date)` definiert ist, führen Sie den folgenden ALTER TABLE-Befehl aus, um eine Partition hinzuzufügen.
```
ALTER TABLE spectrum.lineitem_part ADD PARTITION (l_shipdate='1992-01-29')
LOCATION 's3://spectrum-public/lineitem_partition/l_shipdate=1992-01-29';
```
Wenn Sie CREATE EXTERNAL TABLE AS verwenden, müssen Sie ALTER TABLE...ADD PARTITION nicht ausführen. Amazon Redshift registriert neue Partitionen automatisch im externen Katalog. Amazon Redshift schreibt auch automatisch die entsprechenden Daten in Partitionen in Amazon S3, basierend auf dem Partitionsschlüssel oder den Schlüsseln, die in der Tabelle definiert sind.
Um Partitionen anzuzeigen, führen Sie eine Abfrage für die Systemansicht [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md) aus.
Für den Befehl CREATE EXTERNAL TABLE AS müssen Sie den Datentyp der Partitionsspalte nicht angeben, da diese Spalte von der Abfrage abgeleitet wird.
ROW FORMAT DELIMITED *rowformat*
Eine Klausel, die das Format der zugrundeliegenden Daten angibt. Die möglichen Werte für *rowformat* sind wie folgt:
+ LINES TERMINATED BY '*Trennzeichen*'
+ FIELDS TERMINATED BY '*Trennzeichen*'
Geben Sie ein ASCII-Zeichen für '*delimiter*' an. Sie können nicht druckbare ASCII-Zeichen mithilfe von Oktal-Code im Format `'\`*`ddd`*`'` festlegen, wobei *`d`* eine Oktalziffer (0–7) bis „\$1177“ ist. Im folgenden Beispiel wird das BEL (Bell)-Zeichen anhand Oktalziffern angegeben.
```
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\007'
```
Wenn ROW FORMAT ausgelassen wird, lautet das Standardformat DELIMITED FIELDS TERMINATED BY '\$1A' (Anfang des Headings) und LINES TERMINATED BY '\$1n' (Zeilenumbruch).
ROW FORMAT SERDE '*serde\$1name*' [WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]
Eine Klausel, die das SERDE-Format der zugrundeliegenden Daten angibt.
'*serde\$1name*'
Der Name der SerDe. Sie können die folgenden Formate angeben:
+ org.apache.hadoop.hive.serde2. RegexSerDe
+ com.amazonaws.glue.serde. GrokSerDe
+ org.apache.hadoop.hive.serde2.open CSVSerde
Dieser Parameter unterstützt die folgende Eigenschaft für Open: SerDe CSVSerde
```
'wholeFile' = 'true'
```
Setzen Sie die Eigenschaft `wholeFile` auf `true`, um Neue-Zeile-Zeichen (\$1n) innerhalb von Zeichenfolgen in Anführungszeichen für OpenCSV-Anforderungen richtig zu parsen.
+ org.openx.data.jsonserde. JsonSerDe
+ Das JSON SERDE-Format unterstützt auch ION-Dateien.
+ JSON muss wohl geformt sein.
+ Zeitstempel in Ion und JSON müssen ISO8601 das Format verwenden.
+ Dieser Parameter unterstützt die folgende SerDe Eigenschaft für JsonSerDe:
```
'strip.outer.array'='true'
```
Verarbeitet Ion/JSON Dateien, die ein sehr großes Array in äußeren Klammern ([...]) enthalten, als ob das Array mehrere JSON-Datensätze enthält.
+ com.amazon.ionhiveserde. IonHiveSerDe
Das Amazon ION-Format bietet neben Datentypen Text- und Binärformate. Bei einer externen Tabelle, die auf Daten im ION-Format verweist, weisen Sie jede Spalte in der externen Tabelle dem entsprechenden Element in den ION-Formatdaten zu. Weitere Informationen finden Sie unter [Amazon Ion](https://amzn.github.io/ion-docs/). Sie müssen gegebenenfalls auch die Ein- und Ausgabeformate angeben.
WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]
Optional können Sie Namen und Werte der Eigenschaften getrennt durch Kommas angeben.
Wenn ROW FORMAT ausgelassen wird, lautet das Standardformat DELIMITED FIELDS TERMINATED BY '\$1A' (Anfang des Headings) und LINES TERMINATED BY '\$1n' (Zeilenumbruch).
STORED AS *Dateiformat*
Das Dateiformat für Datendateien.
Gültige Formate sind folgende:
+ PARQUET
+ RCFILE ( ColumnarSerDe nur zur Verwendung von Daten, nicht LazyBinaryColumnarSerDe)
+ SEQUENCEFILE
+ TEXTFILE (für Textdateien, einschließlich JSON-Dateien).
+ ORC
+ AVRO
+ INPUTFORMAT '*input\$1format\$1classname*' OUTPUTFORMAT '*output\$1format\$1classname*'
Der Befehl CREATE EXTERNAL TABLE AS unterstützt nur zwei Dateiformate: TEXTFILE und PARQUET.
Geben Sie für INPUTFORMAT und OUTPUTFORMAT einen Klassennamen wie im folgenden Beispiel ein.
```
'org.apache.hadoop.mapred.TextInputFormat'
```
LOCATION \$1 's3://*bucket/folder*/' \$1 's3://*bucket/manifest\$1file*'\$1
Der Pfad zum -Bucket oder Amazon-S3-Ordner enthält die Datendateien oder eine Manifestdatei, die eine Liste der Amazon-S3-Objektpfade enthält. Die Buckets müssen sich in derselben AWS Region wie der Amazon Redshift Redshift-Cluster befinden. Eine Liste der unterstützten AWS -Regionen finden Sie unter [Einschränkungen für Amazon Redshift Spectrum](c-spectrum-considerations.md).
Wenn im Pfad ein Bucket oder Ordner wie `'s3://amzn-s3-demo-bucket/custdata/'` angegeben wird, scannt Redshift Spectrum die Dateien im angegebenen Bucket oder Ordner und in allen Unterordnern. Redshift Spectrum ignoriert verborgene Dateien sowie Dateien, die mit einem Punkt oder Unterstrich beginnen.
Wenn der Pfad eine Manifestdatei angibt, muss das `'s3://bucket/manifest_file'`-Argument explizit auf eine einzelne Datei verweisen, zum Beispiel `'s3://amzn-s3-demo-bucket/manifest.txt'`. Es darf kein Schlüsselpräfix referenzieren.
Das Manifest ist eine Textdatei im JSON-Format, die die URL jeder Datei, die aus Amazon S3 geladen werden soll, sowie die Größe der jeweiligen Datei in Bytes auflistet. Die URL enthält den Bucket-Namen und den vollständigen Objektpfad für die Datei. Die im Manifest angegebenen Dateien können sich in verschiedenen Buckets befinden, aber alle Buckets müssen sich in derselben AWS Region wie der Amazon Redshift Redshift-Cluster befinden. Wenn eine Datei zweimal aufgelistet wird, wird die Datei zweimal geladen. Im folgenden Beispiel wird der JSON-Code für ein Manifest gezeigt, das drei Dateien lädt.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1", "meta": { "content_length": 5956875 } },
{"url":"s3://amzn-s3-demo-bucket1/custdata.2", "meta": { "content_length": 5997091 } },
{"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
]
}
```
Sie können die Aufnahme einer bestimmten Datei obligatorisch machen. Fügen Sie dazu eine `mandatory`-Option auf Dateiebene in das Manifest ein. Wenn Sie eine externe Tabelle mit einer obligatorischen Datei abfragen, die fehlt, schlägt die SELECT-Anweisung fehl. Stellen Sie sicher, dass alle in der Definition der externen Tabelle enthaltenen Dateien vorhanden sind. Wenn sie nicht alle vorhanden sind, wird ein Fehler angezeigt, in dem die erste obligatorische Datei angezeigt wird, die nicht gefunden wird. Das folgende Beispiel zeigt den JSON für ein Manifest, wobei die `mandatory`-Option auf `true` eingestellt ist.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1", "mandatory":true, "meta": { "content_length": 5956875 } },
{"url":"s3://amzn-s3-demo-bucket1/custdata.2", "mandatory":false, "meta": { "content_length": 5997091 } },
{"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
]
}
```
Um auf Dateien zu verweisen, die mit UNLOAD erstellt wurden, können Sie das mit [UNLOAD](r_UNLOAD.md) mit dem MANIFEST-Parameter erstellte Manifest verwenden. Die Manifestdatei ist mit einer Manifestdatei für [COPY aus Amazon S3](copy-parameters-data-source-s3.md) kompatibel, es werden jedoch andere Schlüssel verwendet. Nicht verwendete Schlüssel werden ignoriert.
TABLE PROPERTIES ( '*property\$1name*'='*property\$1value*' [, ...] )
Eine Klausel, die die Tabellendefinition für Tabelleneigenschaften festlegt.
Bei Tabelleneigenschaften muss die Groß-/Kleinschreibung beachtet werden.
'compression\$1type'='*value*'
Eine Eigenschaft, die den Komprimierungstyp festlegt, der verwendet wird, wenn der Dateiname keine Erweiterung enthält. Wenn Sie diese Eigenschaft festlegen und eine Dateierweiterung vorhanden ist, wird die Erweiterung ignoriert und der von der Eigenschaft festgelegte Wert verwendet. Gültige Werte für den Komprimierungstyp sind folgende:
+ bzip2
+ gzip
+ Keine
+ snappy
'data\$1cleansing\$1enabled'='true / false’
Diese Eigenschaft legt fest, ob die Datenverarbeitung für die Tabelle aktiviert ist. Wenn 'data\$1cleansing\$1enabled' auf „true“ festgelegt ist, ist die Datenverarbeitung für die Tabelle aktiviert. Wenn 'data\$1cleansing\$1enabled' auf „false“ gesetzt ist, ist die Datenverarbeitung für die Tabelle deaktiviert. Im Folgenden finden Sie eine Liste der Datenverarbeitungseigenschaften auf Tabellenebene, die von dieser Eigenschaft gesteuert werden:
+ column\$1count\$1mismatch\$1handling
+ invalid\$1char\$1handling
+ numeric\$1overflow\$1handling
+ replacement\$1char
+ surplus\$1char\$1handling
Beispiele finden Sie unter [Beispiele für die Datenverarbeitung](r_CREATE_EXTERNAL_TABLE_examples.md#r_CREATE_EXTERNAL_TABLE_examples-data-handling).
'invalid\$1char\$1handling'='*value*'
Gibt die Aktion an, die ausgeführt werden soll, wenn Abfrageergebnisse ungültige UTF-8-Zeichenwerte enthalten. Sie können die folgenden Aktionen festlegen:
DISABLED (DEAKTIVIERT)
Führt keine ungültige Zeichenbehandlung durch.
FEHLER
Bricht Abfragen ab, die Daten zurückgeben, die ungültige UTF-8-Werte enthalten.
SET\$1TO\$1NULL
Ersetzt ungültige UTF-8-Werte durch null.
DROP\$1ROW
Ersetzt jeden Wert in der Zeile durch null.
REPLACE
Ersetzt das ungültige Zeichen durch das Ersetzungszeichen, das Sie mit `replacement_char` angeben.
'replacement\$1char'='*character*’
Gibt das Ersetzungszeichen an, das beim Festlegen von `invalid_char_handling` auf `REPLACE` verwendet werden soll.
'numeric\$1overflow\$1handling'='value’
Gibt die Aktion an, die ausgeführt werden soll, wenn ORC-Daten eine Ganzzahl (z. B. BIGINT oder int64) enthalten, die größer als die Spaltendefinition ist (z. B. SMALLINT oder int16). Sie können die folgenden Aktionen festlegen:
DISABLED (DEAKTIVIERT)
Die ungültige Zeichenbehandlung ist deaktiviert.
FEHLER
Brechen Sie die Abfrage ab, wenn die Daten ungültige Zeichen enthalten.
SET\$1TO\$1NULL
Setzen Sie ungültige Zeichen auf null.
DROP\$1ROW
Setzen Sie jeden Wert in der Zeile auf null.
'surplus\$1bytes\$1handling'='*Wert*'
Gibt an, wie geladene Daten behandelt werden, die die Länge des Datentyps überschreiten, der für Spalten mit VARBYTE-Daten definiert ist. Standardmäßig legt Redshift Spectrum den Wert für Daten auf null fest, die die Breite der Spalte überschreiten.
Sie können die folgenden Aktionen angeben, die ausgeführt werden sollen, wenn die Abfrage Daten zurückgibt, die die Länge des Datentyps überschreiten:
SET\$1TO\$1NULL
Ersetzt Daten, die die Spaltenbreite überschreiten, durch null.
DISABLED (DEAKTIVIERT)
Führt keine Behandlung für überschüssige Bytes durch.
FEHLER
Bricht Abfragen ab, die Daten zurückgeben, die die Spaltenbreite überschreiten.
DROP\$1ROW
Entfernt alle Zeilen, deren Daten die Spaltenbreite überschreiten.
TRUNCATE
Entfernt die Zeichen, die die maximale Anzahl der Zeichen überschreiten, die für die Spalte definiert sind.
'surplus\$1char\$1handling'='*value*'
Gibt an, wie geladene Daten behandelt werden, die die Länge des Datentyps überschreiten, der für Spalten definiert ist, die VARCHAR-, CHAR- oder Zeichenfolgen-Daten enthalten. Standardmäßig legt Redshift Spectrum den Wert für Daten auf null fest, die die Breite der Spalte überschreiten.
Sie können die folgenden Aktionen angeben, die ausgeführt werden sollen, wenn die Abfrage Daten zurückgibt, die die Spaltenbreite überschreiten:
SET\$1TO\$1NULL
Ersetzt Daten, die die Spaltenbreite überschreiten, durch null.
DISABLED (DEAKTIVIERT)
Führt keine überzählige Zeichenbehandlung durch.
FEHLER
Bricht Abfragen ab, die Daten zurückgeben, die die Spaltenbreite überschreiten.
DROP\$1ROW
Ersetzt jeden Wert in der Zeile durch null.
TRUNCATE
Entfernt die Zeichen, die die maximale Anzahl der Zeichen überschreiten, die für die Spalte definiert sind.
'column\$1count\$1mismatch\$1handling'='value’
Identifiziert, ob die Datei weniger oder mehr Werte für eine Zeile enthält als die in der externen Tabellendefinition angegebene Anzahl von Spalten. Diese Eigenschaft ist nur für ein unkomprimiertes Textdateiformat verfügbar. Sie können die folgenden Aktionen festlegen:
DISABLED (DEAKTIVIERT)
Die Eigenschaft zum Umgang mit nicht übereinstimmenden Spalten ist deaktiviert.
FEHLER
Die Abfrage schlägt fehl, wenn eine Nichtübereinstimmung bei der Spaltenanzahl festgestellt wird.
SET\$1TO\$1NULL
Fehlende Werte werden mit NULL aufgefüllt und die zusätzlichen Werte in jeder Zeile ignoriert.
DROP\$1ROW
Alle Zeilen, die einen Fehler bei der Spaltenanzahl enthalten, werden vom Scan ausgeschlossen.
'numRows'='*row\$1count*'
Eine Eigenschaft, die den Wert numRows für die Tabellendefinition festlegt. Um die Statistiken einer externen Tabelle explizit zu aktualisieren, legen Sie mit der Eigenschaft numRows die Größe der Tabelle fest. 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 basierend auf der Annahme, dass externe Tabellen die größeren Tabellen und lokale Tabellen die kleineren Tabellen sind.
'skip.header.line.count'='*line\$1count*'
Eine Eigenschaft, die die Anzahl der Reihen festgelegt, die am Anfang jeder Quelldatei übersprungen wird.
'serialization.null.format'=' '
Eine Eigenschaft, die Spectrum festlegt, muss einen `NULL`-Wert zurückgeben, wenn eine exakte Übereinstimmung mit dem in einem Feld angegebenen Text besteht.
'orc.schema.resolution'='mapping\$1type'
Eine Eigenschaft, die den Spalten-Mapping-Typ für Tabellen einrichtet, die das ORC-Datenformat verwenden. Für andere Datenformate wird diese Eigenschaft ignoriert.
Gültige Werte für den Spalten-Mapping-Typ sind folgende:
+ Name
+ position
Wenn die Eigenschaft *orc.schema.resolution* weggelassen wird, werden die Spalten standardmäßig nach Name zugewiesen. Wenn *orc.schema.resolution* auf einen anderen Wert als *'name'* oder *'position'* gesetzt wird, werden die Spalten nach Position zugewiesen. Weitere Informationen zum Spalten-Mapping finden Sie unter [Mapping externer Tabellenspalten zu ORC-Spalten](c-spectrum-external-tables.md#c-spectrum-column-mapping-orc).
Der COPY-Befehl weist ORC-Datendateien nur nach Position zu. Die Tabelleneigenschaft *orc.schema.resolution* hat keine Auswirkungen auf das Verhalten des COPY-Befehls.
'write.parallel'='on / off’
Eine Eigenschaft, die festlegt, ob CREATE EXTERNAL TABLE AS Daten parallel schreiben soll. Standardmäßig schreibt CREATE EXTERNAL TABLE AS die Daten parallel in mehrere Dateien, je nach der Anzahl der Slices in dem Cluster. Die Standardoption ist eingeschaltet. Wenn 'write.parallel' auf „off“ gesetzt ist, schreibt CREATE EXTERNAL TABLE AS eine oder mehrere Datendateien seriell in Amazon S3. Diese Tabelleneigenschaft gilt auch für alle nachfolgenden INSERT-Anweisungen in derselben externen Tabelle.
‘write.maxfilesize.mb’=‘size’
Eine Eigenschaft, mit der die maximale Größe (in MB) jeder Datei festgelegt wird, die von CREATE EXTERNAL TABLE AS in Amazon S3 geschrieben wurde. Die Größe muss eine gültige Ganzzahl zwischen 5 und 6.200 sein. Die standardmäßige maximale Dateigröße beträgt 6.200 MB. Diese Tabelleneigenschaft gilt auch für alle nachfolgenden INSERT-Anweisungen in derselben externen Tabelle.
‘write.kms.key.id’=‘*value*’
Sie können einen AWS Key Management Service Schlüssel angeben, um serverseitige Verschlüsselung (SSE) für Amazon S3 S3-Objekte zu aktivieren, wobei der *Wert einer der folgenden Werte* ist:
+ `auto`um den im Amazon S3 S3-Bucket gespeicherten AWS KMS Standardschlüssel zu verwenden.
+ *kms-key*, den Sie zur Verschlüsselung von Daten angeben.
*select-statement*
Eine Anweisung, die mindestens eine Zeile in die externe Tabelle einfügt, indem eine beliebige Abfrage definiert wird. Alle von der Abfrage erzeugten Zeilen werden auf der Grundlage der Tabellendefinition entweder in Text- oder in Parquet-Format in Amazon S3 geschrieben.
## Beispiele
Eine Sammlung von Beispielen ist unter [Beispiele](r_CREATE_EXTERNAL_TABLE_examples.md) verfügbar.
# Nutzungshinweise
Dieses Thema enthält Nutzungshinweise für [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Sie können die Details für Amazon-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).
## CREATE EXTERNAL TABLE AS
In einigen Fällen können Sie den Befehl CREATE EXTERNAL TABLE AS für einen AWS Glue Datenkatalog, einen AWS Lake Formation externen Katalog oder einen Apache Hive-Metastore ausführen. In solchen Fällen verwenden Sie eine AWS Identity and Access Management (IAM-) Rolle, um das externe Schema zu erstellen. Diese IAM-Rolle muss sowohl Lese- als auch Schreibberechtigungen für Amazon S3 haben.
Wenn Sie einen Lake-Formation-Katalog verwenden, muss die IAM-Rolle über die Berechtigung verfügen, eine Tabelle im Katalog zu erstellen. In diesem Fall muss sie auch über die Data Lake-Speicherort-Berechtigung für den Amazon-S3-Zielpfad verfügen. Diese IAM-Rolle wird zum Besitzer der neuen AWS Lake Formation -Tabelle.
Um sicherzustellen, dass Dateinamen eindeutig sind, verwendet Amazon Redshift das folgende Format für den Namen jeder Datei, die standardmäßig in Amazon S3 hochgeladen wurde.
`_