PostgreSQL “DESCRIBE TABLE”


Risposte:


2820

Prova questo (nello psqlstrumento da riga di comando):

\d+ tablename

Vedi il manuale per maggiori informazioni.


8
Inizialmente avevo accettato la risposta di Devinmoore, ma questa mi piace molto di più. Non solo descrive la tabella, ma mostra anche i metadati come le descrizioni delle colonne e se ci sono OID.
Mr. Muskrat,

27
La +è davvero frizione, come PostgreSQL 9 dà solo la descrizione approfondita per la vista quando si fanno \d+ table_name, piuttosto che la semplice\d table_name
nessur

12
\ d non funziona quando lo invochi in PosgreSQL 9.1 tramite pgAdmin, la risposta di Vinko di seguito è applicabile a più casi
hello_earth,

12
psql -Eè utile per ottenere il sql che implementa \d+e simili (per l'uso al di fuori del prompt di psql)
bsb

17
Errore: "non ha trovato alcuna relazione denominata". Ciò significa che devi racchiudere il nome del tuo tavolo tra virgolette doppie. Apparentemente, Postgres metterà in minuscolo il nome del tuo tavolo senza di essi e quindi non troverà il tuo tavolo. Spero che questo aiuti chiunque altro venga qui e abbia questo problema. :)
amurrell

742

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.


23
selezionare column_name, data_type, character_ma maximum_length da INFORMATION_SCHEMA.COLUMNS dove table_name = 'table';
Dr. Person Person II II

7
Questo è più utile di \ d quando sei bloccato con un pre-8.4 psql e un server post-8.4 - il comando \ d è incompatibile.
Beldaz,

26
Anche questo comando viene eseguito su RedShift, dove \d+non lo è. Questa è la risposta migliore IMO
New Alexandria

6
Meraviglioso, anche per Postgres aggiungerei anche il nome dello schema
ffflabs,

3
Questo elenca solo le colonne con informazioni minime. \ d + fornisce DDL completo per la tabella, inclusi: valori predefiniti, nullability, nextval, precisione, chiave primaria, chiavi esterne, indici, vincoli di controllo e FK da altre tabelle.
bradw2k,

70

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.


3
Questa query è meglio mostrata qui nota che suggeriscono anche "\ d table"
Flavien Volken,

3
Un vantaggio di questa soluzione è che format_type()includerà eventuali modificatori collegati al tipo, ad es numeric(6,2). mentre information_schema.columnsriporterà solo il tipo di base di numeric.
Eli Collins,

3
Come divido il tipo di dati dalla dimensione? dire | carattere variabile (50) | a 2 colonne: | carattere variabile | 50 |
Ivanceras,

51

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


36

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

Vedere la parte psql del manuale PostgreSQL per maggiori dettagli.


2
Inoltre, la selezione del database psql è \c databasenamepiuttosto che use databasename(per chi proviene da MySQL come me :-). Senza \c databasenameprima, \d tablenameproduce No relations found.messaggi e niente di più.
Ville,

27

Questa dovrebbe essere la soluzione:

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

21

Puoi fare degli \d *search pattern * asterischi per trovare le tabelle che corrispondono al modello di ricerca che ti interessa.


Questo era quello che stavo cercando: come descrivere un sottoinsieme di tabelle. Da notare, ho anche scoperto che se le tue tabelle hanno lettere maiuscole, la sintassi è \d *"<SubString>"*. Cioè, le doppie virgolette devono essere all'interno degli asterischi. Tuttavia, se vuoi solo l' elenco delle tabelle, allora vuoi usare\dt
Randall

questo corrisponde a sequenze, indici e tabelle

15

Oltre alla riga di comando che \d+ <table_name>hai già trovato, puoi anche utilizzare lo schema delle 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'

9
FROM info_schema.columnsnon ha funzionato per me che ho dovuto usare from information_schema.columns, non sono sicuro che sia un errore di battitura nella tua risposta o un problema di implementazione da parte mia.
user27874,

14

Utilizzare 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 colonna specifica che si sta cercando.


3
Ecco cosa dice questa risposta del 2008.
Quentin,

@ Quentin-C'è una differenza in entrambi ... la soluzione precedente del 2008 descrive column_name, data_type, character_ma maximum_length per l'intera tabella. Where as mine - la soluzione citata - mostra solo il tipo di dati della colonna dello schema. Esegui entrambi e controlla. Entrambi sono diversi. Tutte le soluzioni qui sono modi diversi per risolvere un problema. L'utente può utilizzarlo per diversi motivi
Mr. Tananki

14

Puoi usare questo:

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


7

In MySQL , DESCRIBE table_name


In PostgreSQL , \ d table_name


In alternativa, 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

7

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
;

4

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.

Aggiungere immagine

* Utilizzo di PG admin3


perché selezionare e aspettarsi che pgadmin rilevi il problema di ottenere i metadati non è "buona pratica"
Mickey Perlstein

2

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

\d+ tablename or \d tablename

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                        |

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

0

1) PostgreSQL DESCRIBE TABLE usando psql

Nello strumento da riga di comando psql, \ d table_name o \ d + table_name per trovare le informazioni sulle colonne di una tabella

2) PostgreSQL DESCRIBE TABLE usando information_schema

Istruzione SELECT per eseguire query su column_names, tipo di dati, lunghezza massima dei caratteri della tabella delle colonne nel database information_schema;

SELEZIONA COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH da INFORMATION_SCHEMA.COLUMNS dove table_name = 'tablename';

Per maggiori informazioni https://www.postgresqltutorial.com/postgresql-describe-table/


-1

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


-3

Ho elaborato il seguente script per ottenere lo schema della tabella.

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

||sembra essere qualcosa come un operatore di concatenazione (che unisce le stringhe insieme)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.