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. # Systemkatalogtabellen **Topics** + [PG\$1ATTRIBUTE\$1INFO](r_PG_ATTRIBUTE_INFO.md) + [PG\$1CLASS\$1INFO](r_PG_CLASS_INFO.md) + [PG\$1DATABASE\$1INFO](r_PG_DATABASE_INFO.md) + [PG\$1DEFAULT\$1ACL](r_PG_DEFAULT_ACL.md) + [PG\$1EXTERNAL\$1SCHEMA](r_PG_EXTERNAL_SCHEMA.md) + [PG\$1LIBRARY](r_PG_LIBRARY.md) + [PG\$1PROC\$1INFO](r_PG_PROC_INFO.md) + [PG\$1STATISTIC\$1INDICATOR](r_PG_STATISTIC_INDICATOR.md) + [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md) + [PG\$1USER\$1INFO](pg_user_info.md) + [Abfragen der Katalogtabellen](c_join_PG.md) Die Systemkataloge speichern Schema-Metadaten, wie etwa Informationen zu Tabellen und Spalten. Systemkatalogtabellen haben das Präfix PG. Die Standard-PostgreSQL-Katalogtabellen sind für Amazon-Redshift-Benutzer zugänglich. Weitere Informationen zu PostgreSQL-Systemkatalogen finden Sie unter [PostgreSQL-Systemtabellen](https://www.postgresql.org/docs/8.0/static/catalogs.html#CATALOGS-OVERVIEW). # PG\$1ATTRIBUTE\$1INFO PG\$1ATTRIBUTE\$1INFO ist eine Amazon-Redshift-Systemansicht, die auf der PostgreSQL-Katalogtabelle PG\$1ATTRIBUTE und der internen Katalogtabelle PG\$1ATTRIBUTE\$1ACL basiert. PG\$1ATTRIBUTE\$1INFO enthält Details zu Spalten einer Tabelle oder Ansicht, einschließlich Spaltenzugriffskontrolllisten, falls vorhanden. ## Tabellenspalten PG\$1ATTRIBUTE\$1INFO zeigt zusätzlich zu den Spalten in PG\$1ATTRIBUTE die folgende Spalte. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_ATTRIBUTE_INFO.html) # PG\$1CLASS\$1INFO PG\$1CLASS\$1INFO ist eine Amazon-Redshift-Systemansicht in den PostgreSQL-Katalogtabellen PG\$1CLASS und PG\$1CLASS\$1EXTENDED. PG\$1CLASS\$1INFO enthält Informationen zum Zeitpunkt der Tabellenerstellung und zum aktuellen Verteilungsstil. Weitere Informationen finden Sie unter [Datenverteilung zur Abfrageoptimierung](t_Distributing_data.md). PG\$1CLASS\$1INFO ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data). ## Tabellenspalten PG\$1CLASS\$1INFO zeigt die folgenden Spalten zusätzlich zu den Spalten in PG\$1CLASS an. Die `oid`-Spalte in PG\$1CLASS hat in der Tabelle PG\$1CLASS\$1INFO den Namen `reloid`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_CLASS_INFO.html) Die Spalte RELEFFECTIVEDISTSTYLE in PG\$1CLASS\$1INFO zeigt den Verteilungsstil für die Tabelle an. Wenn die Tabelle die automatische Verteilung verwendet, ist RELEFFECTIVEDISTSTYLE auf 10, 11 oder 12 festgelegt. Diese Werte bezeichnen die verwendeten Verteilungsstile AUTO (ALL), AUTO (EVEN) oder AUTO (KEY). Wenn die Tabelle die automatische Verteilung verwendet, ändert sich der Verteilungsstil von anfänglich AUTO (ALL) in AUTO (EVEN), wenn die Tabelle wächst, oder AUTO (KEY), wenn eine Spalte als Verteilungsschlüssel dienen kann. In der folgenden Tabelle wird der Verteilungsstil für die einzelnen Werte in der Spalte RELEFFECTIVEDISTSTYLE angegeben: | RELEFFECTIVEDISTSTYLE | Aktueller Verteilungsstil | | --- | --- | | 0 | EVEN | | 1 | KEY | | 8 | ALL | | 10 | AUTO (ALL) | | 11 | AUTO (EVEN) | | 12 | AUTO (KEY) | ## Beispiel Die folgende Abfrage gibt den aktuellen Verteilungsstil von Tabellen im Katalog zurück. ``` select reloid as tableid,trim(nspname) as schemaname,trim(relname) as tablename,reldiststyle,releffectivediststyle, CASE WHEN "reldiststyle" = 0 THEN 'EVEN'::text WHEN "reldiststyle" = 1 THEN 'KEY'::text WHEN "reldiststyle" = 8 THEN 'ALL'::text WHEN "releffectivediststyle" = 10 THEN 'AUTO(ALL)'::text WHEN "releffectivediststyle" = 11 THEN 'AUTO(EVEN)'::text WHEN "releffectivediststyle" = 12 THEN 'AUTO(KEY)'::text ELSE '<>'::text END as diststyle,relcreationtime from pg_class_info a left join pg_namespace b on a.relnamespace=b.oid; ``` ``` tableid | schemaname | tablename | reldiststyle | releffectivediststyle | diststyle | relcreationtime ---------+------------+-----------+--------------+-----------------------+------------+---------------------------- 3638033 | public | customer | 0 | 0 | EVEN | 2019-06-13 15:02:50.666718 3638037 | public | sales | 1 | 1 | KEY | 2019-06-13 15:03:29.595007 3638035 | public | lineitem | 8 | 8 | ALL | 2019-06-13 15:03:01.378538 3638039 | public | product | 9 | 10 | AUTO(ALL) | 2019-06-13 15:03:42.691611 3638041 | public | shipping | 9 | 11 | AUTO(EVEN) | 2019-06-13 15:03:53.69192 3638043 | public | support | 9 | 12 | AUTO(KEY) | 2019-06-13 15:03:59.120695 (6 rows) ``` # PG\$1DATABASE\$1INFO PG\$1DATABASE\$1INFO ist eine Amazon-Redshift-Systemansicht, die die PostgreSQL-Katalogtabelle PG\$1DATABASE erweitert. PG\$1DATABASE\$1INFO ist für alle Benutzer sichtbar. ## Tabellenspalten PG\$1DATABASE\$1INFO enthält neben den Spalten aus PG\$1DATABASE die folgenden Spalten. Die `oid`-Spalte in PG\$1DATABASE hat in der Tabelle PG\$1DATABASE\$1INFO den Namen `datid`. Weitere Informationen finden Sie in der [PostgreSQL-Dokumentation](https://www.postgresql.org/docs/8.0/catalog-pg-database.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_DATABASE_INFO.html) # PG\$1DEFAULT\$1ACL Speichert Informationen zu Standard-Zugriffsberechtigungen. Für weitere Informationen zu Standard-Zugriffsberechtigungen vgl. [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md). PG\$1DEFAULT\$1ACL ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data). ## Tabellenspalten [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_DEFAULT_ACL.html) ## Beispiel Die folgende Abfrage gibt alle für die Datenbank definierten Standardberechtigungen zurück. ``` select pg_get_userbyid(d.defacluser) as user, n.nspname as schema, case d.defaclobjtype when 'r' then 'tables' when 'f' then 'functions' end as object_type, array_to_string(d.defaclacl, ' + ') as default_privileges from pg_catalog.pg_default_acl d left join pg_catalog.pg_namespace n on n.oid = d.defaclnamespace; user | schema | object_type | default_privileges -------+--------+-------------+------------------------------------------------------- admin | tickit | tables | user1=r/admin + "group group1=a/admin" + user2=w/admin ``` Das Ergebnis im vorherigen Beispiel zeigt, dass für alle vom Benutzer `admin` im Schema `tickit` erstellten neuen Tabellen `admin` SELECT-Berechtigungen für `user1`, INSERT-Berechtigungen für `group1` und UPDATE-Berechtigungen für `user2` gewährt. # PG\$1EXTERNAL\$1SCHEMA Speichert Informationen über externe Schemata. PG\$1EXTERNAL\$1SCHEMA ist für alle Benutzer sichtbar. Superuser können alle Zeilen anzeigen, während normale Benutzer nur die Metadaten anzeigen können, auf die sie Zugriff haben. Weitere Informationen finden Sie unter [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md). ## Tabellenspalten [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_EXTERNAL_SCHEMA.html) ## Beispiel Das folgende Beispiel zeigt Einzelheiten für externe Schemata. ``` select esoid, nspname as schemaname, nspowner, esdbname as external_db, esoptions from pg_namespace a,pg_external_schema b where a.oid=b.esoid; esoid | schemaname | nspowner | external_db | esoptions -------+-----------------+----------+-------------+------------------------------------------------------------- 100134 | spectrum_schema | 100 | spectrum_db | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"} 100135 | spectrum | 100 | spectrumdb | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"} 100149 | external | 100 | external_db | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"} ``` # PG\$1LIBRARY Speichert Informationen zu benutzerdefinierten Bibliotheken. PG\$1LIBRARY ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data). ## Tabellenspalten [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_LIBRARY.html) ## Beispiel Das folgende Beispiel gibt Informationen über von Benutzern installierte Bibliotheken zurück. ``` select * from pg_library; name | language_oid | file_store_id | owner -----------+--------------+---------------+------ f_urlparse | 108254 | 2000 | 100 ``` # PG\$1PROC\$1INFO PG\$1PROC\$1INFO ist eine Amazon-Redshift-Systemansicht in der PostgreSQL-Katalogtabelle PG\$1PROC und der internen Katalogtabelle PG\$1PROC\$1EXTENDED. PG\$1PROC\$1INFO enthält Details zu gespeicherten Prozeduren und Funktionen, einschließlich Informationen über Ausgabeargumente, falls vorhanden. ## Tabellenspalten PG\$1PROC\$1INFO zeigt die folgenden Spalten zusätzlich zu den Spalten in PG\$1PROC an. Die `oid`-Spalte in PG\$1PROC hat in der Tabelle PG\$1PROG\$1INFO den Namen `prooid`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_PROC_INFO.html) Das Feld proargnames in PG\$1PROC\$1INFO enthält die Namen aller Argumenttypen (einschließlich OUT und INOUT), falls vorhanden. # PG\$1STATISTIC\$1INDICATOR Speichert Informationen zur Anzahl der seit dem letzten ANALYZE-Vorgang eingefügten oder gelöschten Zeilen. Die Tabelle PG\$1STATISTIC\$1INDICATOR wird häufig nach DML-Operationen aktualisiert, die statistischen Daten sind daher nur Näherungswerte. PG\$1STATISTIC\$1INDICATOR ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data). ## Tabellenspalten [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_STATISTIC_INDICATOR.html) ## Beispiel Das folgende Beispiel gibt Informationen zu den Tabellenänderungen seit dem letzten ANALYZE-Vorgang zurück. ``` select * from pg_statistic_indicator; stairelid | stairows | staiins | staidels ----------+----------+---------+--------- 108271 | 11 | 0 | 0 108275 | 365 | 0 | 0 108278 | 8798 | 0 | 0 108280 | 91865 | 0 | 100632 108267 | 89981 | 49990 | 9999 108269 | 808 | 606 | 374 108282 | 152220 | 76110 | 248566 ``` # PG\$1TABLE\$1DEF Speichert Informationen zu Tabellenspalten. PG\$1TABLE\$1DEF gibt nur Informationen zu Tabellen zurück, die für den Benutzer sichtbar sind. Wenn PG\$1TABLE\$1DEF nicht die erwarteten Ergebnisse ausgibt, prüfen Sie, ob der Parameter [search\$1path](r_search_path.md) korrekt so eingestellt ist, dass die relevanten Schemata eingeschlossen sind. Mit [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md) können Sie umfassendere Informationen zu einer Tabelle anzeigen, einschließlich der Datenverteilungsverzerrung, der Schlüsselverteilungsverzerrung, der Tabellengröße und statistischer Daten. ## Tabellenspalten [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_PG_TABLE_DEF.html) ## Beispiel Das folgende Beispiel zeigt die zusammengesetzten Sortierschlüsselspalten für die Tabelle LINEORDER\$1COMPOUND. ``` select "column", type, encoding, distkey, sortkey, "notnull" from pg_table_def where tablename = 'lineorder_compound' and sortkey <> 0; column | type | encoding | distkey | sortkey | notnull -------------+---------+----------+---------+---------+-------- lo_orderkey | integer | delta32k | false | 1 | true lo_custkey | integer | none | false | 2 | true lo_partkey | integer | none | true | 3 | true lo_suppkey | integer | delta32k | false | 4 | true lo_orderdate | integer | delta | false | 5 | true (5 rows) ``` Das folgende Beispiel zeigt die überlappenden Sortierschlüsselspalten für die Tabelle LINEORDER\$1INTERLEAVED. ``` select "column", type, encoding, distkey, sortkey, "notnull" from pg_table_def where tablename = 'lineorder_interleaved' and sortkey <> 0; column | type | encoding | distkey | sortkey | notnull -------------+---------+----------+---------+---------+-------- lo_orderkey | integer | delta32k | false | -1 | true lo_custkey | integer | none | false | 2 | true lo_partkey | integer | none | true | -3 | true lo_suppkey | integer | delta32k | false | 4 | true lo_orderdate | integer | delta | false | -5 | true (5 rows) ``` PG\$1TABLE\$1DEF gibt nur Informationen für Tabellen in Schemata aus, die zum Suchpfad gehören. Weitere Informationen finden Sie unter [search\$1path](r_search_path.md). Nehmen Sie beispielsweise an, Sie erstellen ein neues Schema und eine neue Tabelle und fragen dann PG\$1TABLE\$1DEF ab. ``` create schema demo; create table demo.demotable (one int); select * from pg_table_def where tablename = 'demotable'; schemaname|tablename|column| type | encoding | distkey | sortkey | notnull ----------+---------+------+------+----------+---------+---------+-------- ``` Die Abfrage gibt für die neue Tabelle keine Zeilen zurück. Prüfen Sie die Einstellung für `search_path`. ``` show search_path; search_path --------------- $user, public (1 row) ``` Fügen Sie das Schema `demo` zum Suchpfad hinzu und führen Sie die Abfrage erneut aus. ``` set search_path to '$user', 'public', 'demo'; select * from pg_table_def where tablename = 'demotable'; schemaname| tablename |column| type | encoding |distkey|sortkey| notnull ----------+-----------+------+---------+----------+-------+-------+-------- demo | demotable | one | integer | none | f | 0 | f (1 row) ``` # PG\$1USER\$1INFO PG\$1USER\$1INFO ist eine Amazon-Redshift-Systemansicht, die Benutzerinformationen wie Benutzer-ID und Ablaufzeit des Passworts anzeigt. Nur Superuser können PG\$1USER\$1INFO sehen. ## Tabellenspalten PG\$1USER\$1INFO enthält die folgenden Spalten. Weitere Informationen finden Sie in der [PostgreSQL-Dokumentation](https://www.postgresql.org/docs/8.0/view-pg-user.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/pg_user_info.html) # Abfragen der Katalogtabellen **Topics** + [Beispiele für Katalogabfragen](c_join_PG_examples.md) Im Allgemeinen können Sie Katalogtabellen und Ansichten (Beziehungen, deren Namen mit **PG\$1** beginnen) mit Amazon-Redshift-Tabellen und -Ansichten verbinden. Die Katalogtabellen verwenden eine Reihe von Datentypen, die Amazon Redshift nicht unterstützt. Die folgenden Datentypen werden unterstützt, wenn Abfragen Katalogtabellen mit Amazon-Redshift-Tabellen verbinden: + bool + „char“ + float4 + int2 + int4 + int8 + Name + oid + Text + varchar Wenn Sie eine Verbindungsabfrage schreiben, die explizit oder implizit auf eine Spalte verweist, die einen nicht unterstützten Datentyp aufweist, gibt die Abfrage einen Fehler aus. Die in einigen Katalogtabellen verwendeten SQL-Funktionen werden ebenfalls nicht unterstützt, ausgenommen solche, die von den Tabellen PG\$1SETTINGS und PG\$1LOCKS verwendet werden. So kann beispielsweise die Tabelle PG\$1STATS aufgrund nicht unterstützter Funktionen nicht in Verbindung mit einer Amazon-Redshift-Tabelle abgefragt werden. Die folgenden Katalogtabellen und -ansichten bieten nützliche Informationen, die mit Informationen in Amazon-Redshift-Tabellen verbunden werden können. Einige dieser Tabellen erlauben aufgrund von Datentyp- und Funktionseinschränkungen nur den partiellen Zugriff. Wenn Sie die nur partiell zugänglichen Tabellen abfragen, wählen Sie deren Spalten sorgfältig aus. Die folgenden Tabellen sind vollständig zugänglich und enthalten keine nicht unterstützten Typen oder Funktionen: + [pg\$1attribute](https://www.postgresql.org/docs/8.0/static/catalog-pg-attribute.html) + [pg\$1cast ](https://www.postgresql.org/docs/8.0/static/catalog-pg-cast.html) + [pg\$1depend](https://www.postgresql.org/docs/8.0/static/catalog-pg-depend.html) + [pg\$1description ](https://www.postgresql.org/docs/8.0/static/catalog-pg-description.html) + [pg\$1locks ](https://www.postgresql.org/docs/8.0/static/view-pg-locks.html) + [pg\$1opclass ](https://www.postgresql.org/docs/8.0/static/catalog-pg-opclass.html) Die folgenden Tabellen sind nur partiell zugänglich und enthalten nicht unterstützte Typen, Funktionen und abgeschnittene Textspalten. Werte in Textspalten werden auf varchar(256)-Werte verkürzt. + [pg\$1class](https://www.postgresql.org/docs/8.0/static/catalog-pg-class.html) + [pg\$1constraint](https://www.postgresql.org/docs/8.0/static/catalog-pg-constraint.html) + [pg\$1database](https://www.postgresql.org/docs/8.0/static/catalog-pg-database.html) + [pg\$1group](https://www.postgresql.org/docs/8.0/static/catalog-pg-group.html) + [pg\$1language ](https://www.postgresql.org/docs/8.0/static/catalog-pg-language.html) + [pg\$1namespace](https://www.postgresql.org/docs/8.0/static/catalog-pg-namespace.html) + [pg\$1operator](https://www.postgresql.org/docs/8.0/static/catalog-pg-operator.html) + [pg\$1proc](https://www.postgresql.org/docs/8.0/static/catalog-pg-proc.html) + [pg\$1settings](https://www.postgresql.org/docs/8.0/static/view-pg-settings.html) + [pg\$1statistic](https://www.postgresql.org/docs/8.0/static/catalog-pg-statistic.html) + [pg\$1tables](https://www.postgresql.org/docs/8.0/static/view-pg-tables.html) + [pg\$1type ](https://www.postgresql.org/docs/8.0/static/catalog-pg-type.html) + [pg\$1user](https://www.postgresql.org/docs/8.0/static/view-pg-user.html) + [pg\$1views](https://www.postgresql.org/docs/8.0/static/view-pg-views.html) Die hier nicht aufgeführten Katalogtabellen sind entweder nicht zugänglich oder für Amazon-Redshift-Administratoren eher unwichtig. Sie können jedoch jede Katalogtabelle oder -ansicht offen abfragen, wenn die Abfrage keine Verbindung zu einer Amazon-Redshift-Tabelle beinhaltet. Sie können die OID-Spalten in den Postgres-Katalogtabellen als Verbindungsspalten verwenden. Beispielsweise gleicht die Verbindungsbedingung `pg_database.oid = stv_tbl_perm.db_id` die interne Datenbankobjekt-ID für jede Zeile von PG\$1DATABASE mit der sichtbaren Spalte DB\$1ID in der Tabelle STV\$1TBL\$1PERM ab. Die OID-Spalten sind interne Primärschlüssel, die nicht sichtbar sind, wenn Sie eine Auswahl aus der Tabelle treffen. Die Katalogansichten haben keine OID-Spalten. Einige Amazon-Redshift-Funktionen können nur in den Datenverarbeitungsknoten ausgeführt werden. Wenn eine Abfrage eine vom Benutzer erstellte Tabelle referenziert, wird SQL auf den Datenverarbeitungsknoten ausgeführt. Eine Abfrage, die nur Katalogtabellen (Tabellen mit einem PG-Präfix wie PG\$1TABLE\$1DEF) oder keine Tabellen referenziert, wird ausschließlich auf dem Führungsknoten ausgeführt. Wenn eine Abfrage, die eine Datenverarbeitungsknotenfunktion verwendet, auf keine benutzerdefinierte Tabelle oder Amazon-Redshift-Systemtabelle verweist, wird der folgende Fehler zurückgegeben. ``` [Amazon](500310) Invalid operation: One or more of the used functions must be applied on at least one user created table. ``` # Beispiele für Katalogabfragen Die folgenden Abfragen zeigen einige Möglichkeiten für die Abfrage von Katalogtabellen, um nützliche Informationen zu einer Amazon-Redshift-Datenbank zu erhalten. ## Anzeige von Tabellen-ID, Datenbank, Schema und Tabellenname Die folgende Ansichtsdefinition verbindet die Systemtabelle STV\$1TBL\$1PERM mit den Systemkatalogtabellen PG\$1CLASS, PG\$1NAMESPACE und PG\$1DATABASE zur Ausgabe von Tabellen-ID, Datenbankname, Schemaname und Tabellenname. ``` create view tables_vw as select distinct(stv_tbl_perm.id) table_id ,trim(pg_database.datname) db_name ,trim(pg_namespace.nspname) schema_name ,trim(pg_class.relname) table_name from stv_tbl_perm join pg_class on pg_class.oid = stv_tbl_perm.id join pg_namespace on pg_namespace.oid = pg_class.relnamespace join pg_database on pg_database.oid = stv_tbl_perm.db_id; ``` Das folgende Beispiel gibt die Informationen für Tabellen-ID 117855 zurück. ``` select * from tables_vw where table_id = 117855; ``` ``` table_id | db_name | schema_name | table_name ---------+-----------+-------------+----------- 117855 | dev | public | customer ``` ## Auflisten der Anzahl der Spalten pro Amazon-Redshift-Tabelle Die folgende Abfrage verknüpft einige Katalogtabellen, um herauszufinden, wie viele Spalten jede Amazon-Redshift-Tabelle enthält. Amazon-Redshift-Tabellennamen werden sowohl in PG\$1TABLES als auch in STV\$1TBL\$1PERM gespeichert. Verwenden Sie nach Möglichkeit PG\$1Tables, um Amazon-Redshift-Tabellennamen zurückzunehmen. Diese Abfrage beinhaltet keine Amazon-Redshift-Tabellen. ``` select nspname, relname, max(attnum) as num_cols from pg_attribute a, pg_namespace n, pg_class c where n.oid = c.relnamespace and a.attrelid = c.oid and c.relname not like '%pkey' and n.nspname not like 'pg%' and n.nspname not like 'information%' group by 1, 2 order by 1, 2; nspname | relname | num_cols --------+----------+---------- public | category | 4 public | date | 8 public | event | 6 public | listing | 8 public | sales | 10 public | users | 18 public | venue | 5 (7 rows) ``` ## Auflisten der Schemata und Tabellen in einer Datenbank Die folgende Abfrage verbindet STV\$1TBL\$1PERM mit einigen PG-Tabellen zur Ausgabe einer Liste von Tabellen in der TICKIT-Datenbank und ihrer Schemanamen (Spalte NSPNAME). Dazu gibt die Abfrage die Gesamtzahl der Zeilen in jeder Tabelle aus. (Diese Abfrage ist nützlich, wenn mehrere Schemata in Ihrem System die gleichen Tabellennamen haben.) ``` select datname, nspname, relname, sum(rows) as rows from pg_class, pg_namespace, pg_database, stv_tbl_perm where pg_namespace.oid = relnamespace and pg_class.oid = stv_tbl_perm.id and pg_database.oid = stv_tbl_perm.db_id and datname ='tickit' group by datname, nspname, relname order by datname, nspname, relname; datname | nspname | relname | rows --------+---------+----------+-------- tickit | public | category | 11 tickit | public | date | 365 tickit | public | event | 8798 tickit | public | listing | 192497 tickit | public | sales | 172456 tickit | public | users | 49990 tickit | public | venue | 202 (7 rows) ``` ## Listet Tabellen IDs, Datentypen, Spaltennamen und Tabellennamen auf Die folgende Abfrage listet einige Informationen zu jeder Benutzertabelle und ihren Spalten aus: Tabellen-ID, Tabellenname, die Namen der Spalten sowie den Datentyp jeder Spalte: ``` select distinct attrelid, rtrim(name), attname, typname from pg_attribute a, pg_type t, stv_tbl_perm p where t.oid=a.atttypid and a.attrelid=p.id and a.attrelid between 100100 and 110000 and typname not in('oid','xid','tid','cid') order by a.attrelid asc, typname, attname; attrelid | rtrim | attname | typname ---------+----------+----------------+----------- 100133 | users | likebroadway | bool 100133 | users | likeclassical | bool 100133 | users | likeconcerts | bool ... 100137 | venue | venuestate | bpchar 100137 | venue | venueid | int2 100137 | venue | venueseats | int4 100137 | venue | venuecity | varchar ... ``` ## Zählen der Anzahl der Datenblöcke für jede Spalte in einer Tabelle Die folgende Abfrage verbindet die Tabelle STV\$1BLOCKLIST mit PG\$1CLASS zur Ausgabe von Speicherinformationen für die Spalten in der Tabelle SALES. ``` select col, count(*) from stv_blocklist s, pg_class p where s.tbl=p.oid and relname='sales' group by col order by col; col | count ----+------- 0 | 4 1 | 4 2 | 4 3 | 4 4 | 4 5 | 4 6 | 4 7 | 4 8 | 4 9 | 8 10 | 4 12 | 4 13 | 8 (13 rows) ```