PostgreSQL «DESCRIBE TABLE»

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

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

\d+ tablename

Voir le manuel pour plus d'informations.

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.

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.

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

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

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

Cela devrait être la solution:

SELECT * FROM information_schema.columns
WHERE table_schema = 'your_schema'
   AND table_name   = 'your_table'

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.

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'

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.

Vous pouvez utiliser ceci:

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

Cette variation de la requête (comme expliqué dans d'autres réponses) a fonctionné pour moi.

SELECT
 COLUMN_NAME
FROM
 information_schema.COLUMNS
WHERE
 TABLE_NAME = 'city';

Il est décrit ici en détail: http://www.postgresqltutorial.com/postgresql-describe-table/

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

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
;

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.

* Utilisation de PG admin3

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

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                        |

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

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/

/ 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

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;