Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Tables catalogue système **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) + [Interrogation des tables catalogue](c_join_PG.md) Les catalogues système stockent les métadonnées du schéma, telles que les informations sur les tables et les colonnes. Les tables catalogue système ont un préfixe PG. Les tables catalogue PostgreSQL standard sont accessibles aux utilisateurs Amazon Redshift. Pour plus d'informations sur les catalogues système PostgreSQL, consultez [Tables système PostgreSQL](https://www.postgresql.org/docs/8.0/static/catalogs.html#CATALOGS-OVERVIEW) # PG\$1ATTRIBUTE\$1INFO PG\$1ATTRIBUTE\$1INFO est une vue système Amazon Redshift basée sur la table de catalogue PostgreSQL PG\$1ATTRIBUTE et la table de catalogue interne PG\$1ATTRIBUTE\$1ACL. PG\$1ATTRIBUTE\$1INFO contient des détails sur les colonnes d'une table ou d'une vue, y compris les listes de contrôle d'accès aux colonnes, le cas échéant. ## Colonnes de la table PG\$1ATTRIBUTE\$1INFO affiche la colonne suivante en plus des colonnes de PG\$1ATTRIBUTE. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_ATTRIBUTE_INFO.html) # PG\$1CLASS\$1INFO PG\$1CLASS\$1INFO est une vue système Amazon Redshift qui repose sur les tables catalogue PostgreSQL PG\$1CLASS et PG\$1CLASS\$1EXTENDED. PG\$1CLASS\$1INFO inclut des détails sur l'heure de création de table et le style de distribution actuel. Pour plus d’informations, consultez [Distribution de données pour l’optimisation des requêtes](t_Distributing_data.md). PG\$1CLASS\$1INFO est visible par tous les utilisateurs. Les super-utilisateurs peuvent voir toutes les lignes, tandis que les utilisateurs standard peuvent voir uniquement leurs propres données. Pour plus d'informations, consultez [Visibilité des données dans les tables et vues système](cm_chap_system-tables.md#c_visibility-of-data). ## Colonnes de la table PG\$1CLASS\$1INFO montre les colonnes suivantes en plus des colonnes dans PG\$1CLASS. La colonne `oid` de PG\$1CLASS est appelée `reloid` dans la table PG\$1CLASS\$1INFO. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_CLASS_INFO.html) La colonne RELEFFECTIVEDISTSTYLE de PG\$1CLASS\$1INFO indique le style de distribution actuel pour la table. Si la table utilise la distribution automatique, RELEFFECTIVEDISTSTYLE a pour valeur 10, 11 ou 12, ce qui indique si le style de distribution effectif est AUTO (ALL), AUTO (EVEN) ou AUTO (KEY). Si la table utilise la distribution automatique, le style de distribution peut initialement afficher AUTO (ALL), puis passer à AUTO (EVEN) ou AUTO (KEY) lorsque la table se développe ou AUTO (KEY) si une colonne peut être utile en tant que clé de distribution. La table suivante donne le style de distribution pour chaque valeur de la colonne RELEFFECTIVEDISTSTYLE : | RELEFFECTIVEDISTSTYLE | Style de distribution actuel | | --- | --- | | 0 | EVEN | | 1 | KEY | | 8 | ALL | | 10 | AUTO (ALL) | | 11 | AUTO (EVEN) | | 12 | AUTO (KEY) | ## Exemple La requête suivante renvoie le style de distribution actuel des tables dans le catalogue. ``` 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 est une vue système Amazon Redshift qui étend la table de catalogue PostgreSQL PG\$1DATABASE. PG\$1DATABASE\$1INFO est visible par tous les utilisateurs. ## Colonnes de la table PG\$1DATABASE\$1INFO contient les colonnes suivantes en plus des colonnes de PG\$1DATABASE. La colonne `oid` de PG\$1DATABASE est appelée `datid` dans la table PG\$1DATABASE\$1INFO. Pour de plus amples informations, veuillez consulter la [documentation sur PostgreSQL](https://www.postgresql.org/docs/8.0/catalog-pg-database.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_DATABASE_INFO.html) # PG\$1DEFAULT\$1ACL Stocke des informations sur les privilèges d’accès par défaut. Pour plus d'informations sur les privilèges d'accès par défaut, consultez [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md). PG\$1DEFAULT\$1ACL est visible par tous les utilisateurs. Les super-utilisateurs peuvent voir toutes les lignes, tandis que les utilisateurs standard peuvent voir uniquement leurs propres données. Pour plus d'informations, consultez [Visibilité des données dans les tables et vues système](cm_chap_system-tables.md#c_visibility-of-data). ## Colonnes de la table [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_DEFAULT_ACL.html) ## Exemple La requête suivante renvoie tous les privilèges par défaut définis pour la base de données. ``` 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 ``` Le résultat de l'exemple précédent indique que pour toutes les nouvelles tables créées par l'utilisateur `admin` dans le schéma `tickit`, `admin` accorde les privilèges SELECT à `user1`, les privilèges INSERT à `group1` et les privilèges UPDATE à `user2`. # PG\$1EXTERNAL\$1SCHEMA Stocke les informations au sujet des schémas externes. PG\$1EXTERNAL\$1SCHEMA est visible par tous les utilisateurs. Les super-utilisateurs peuvent voir toutes les lignes, tandis que les utilisateurs standard peuvent voir uniquement les métadonnées auxquelles ils ont accès. Pour plus d'informations, consultez [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md). ## Colonnes de la table [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_EXTERNAL_SCHEMA.html) ## Exemple L’exemple suivant illustre les détails relatifs aux schémas externes. ``` 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 Stocke les informations sur les bibliothèques définies par l’utilisateur. PG\$1LIBRARY est visible par tous les utilisateurs. Les super-utilisateurs peuvent voir toutes les lignes, tandis que les utilisateurs standard peuvent voir uniquement leurs propres données. Pour plus d'informations, consultez [Visibilité des données dans les tables et vues système](cm_chap_system-tables.md#c_visibility-of-data). ## Colonnes de la table [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_LIBRARY.html) ## Exemple L'exemple suivant renvoie des informations pour les bibliothèques installées par l'utilisateur. ``` select * from pg_library; name | language_oid | file_store_id | owner -----------+--------------+---------------+------ f_urlparse | 108254 | 2000 | 100 ``` # PG\$1PROC\$1INFO PG\$1PROC\$1INFO est une vue système Amazon Redshift basée sur la table de catalogue PostgreSQL PG\$1PROC et la table de catalogue interne PG\$1PROC\$1EXTENDED. PG\$1PROC\$1INFO comprend des détails sur les procédures stockées et les fonctions, notamment des informations relatives aux arguments en sortie, le cas échéant. ## Colonnes de la table PG\$1PROC\$1INFO affiche les colonnes suivantes en plus des colonnes dans PG\$1PROC. La colonne `oid` de PG\$1PROC est appelée `prooid` dans la table PG\$1PROC\$1INFO. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_PROC_INFO.html) Le champ proargnames dans PG\$1PROC\$1INFO contient les noms de tous les types d'arguments (y compris OUT et INOUT), le cas échéant. # PG\$1STATISTIC\$1INDICATOR Stocke les informations sur le nombre de lignes insérées ou supprimées depuis la dernière opération ANALYZE. La table PG\$1STATISTIC\$1INDICATOR est mise à jour régulièrement en fonction des opérations DML ; les statistiques sont donc approximatives. PG\$1STATISTIC\$1INDICATOR n'est visible que par les super-utilisateurs. Pour plus d’informations, consultez [Visibilité des données dans les tables et vues système](cm_chap_system-tables.md#c_visibility-of-data). ## Colonnes de la table [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_STATISTIC_INDICATOR.html) ## Exemple L'exemple suivant renvoie les informations sur les modifications apportées à la table depuis la dernière opération ANALYZE. ``` 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 Stocke les informations sur les colonnes de la table. PG\$1TABLE\$1DEF renvoie uniquement les informations sur les tables visibles de l’utilisateur. Si PG\$1TABLE\$1DEF ne renvoie pas les résultats attendus, vérifiez que le paramètre [search\$1path](r_search_path.md) est correctement défini pour inclure les schémas correspondants. Vous pouvez utiliser [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md) pour afficher des informations plus exhaustives sur une table, notamment l'asymétrie de la distribution des données, l'asymétrie de la distribution de clés, la taille de la table et les statistiques. ## Colonnes de la table [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/r_PG_TABLE_DEF.html) ## Exemple L'exemple suivant illustre les colonnes de clés de tri composées de la table 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) ``` L'exemple suivant illustre les colonnes de clés de tri entrelacées de la table 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 renvoie uniquement les informations pour les tables dans des schémas inclus dans le chemin de recherche. Pour plus d’informations, consultez [search\$1path](r_search_path.md). Par exemple, supposons que vous créiez un schéma et une table, puis que vous interrogiez PG\$1TABLE\$1DEF. ``` 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 ----------+---------+------+------+----------+---------+---------+-------- ``` La requête ne renvoie aucune ligne pour la nouvelle table. Examinez le paramètre de `search_path`. ``` show search_path; search_path --------------- $user, public (1 row) ``` Ajoutez le schéma `demo` au chemin de recherche et exécutez la requête à nouveau. ``` 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 est une vue système d'Amazon Redshift qui affiche des informations sur les utilisateurs, telles que l'ID utilisateur et le délai d'expiration du mot de passe. Seuls les super-utilisateurs peuvent afficher PG\$1USER\$1INFO. ## Colonnes de la table PG\$1USER\$1INFO contient les colonnes suivantes. Pour de plus amples informations, veuillez consulter la [documentation sur PostgreSQL](https://www.postgresql.org/docs/8.0/view-pg-user.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/redshift/latest/dg/pg_user_info.html) # Interrogation des tables catalogue **Topics** + [Exemples de requêtes de catalogue](c_join_PG_examples.md) En général, vous pouvez joindre des tables et des vues du catalogue (relations dont les noms commencent par **PG\$1**) à des tables et des vues Amazon Redshift. Les tables du catalogue utilisent un certain nombre de types de données non pris en charge par Amazon Redshift. Les types de données suivants sont pris en charge lorsque des requêtes joignent des tables de catalogue à des tables Amazon Redshift : + bool + "char" + float4 + int2 + int4 + int8 + name + oid + text + varchar Si vous écrivez une requête de jointure qui fait référence explicitement ou implicitement à une colonne avec un type de données non pris en charge, la requête renvoie une erreur. Les fonctions SQL qui sont utilisées dans certaines des tables catalogue ne sont également pas prises en charge, à l'exception de celles utilisées par les tables PG\$1SETTINGS et PG\$1LOCKS. Par exemple, la table PG\$1STATS ne peut pas être interrogée dans une jointure avec une table Amazon Redshift en raison de fonctions non prises en charge. Les tables et vues du catalogue suivantes fournissent des informations utiles qui peuvent être jointes à des informations dans les tables Amazon Redshift. Certaines de ces tables autorisent uniquement un accès partiel en raison de restrictions de type de données et de fonction. Lorsque vous interrogez les tables partiellement accessibles, sélectionnez ou faites référence à leurs colonnes avec soin. Les tables suivantes sont totalement accessibles et ne contiennent pas les types ou fonctions non pris en charge : + [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) Les tables suivantes sont partiellement accessibles et contiennent certains types, fonctions et colonnes de texte tronquées non pris en charge. Les valeurs dans les colonnes de texte sont tronquées en valeurs varchar(256). + [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) Les tables du catalogue qui ne sont pas répertoriées ici sont inaccessibles ou probablement inutiles pour les administrateurs Amazon Redshift. Cependant, vous pouvez interroger librement une table ou une vue du catalogue si votre requête n'implique pas de jointure avec une table Amazon Redshift. Vous pouvez utiliser les colonnes OID dans les tables catalogue Postgres en tant que colonnes de jointure. Par exemple, la condition de jointure `pg_database.oid = stv_tbl_perm.db_id` correspond à l'ID d'objet de base de données interne de chaque ligne PG\$1DATABASE avec la colonne DB\$1ID visible dans la table STV\$1TBL\$1PERM. Les colonnes OID sont des clés primaires internes qui ne sont pas visibles lorsque vous effectuez la sélection depuis la table. Les vues catalogue ne disposent pas de colonnes OID. Certaines fonctions Amazon Redshift ne doivent s'exécuter que sur les nœuds de calcul. Si une requête fait référence à une table créée par un utilisateur, l’instruction SQL s’exécute sur les nœuds de calcul. Une requête qui ne fait référence qu’aux tables catalogue (tables avec le préfixe PG, comme PG\$1TABLE\$1DEF) ou qui ne fait référence à aucune table, s’exécute exclusivement sur le nœud principal. Si une requête qui utilise une fonction de nœud de calcul ne fait pas référence à une table définie par un utilisateur ou à une table système Amazon Redshift, elle renvoie l’erreur suivante : ``` [Amazon](500310) Invalid operation: One or more of the used functions must be applied on at least one user created table. ``` # Exemples de requêtes de catalogue Les requêtes suivantes illustrent quelques-unes des manières dont vous pouvez interroger les tables du catalogue pour obtenir des informations utiles sur une base de données Amazon Redshift. ## Afficher l'ID de la table, la base de données, le schéma et le nom de la table La définition de vue suivante joint la table système STV\$1TBL\$1PERM aux tables catalogue système PG\$1CLASS, PG\$1NAMESPACE et PG\$1DATABASE pour renvoyer l'ID de la table, le nom de la base de données, le nom du schéma et le nom de la table. ``` 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; ``` L'exemple suivant renvoie les informations concernant l'ID de table 117855. ``` select * from tables_vw where table_id = 117855; ``` ``` table_id | db_name | schema_name | table_name ---------+-----------+-------------+----------- 117855 | dev | public | customer ``` ## Répertorier le nombre de colonnes par table Amazon Redshift La requête suivante joint certaines tables de catalogue pour connaître le nombre de colonnes que contient chaque table Amazon Redshift. Les noms de table Amazon Redshift sont stockés à la fois dans PG\$1TABLES et STV\$1TBL\$1PERM ; lorsque cela est possible, utilisez PG\$1TABLES pour renvoyer les noms de table Amazon Redshift. Cette requête n'implique pas de table Amazon Redshift. ``` 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) ``` ## Répertorier les schémas et les tables dans une base de données La requête suivante joint STV\$1TBL\$1PERM à quelques tables PG pour renvoyer une liste de tables de la base de données TICKIT et leurs noms de schéma (colonne NSPNAME). La requête renvoie également le nombre total de lignes de chaque table. (Cette requête est utile lorsque plusieurs schémas de votre système portent des noms de tables identiques.) ``` 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) ``` ## Table de liste IDs, types de données, noms de colonnes et noms de tables La requête suivante répertorie quelques informations sur chaque table d'utilisateur et ses colonnes : l'ID de la table, le nom de la table, les noms de ses colonnes et le type de données de chaque colonne : ``` 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 ... ``` ## Compter le nombre de blocs de données de chaque colonne dans une table La requête suivante joint la table STV\$1BLOCKLIST à PG\$1CLASS pour renvoyer des informations de stockage sur les colonnes de la table 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) ```