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. # Beispiele für datenbankübergreifende Abfragen Dieses Thema enthält Beispiele für die Verwendung datenbankübergreifender Abfragen. Datenbankübergreifende Abfragen sind Abfragen, die auf mehreren Datenbanken innerhalb eines einzigen Amazon-Redshift-Clusters ausgeführt werden. Anhand der folgenden Beispiele erfahren Sie, wie Sie eine datenbankübergreifende Abfrage einrichten, die auf eine Amazon-Redshift-Datenbank verweist. Erstellen Sie zum Starten die Datenbanken `db1` und `db2` sowie die Benutzer `user1` und `user2` in Ihrem Amazon-Redshift-Cluster. Weitere Informationen erhalten Sie unter [CREATE DATABASE](r_CREATE_DATABASE.md) und [CREATE USER](r_CREATE_USER.md). ``` --As user1 on db1 CREATE DATABASE db1; CREATE DATABASE db2; CREATE USER user1 PASSWORD 'Redshift01'; CREATE USER user2 PASSWORD 'Redshift01'; ``` Erstellen Sie als `user1` in `db1` eine Tabelle, erteilen Sie Zugriffsberechtigungen für `user2` und fügen Sie Werte in `table1` ein. Weitere Informationen erhalten Sie unter [GRANT](r_GRANT.md) und [INSERT](r_INSERT_30.md). ``` --As user1 on db1 CREATE TABLE table1 (c1 int, c2 int, c3 int); GRANT SELECT ON table1 TO user2; INSERT INTO table1 VALUES (1,2,3),(4,5,6),(7,8,9); ``` Führen Sie als `user2` in `db2` eine datenbankübergreifende Abfrage in `db2`unter Verwendung der dreiteiligen Notation durch. ``` --As user2 on db2 SELECT * from db1.public.table1 ORDER BY c1; c1 | c2 | c3 ---+-----+---- 1 | 2 | 3 4 | 5 | 6 7 | 8 | 9 (3 rows) ``` Gewähren Sie jetzt Schreibberechtigungen für `user2` und fügen Sie Werte in `table1` in `db1` als `user2` ein. ``` --As user1 on db1 GRANT INSERT ON table1 TO user2; ``` Führen Sie als `user2` auf `db2` eine datenbankübergreifende Abfrage in `db2` unter Verwendung der dreiteiligen Notation zur Einfügung von Daten in `table1` in `db1` durch. ``` --As user2 on db2 INSERT INTO db1.public.table1 VALUES (10,11,12); SELECT * from db1.public.table1 ORDER BY c1; c1 | c2 | c3 ----+------+---- 1 | 2 | 3 4 | 5 | 6 7 | 8 | 9 10 | 11 | 12 (4 rows) ``` Erstellen Sie als `user2` in `db2` ein externes Schema und führen Sie eine datenbankübergreifende Abfrage in `db2` unter Verwendung der externen Schemanotation durch. ``` --As user2 on db2 CREATE EXTERNAL SCHEMA db1_public_sch FROM REDSHIFT DATABASE 'db1' SCHEMA 'public'; SELECT * FROM db1_public_sch.table1 ORDER BY c1; c1 | c2 | c3 ----+----+---- 1 | 2 | 3 4 | 5 | 6 7 | 8 | 9 10 | 11 | 12 (4 rows) ``` Gehen Sie wie folgt vor, um als `user1` in `db1` verschiedene Ansichten zu erstellen und diesen Ansichten Berechtigungen zu erteilen. ``` --As user1 on db1 CREATE VIEW regular_view AS SELECT c1 FROM table1; GRANT SELECT ON regular_view TO user2; CREATE MATERIALIZED VIEW mat_view AS SELECT c2 FROM table1; GRANT SELECT ON mat_view TO user2; CREATE VIEW late_bind_view AS SELECT c3 FROM public.table1 WITH NO SCHEMA BINDING; GRANT SELECT ON late_bind_view TO user2; ``` Führen Sie als `user2` in `db2` die folgende datenbankübergreifende Abfrage mit der dreiteiligen Notation aus, um die bestimmte Ansicht anzuzeigen. ``` --As user2 on db2 SELECT * FROM db1.public.regular_view; c1 ---- 1 4 7 10 (4 rows) SELECT * FROM db1.public.mat_view; c2 ---- 2 5 8 11 (4 rows) SELECT * FROM db1.public.late_bind_view; c3 ---- 3 6 9 12 (4 rows) ``` Führen Sie als `user2` in `db2` die folgende datenbankübergreifende Abfrage mithilfe der externen Schemanotation aus, um die späte Bindungsansicht abzufragen. ``` --As user2 on db2 SELECT * FROM db1_public_sch.late_bind_view; c3 ---- 3 6 9 12 (4 rows) ``` Führen Sie als `user2` in `db2` den folgenden Befehl aus, um verbundene Tabellen in einer einzelnen Abfrage zu verwenden. ``` --As user2 on db2 CREATE TABLE table1 (a int, b int, c int); INSERT INTO table1 VALUES (1,2,3), (4,5,6), (7,8,9); SELECT a AS col_1, (db1.public.table1.c2 + b) AS sum_col2, (db1.public.table1.c3 + c) AS sum_col3 FROM db1.public.table1, table1 WHERE db1.public.table1.c1 = a; col_1 | sum_col2 | sum_col3 ------+----------+---------- 1 | 4 | 6 4 | 10 | 12 7 | 16 | 18 (3 rows) ``` Im folgenden Beispiel werden alle Datenbanken auf dem Cluster aufgelistet. ``` select database_name, database_owner, database_type from svv_redshift_databases where database_name in ('db1', 'db2'); database_name | database_owner | database_type ---------------+----------------+--------------- db1 | 100 | local db2 | 100 | local (2 rows) ``` Im folgenden Beispiel werden alle Amazon-Redshift-Schemas aller Datenbanken im Cluster aufgelistet. ``` select database_name, schema_name, schema_owner, schema_type from svv_redshift_schemas where database_name in ('db1', 'db2'); database_name | schema_name | schema_owner | schema_type ---------------+--------------------+--------------+------------- db1 | pg_catalog | 1 | local db1 | public | 1 | local db1 | information_schema | 1 | local db2 | pg_catalog | 1 | local db2 | public | 1 | local db2 | information_schema | 1 | local (6 rows) ``` Im folgenden Beispiel werden alle Amazon-Redshift-Tabellen aller Datenbanken im Cluster aufgelistet. ``` select database_name, schema_name, table_name, table_type from svv_redshift_tables where database_name in ('db1', 'db2') and schema_name in ('public'); database_name | schema_name | table_name | table_type ---------------+-------------+---------------------+------------ db1 | public | late_bind_view | VIEW db1 | public | mat_view | VIEW db1 | public | mv_tbl__mat_view__0 | TABLE db1 | public | regular_view | VIEW db1 | public | table1 | TABLE db2 | public | table2 | TABLE (6 rows) ``` Im folgenden Beispiel werden alle Amazon-Redshift- und externen Schemas aller Datenbanken im Cluster aufgelistet. ``` select database_name, schema_name, schema_owner, schema_type from svv_all_schemas where database_name in ('db1', 'db2') ; database_name | schema_name | schema_owner | schema_type ---------------+--------------------+--------------+------------- db1 | pg_catalog | 1 | local db1 | public | 1 | local db1 | information_schema | 1 | local db2 | pg_catalog | 1 | local db2 | public | 1 | local db2 | information_schema | 1 | local db2 | db1_public_sch | 1 | external (7 rows) ``` Im folgenden Beispiel werden alle Amazon-Redshift- und externen Tabellen aller Datenbanken im Cluster aufgelistet. ``` select database_name, schema_name, table_name, table_type from svv_all_tables where database_name in ('db1', 'db2') and schema_name in ('public'); database_name | schema_name | table_name | table_type ---------------+-------------+---------------------+------------ db1 | public | regular_view | VIEW db1 | public | mv_tbl__mat_view__0 | TABLE db1 | public | mat_view | VIEW db1 | public | late_bind_view | VIEW db1 | public | table1 | TABLE db2 | public | table2 | TABLE (6 rows) ```