PostgreSQL “DESCRIBE TABLE”

Question

Come si esegue l'equivalente del DESCRIBE TABLE di Oracle in PostgreSQL (usando il comando psql)?

Answer 1

Prova questo (nello strumento da riga di comando psql ):

\d+ tablename

Vedi il manuale per maggiori informazioni.

Answer 2

Oltre al modo PostgreSQL (\ d 'qualcosa' o \ dt 'tabella' o \ ds 'sequenza' e così via)

Il modo standard SQL, come mostrato qui :

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

È supportato da molti motori db.

Answer 3

Se si desidera ottenerlo dalla query anziché da psql, è possibile eseguire una query sullo schema del catalogo. Ecco una query complessa che lo fa:

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
;

È piuttosto complesso ma ti mostra la potenza e la flessibilità del catalogo di sistema PostgreSQL e dovrebbe portarti sulla strada verso la padronanza di pg_catalog ;-). Assicurati di modificare le% s nella query. Il primo è Schema e il secondo è il nome della tabella.

Answer 4

Puoi farlo con un comando slash psql:

 \d myTable describe table

Funziona anche con altri oggetti:

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

Fonte: faqs.org

Answer 5

L'equivalente psql di DESCRIBE TABLE è \ d table .

Vedi la parte psql del manuale PostgreSQL per maggiori dettagli.

Answer 6

Puoi fare un \ d * modello di ricerca * con asterischi per trovare tabelle che corrispondono al modello di ricerca che ti interessa.

Answer 7

Oltre alla riga di comando \ d + < table_name > che hai già trovato, puoi anche utilizzare schema-informazioni per cercare i dati della colonna, usando info_schema.columns

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

Answer 8

Puoi usare questo:

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

Answer 9

Utilizza la seguente istruzione SQL

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

Se si sostituisce tbl_name e col_name, viene visualizzato il tipo di dati della particolare colonna che si sta cercando.

Answer 10

Questa dovrebbe essere la soluzione:

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

Answer 11

Questa variante della query (come spiegato in altre risposte) ha funzionato per me.

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

È descritto qui in dettaglio: http://www.postgresqltutorial.com/postgresql-describe-table/

Answer 12

In MySQL , DESCRIBE table_name

---

In PostgreSQL , \ d table_name

---

Oppure puoi usare questo comando lungo:

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

Answer 13

Per migliorare la query SQL dell'altra risposta (che è eccezionale!), ecco una query rivista. Include anche nomi di vincoli, informazioni di ereditarietà e tipi di dati suddivisi nelle sue parti costitutive (tipo, lunghezza, precisione, scala). Filtra anche le colonne che sono state eliminate (che esistono ancora nel database).

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
;

Answer 14

Puoi anche controllare usando la query qui sotto

Select * from schema_name.table_name limit 0;

Expmple: la mia tabella ha 2 colonne nome e pwd. Dare screenshot qui sotto.

* Uso di PG admin3

Answer 15

Il modo migliore per descrivere una tabella come una colonna, tipo, modificatori di colonne, ecc.

\d+ tablename or \d tablename

Answer 16

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                        |

Answer 17

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

Answer 18

/ dt è il comando che elenca tutte le tabelle presenti in un database. utilizzando
/ d comando e / d + possiamo ottenere i dettagli di una tabella. Il sysntax sarà come
* / d nome_tabella (o) \ d + nome_tabella

Answer 19

Ho elaborato il seguente script per ottenere lo schema delle tabelle.

'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;