PostgreSQL «DESCRIBE TABLE»

1854

Comment effectuez-vous l'équivalent d'Oracle DESCRIBE TABLEdans PostgreSQL (en utilisant la commande psql)?

M. Muskrat
la source

Réponses:

2820

Essayez ceci (dans l' psqloutil de ligne de commande):

\d+ tablename

Voir le manuel pour plus d'informations.

Chris Bunch
la source
8
J'avais initialement accepté la réponse de devinmoore mais j'aime vraiment mieux celle-ci. Non seulement il décrit le tableau, mais il montre également les métadonnées telles que les descriptions des colonnes et s'il existe des OID.
M. Muskrat
27
C'est +vraiment embrayage, car PostgresSQL 9 ne donne que la description détaillée des vues lorsque vous le faites \d+ table_name, plutôt que la simple\d table_name
nessur
12
\ d ne fonctionne pas lorsque vous l'invoquez dans PosgreSQL 9.1 via pgAdmin, la réponse de Vinko ci-dessous s'applique à plus de cas
hello_earth
12
psql -Eest pratique pour obtenir le sql qui implémente \d+et similaire (pour une utilisation en dehors de l'invite psql)
bsb
17
Erreur: "n'a trouvé aucune relation nommée". Cela signifie que vous devez mettre le nom de votre table entre guillemets. Apparemment, postgres mettra en minuscule le nom de votre table sans eux et ne trouvera donc pas votre table. J'espère que cela aide toute autre personne qui vient ici et qui a ce problème. :)
amurrell
742

En plus de la méthode PostgreSQL (\ d 'quelque chose' ou \ dt 'table' ou \ ds 'séquence' et ainsi de suite)

La manière standard SQL, comme indiqué ici :

select column_name, data_type, character_maximum_length
from INFORMATION_SCHEMA.COLUMNS where table_name = '<name of table>';

Il est pris en charge par de nombreux moteurs de base de données.

Vinko Vrsalovic
la source
23
sélectionnez column_name, data_type, character_maximum_length dans INFORMATION_SCHEMA.COLUMNS où table_name = 'table';
Dr. Person Person II
7
Ceci est plus utile que \ d lorsque vous êtes bloqué avec un psql antérieur à 8.4 et un serveur post-8.4 - la commande \ d est incompatible.
beldaz
26
Cette commande s'exécute également sur RedShift, où ce \d+n'est pas le cas. Ceci est la meilleure réponse IMO
New Alexandria
6
Merveilleux, pour les postgres, j'ajouterais aussi le nom du schéma
ffflabs
3
Cela ne répertorie que les colonnes avec un minimum d'informations. \ d + donne la DDL complète de la table, y compris: valeurs par défaut, nullité, valeur suivante, précision, clé primaire, clés étrangères, index, contraintes de vérification et FK provenant d'autres tables.
bradw2k
70

Si vous souhaitez l'obtenir à partir d'une requête au lieu de psql, vous pouvez interroger le schéma de catalogue. Voici une requête complexe qui fait cela:

SELECT  
    f.attnum AS number,  
    f.attname AS name,  
    f.attnum,  
    f.attnotnull AS notnull,  
    pg_catalog.format_type(f.atttypid,f.atttypmod) AS type,  
    CASE  
        WHEN p.contype = 'p' THEN 't'  
        ELSE 'f'  
    END AS primarykey,  
    CASE  
        WHEN p.contype = 'u' THEN 't'  
        ELSE 'f'
    END AS uniquekey,
    CASE
        WHEN p.contype = 'f' THEN g.relname
    END AS foreignkey,
    CASE
        WHEN p.contype = 'f' THEN p.confkey
    END AS foreignkey_fieldnum,
    CASE
        WHEN p.contype = 'f' THEN g.relname
    END AS foreignkey,
    CASE
        WHEN p.contype = 'f' THEN p.conkey
    END AS foreignkey_connnum,
    CASE
        WHEN f.atthasdef = 't' THEN d.adsrc
    END AS default
FROM pg_attribute f  
    JOIN pg_class c ON c.oid = f.attrelid  
    JOIN pg_type t ON t.oid = f.atttypid  
    LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = f.attnum  
    LEFT JOIN pg_namespace n ON n.oid = c.relnamespace  
    LEFT JOIN pg_constraint p ON p.conrelid = c.oid AND f.attnum = ANY (p.conkey)  
    LEFT JOIN pg_class AS g ON p.confrelid = g.oid  
WHERE c.relkind = 'r'::char  
    AND n.nspname = '%s'  -- Replace with Schema name  
    AND c.relname = '%s'  -- Replace with table name  
    AND f.attnum > 0 ORDER BY number
;

C'est assez complexe mais il vous montre la puissance et la flexibilité du catalogue système de PostgreSQL et devrait vous aider à maîtriser pg_catalog ;-). Assurez-vous de modifier les% s dans la requête. Le premier est Schéma et le second est le nom de la table.

Gavin M. Roy
la source
3
Cette requête est mieux montrée ici, notez qu'ils suggèrent également "\ d table"
Flavien Volken
3
Un avantage de cette solution est qu'elle format_type()inclura tous les modificateurs attachés au type, par exemple numeric(6,2); alors que information_schema.columnsne rapportera que le type de base de numeric.
Eli Collins
3
Comment séparer le type de données de la taille? dire | caractère variable (50) | à 2 colonnes: | caractère variable | 50 |
ivanceras
51

Vous pouvez le faire avec une commande psql slash:

 \d myTable describe table

Cela fonctionne également pour d'autres objets:

 \d myView describe view
 \d myIndex describe index
 \d mySequence describe sequence

Source: faqs.org

devinmoore
la source
36

L'équivalent psql de DESCRIBE TABLEest \d table.

Voir la partie psql du manuel PostgreSQL pour plus de détails.

M. Muskrat
la source
2
De plus, la sélection de base de données psql est \c databasenameplutôt que use databasename(pour ceux qui viennent de MySQL comme moi :-). Sans d' \c databasenameabord, \d tablenameproduit un No relations found.message et rien de plus.
Ville
27

Cela devrait être la solution:

SELECT * FROM information_schema.columns
WHERE table_schema = 'your_schema'
   AND table_name   = 'your_table'
LeYAUable
la source
21

Vous pouvez faire un \d *search pattern * avec des astérisques pour trouver des tableaux qui correspondent au modèle de recherche qui vous intéresse.

Ryan
la source
C'est ce que je cherchais - comment décrire un sous - ensemble de tableaux. À noter, j'ai également constaté que si vos tables sont en majuscules, la syntaxe est \d *"<SubString>"*. Autrement dit, les guillemets doubles doivent être à l' intérieur des astérisques. Cependant, si vous voulez juste la liste des tableaux, alors vous voulez utiliser\dt
Randall
cela correspond aux séquences et aux index ainsi qu'aux tables
15

En plus de la ligne de commande que \d+ <table_name>vous avez déjà trouvée, vous pouvez également utiliser le schéma d' information pour rechercher les données de colonne, en utilisant info_schema.columns

SELECT *
FROM info_schema.columns
WHERE table_schema = 'your_schema'
AND table_name   = 'your_table'
Mushahid Khan
la source
9
FROM info_schema.columnsne fonctionnait pas pour moi, je devais utiliser from information_schema.columns, je ne sais pas si c'est une faute de frappe dans votre réponse ou un problème d'implémentation de mon côté.
user27874
14

Utilisez l'instruction SQL suivante

SELECT DATA_TYPE 
FROM INFORMATION_SCHEMA.COLUMNS 
WHERE table_name = 'tbl_name' 
AND COLUMN_NAME = 'col_name'

Si vous remplacez tbl_name et col_name, il affiche le type de données de la colonne particulière que vous recherchez.

Mr.Tananki
la source
3
C'est ce que dit cette réponse de 2008.
Quentin
@ Quentin-Il y a une différence dans les deux .. la solution 2008 ci-dessus décrit column_name, data_type, character_maximum_length pour toute la table. Where as mine - la solution mentionnée - n'affiche que le type de données de la colonne de schéma. Exécutez les deux et vérifiez. Ils sont tous les deux différents. Toutes les solutions ici sont différentes manières de résoudre un problème. L'utilisateur peut l'utiliser pour différentes raisons
Mr.Tananki
14

Vous pouvez utiliser ceci:

SELECT attname 
FROM pg_attribute,pg_class 
WHERE attrelid=pg_class.oid 
AND relname='TableName' 
AND attstattarget <>0; 
YATK
la source
7

Dans MySQL , DESCRIBE nom_table


Dans PostgreSQL , \ d nom_table


Ou, vous pouvez utiliser cette longue commande:

SELECT
        a.attname AS Field,
        t.typname || '(' || a.atttypmod || ')' AS Type,
        CASE WHEN a.attnotnull = 't' THEN 'YES' ELSE 'NO' END AS Null,
        CASE WHEN r.contype = 'p' THEN 'PRI' ELSE '' END AS Key,
        (SELECT substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid), '\'(.*)\'')
                FROM
                        pg_catalog.pg_attrdef d
                WHERE
                        d.adrelid = a.attrelid
                        AND d.adnum = a.attnum
                        AND a.atthasdef) AS Default,
        '' as Extras
FROM
        pg_class c 
        JOIN pg_attribute a ON a.attrelid = c.oid
        JOIN pg_type t ON a.atttypid = t.oid
        LEFT JOIN pg_catalog.pg_constraint r ON c.oid = r.conrelid 
                AND r.conname = a.attname
WHERE
        c.relname = 'tablename'
        AND a.attnum > 0

ORDER BY a.attnum
MonsieurJoyson
la source
7

Pour améliorer la requête SQL de l'autre réponse (ce qui est génial!), Voici une requête révisée. Il comprend également des noms de contrainte, des informations d'héritage et un type de données divisé en ses parties constituantes (type, longueur, précision, échelle). Il filtre également les colonnes qui ont été supprimées (qui existent toujours dans la base de données).

SELECT
    n.nspname as schema,
    c.relname as table,
    f.attname as column,  
    f.attnum as column_id,  
    f.attnotnull as not_null,
    f.attislocal not_inherited,
    f.attinhcount inheritance_count,
    pg_catalog.format_type(f.atttypid,f.atttypmod) AS data_type_full,
    t.typname AS data_type_name,
    CASE  
        WHEN f.atttypmod >= 0 AND t.typname <> 'numeric'THEN (f.atttypmod - 4) --first 4 bytes are for storing actual length of data
    END AS data_type_length, 
    CASE  
        WHEN t.typname = 'numeric' THEN (((f.atttypmod - 4) >> 16) & 65535)
    END AS numeric_precision,   
    CASE  
        WHEN t.typname = 'numeric' THEN ((f.atttypmod - 4)& 65535 )
    END AS numeric_scale,       
    CASE  
        WHEN p.contype = 'p' THEN 't'  
        ELSE 'f'  
    END AS is_primary_key,  
    CASE
        WHEN p.contype = 'p' THEN p.conname
    END AS primary_key_name,
    CASE  
        WHEN p.contype = 'u' THEN 't'  
        ELSE 'f'
    END AS is_unique_key,
    CASE
        WHEN p.contype = 'u' THEN p.conname
    END AS unique_key_name,
    CASE
        WHEN p.contype = 'f' THEN 't'
        ELSE 'f'
    END AS is_foreign_key,
    CASE
        WHEN p.contype = 'f' THEN p.conname
    END AS foreignkey_name,
    CASE
        WHEN p.contype = 'f' THEN p.confkey
    END AS foreign_key_columnid,
    CASE
        WHEN p.contype = 'f' THEN g.relname
    END AS foreign_key_table,
    CASE
        WHEN p.contype = 'f' THEN p.conkey
    END AS foreign_key_local_column_id,
    CASE
        WHEN f.atthasdef = 't' THEN d.adsrc
    END AS default_value
FROM pg_attribute f  
    JOIN pg_class c ON c.oid = f.attrelid  
    JOIN pg_type t ON t.oid = f.atttypid  
    LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = f.attnum  
    LEFT JOIN pg_namespace n ON n.oid = c.relnamespace  
    LEFT JOIN pg_constraint p ON p.conrelid = c.oid AND f.attnum = ANY (p.conkey)  
    LEFT JOIN pg_class AS g ON p.confrelid = g.oid  
WHERE c.relkind = 'r'::char  
    AND f.attisdropped = false
    AND n.nspname = '%s'  -- Replace with Schema name  
    AND c.relname = '%s'  -- Replace with table name  
    AND f.attnum > 0 
ORDER BY f.attnum
;
Howard Elton
la source
4

Vous pouvez également vérifier en utilisant la requête ci-dessous

Select * from schema_name.table_name limit 0;

Expmple: Ma table a 2 colonnes de nom et pwd. Donner une capture d'écran ci-dessous.

Ajout d'image

* Utilisation de PG admin3

Riya Bansal
la source
parce que sélectionner et attendre que le pgadmin récupère le temps nécessaire pour obtenir les métadonnées n'est pas une «meilleure pratique»
Mickey Perlstein
2

La meilleure façon de décrire une table telle qu'une colonne, un type, des modificateurs de colonnes, etc.

\d+ tablename or \d tablename
Gardien
la source
1
Use this command 

\d table name

like 

\d queuerecords

             Table "public.queuerecords"
  Column   |            Type             | Modifiers
-----------+-----------------------------+-----------
 id        | uuid                        | not null
 endtime   | timestamp without time zone |
 payload   | text                        |
 queueid   | text                        |
 starttime | timestamp without time zone |
 status    | text                        |
Usman Yaqoob
la source
1
In postgres \d is used to describe the table structure.
e.g. \d schema_name.table_name;
this command will provide you the basic info of table such as, columns, type and modifiers.

If you want more info about table use
\d+ schema_name.table_name;
this will give you extra info such as, storage, stats target and description
meenal
la source
0

1) PostgreSQL DESCRIBE TABLE en utilisant psql

Dans l'outil de ligne de commande psql, \ d nom_table ou \ d + nom_table pour rechercher les informations sur les colonnes d'une table

2) PostgreSQL DESCRIBE TABLE utilisant information_schema

Instruction SELECT pour interroger les noms_colonnes, le type de données, la longueur maximale des caractères de la table des colonnes dans la base de données information_schema;

SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH dans INFORMATION_SCHEMA.COLUMNS où table_name = 'tablename';

Pour plus d'informations https://www.postgresqltutorial.com/postgresql-describe-table/

SumiSujith
la source
-1

/ dt est la commande qui vous répertorie toutes les tables présentes dans une base de données. en utilisant la
commande / d et / d + nous pouvons obtenir les détails d'une table. La sysntax sera comme
* / d nom_table (ou) \ d + nom_table

Pavan Teja
la source
-3

J'ai travaillé sur le script suivant pour obtenir le schéma de table.

'CREATE TABLE ' || 'yourschema.yourtable' || E'\n(\n' ||
array_to_string(
array_agg(
'    ' || column_expr
)
, E',\n'
) || E'\n);\n'
from
(
SELECT '    ' || column_name || ' ' || data_type || 
coalesce('(' || character_maximum_length || ')', '') || 
case when is_nullable = 'YES' then ' NULL' else ' NOT NULL' end as column_expr
FROM information_schema.columns
WHERE table_schema || '.' || table_name = 'yourschema.yourtable'
ORDER BY ordinal_position
) column_list;
paulg
la source
||semble être quelque chose comme un opérateur de concaténation (reliant des chaînes)