PostgreSQL “DESCRIVERE TABELLA”

Come eseguire l’equivalente di Oracle DESCRIBE TABLE in PostgreSQL (utilizzando il comando psql)?

 

19 Replies
  1. 2615

    Provare questo (in psql strumento da riga di comando):

    \d+ tablename

    Vedere il manuale per ulteriori info.

    • Mi aveva inizialmente accettato devinmoore la risposta ma questa mi piace molto di meglio. Non solo descrivere il tavolo, ma si mostra anche i metadati, ad esempio descrizioni di colonna e se ci sono Oid.
    • Il + è davvero frizione, come PostgresSQL 9 dà solo la descrizione approfondita di vista quando si esegue \d+ table_name, piuttosto che il semplice \d table_name
    • \d non funziona quando si richiama in PosgreSQL 9.1 attraverso pgAdmin, Vinko la risposta di seguito è applicabile a più casi
    • psql -E è utile per raggiungere l’sql che implementa \d+ e simili (per l’uso al di fuori del psql prompt)
    • Nota: Questo funziona solo da riga di comando psql client. Sotto il cofano, si esegue una query per ottenere le informazioni dal server, come illustrato nella risposta qui sotto.
    • Errore: “non è stata trovata alcuna relazione denominata”. Questo significa che è necessario per avvolgere il vostro tavolo un nome tra virgolette doppie. A quanto pare, postgres abbassare un caso il nome della tabella senza di loro e, pertanto, non trovare il vostro tavolo. Spero che questo aiuta chiunque viene qui e ha questo problema. 🙂
    • Chi si avvicinò con un CLI interfaccia che rende una lettera di comandi che iniziano con la stessa lettera, come dpor o dcancellazione non dovrebbe essere progettazione di basi di dati.
    • il comando inizia con ‘\’, non e ‘d’.
    • Questo è difficile da ricordare, mantenere confuding \dt (elenco delle tabelle in un database) con \d+ tablename (descrivere una tabella).
    • Ho sempre venire qui, e non ricordo la sintassi :D… questa è la 3 ° volta in un mese 😀

  2. 673

    Oltre a PostgreSQL modo (\d ‘qualcosa’ o \dt ‘tabella’ o \ds ‘sequenza’ e così via)

    Standard SQL modo, 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.

    • selezionare column_name,data_type,character_maximum_length da INFORMATION_SCHEMA.COLONNE dove table_name = ‘tabella’;
    • Questo è più utile che \d quando sei bloccato con un pre-8.4 psql e un post-8.4 server \d comando è incompatibile.
    • Anche questo comando viene eseguito contro il RedShift, dove \d+ non. Questa è la risposta migliore IMO
    • Meraviglioso, sebbene per postgres mi piacerebbe aggiungere il nome dello schema troppo
    • \d \d+ non funzionano da Navicat. Questo piccolo query è abbastanza buono! Questa sarebbe stata la risposta!
    • Questo funziona su AWS redshift come bene.
    • Vorrei aggiungere ORDER BY ordinal_position per renderlo ancora migliore.
    • aggiornamento a @NewAlexandria : \d+ opere in redshift ora
    • Questo elenca solo le colonne con le informazioni minime. \d+ dà piena DDL per la tabella di cui: valori di default, il supporto di valori null, nextval, la precisione, la chiave primaria, chiavi esterne, indici, vincoli check, e FK da altre tabelle.
    • Hai provato a SELEZIONARE *?
    • Le ‘colonne’ la tabella non sia in possesso di informazioni su cose come chiave primaria, chiavi esterne, indici, vincoli check. In un progetto ho lasciato join ‘colonne’ e ‘key_column_usage’ e ‘table_constraints’ a raccogliere PK e FK vincoli. Tutte le informazioni di cui è in tale schema di sicuro.

  3. 65

    Se si desidera ottenere dalla query invece di psql, è possibile interrogare il catalogo schema. Ecco una query complessa che 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
    ;

    È abbastanza complesso, ma non mostra la potenza e la flessibilità del sistema di PostgreSQL catalogo e si dovrebbe ottenere sul vostro modo di pg_catalog padronanza ;-). Assicurarsi di modificare il %s nella query. Il primo è lo Schema e il secondo è il nome della tabella.

    • Questa query è rivelato meglio di qui nota che essi suggeriscono “\d” tabella di troppo
    • Un vantaggio di questa soluzione è che format_type() comprendono tutti i modificatori collegata al tipo, ad esempio numeric(6,2); che information_schema.columns segnala il tipo di base di numeric.
    • Come faccio a dividere il tipo di dati da dimensioni? dire | character varying(50) | 2 colonne: | character varying | 50 |
  4. 48

    Si può fare con psql barra di comando:

     \d myTable describe table

    Funziona anche per altri oggetti:

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

    Fonte: faqs.org

  5. 35

    Il psql equivalente di DESCRIBE TABLE è \d table.

    Vedere il psql porzione di PostgreSQL manuale per ulteriori dettagli.

    • Inoltre, psql database di selezione è \c databasename piuttosto che use databasename (per chi proviene da MySQL come me :-). Senza \c databasename prima, \d tablename produce No relations found. messaggio e niente di più.
  6. 21

    Si può fare un \d *search pattern * con asterischi per trovare tabelle che corrispondono al criterio di ricerca a cui sei interessato.

    • Questo era quello che stavo cercando – come descrivere un sottoinsieme delle tabelle. Di nota, ho anche scoperto che se le tabelle sono in maiuscolo, la sintassi è \d *"<SubString>"*. Che è, le virgolette devono essere all’interno di gli asterischi. Anche se, se si desidera solo i elenco delle tabelle che si desidera utilizzare \dt
    • questo corrisponde sequenze e gli indici e le tabelle
  7. 14

    In aggiunta alla linea di comando \d+ <table_name> che hai già trovato, si potrebbe anche usare il informazioni-schema per cercare la colonna di dati, utilizzando info_schema.colonne

    SELECT *
    FROM info_schema.columns
    WHERE table_schema = 'your_schema'
    AND table_name   = 'your_table'
    • FROM info_schema.columns non ha funzionato per me, ho dovuto usare from information_schema.columns, non so se è un errore di battitura nella tua risposta o qualche problema di implementazione alla mia fine.
  8. 13

    È possibile utilizzare questo :

    SELECT attname 
    FROM pg_attribute,pg_class 
    WHERE attrelid=pg_class.oid 
    AND relname='TableName' 
    AND attstattarget <>0; 
    • Questo funziona anche per le tabelle temporanee.
  9. 12

    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, visualizza il tipo di dati di una particolare colonna che cercate.

    • Che cosa questa risposta dal 2008 dice.
    • è la differenza sia di loro..sopra 2008 Soluzione descrive column_name, data_type, character_maximum_length per l’intera tabella. Dove come la mia – la citata soluzione – mostra solo il tipo di dati della colonna dello schema. Eseguire entrambi e di controllo. Entrambi sono diverse. Tutte le soluzioni qui ci sono diversi modi per risolvere un problema. L’utente può utilizzare questo per diversi motivi
  10. 8

    Questa dovrebbe essere la soluzione:

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

    In MySQL , DESCRIVERE table_name


    In PostgreSQL , \d table_name


    O , è possibile utilizzare questo comando lunga:

    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
  12. 5

    Per migliorare l’altra risposta della query SQL (che è grande!), qui è la revisione di una query. Esso comprende anche i nomi di vincolo, eredità delle informazioni, e i tipi di dati suddivisi in esso elementi (tipo, durata, precisione, scala). È anche filtra le colonne che sono state eliminate (che ancora esistono 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
    ;
  13. 3

    È possibile anche verificare utilizzando seguito query

    Select * from schema_name.table_name limit 0;

    Expmple : tabella con 2 colonne nome e pwd. Mi screenshot qui sotto.

    PostgreSQL “DESCRIVERE TABELLA”

    *Utilizzo di PG admin3

    • Perché questo downvoted?
    • perché la selezione di e in attesa del pgadmin per pick-up il ristagno di raggiungere la meta dati non è una “best practice”
  14. 2

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

    \d+ tablename or \d tablename
    • Questo non aggiunge nulla alla accettati risposta
  15. 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                        |
    • Questo non aggiunge nulla alla accettati risposta
  16. 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
  17. -2

    /dt è il command che elenca tutte le tabelle presenti in un database. utilizzando

    comando /d e /d+ siamo in grado di ottenere i dettagli di una tabella. Il sysntax sarà come

    * /d nome_tabella (o) \d+ table_name

    • Questo non aggiunge nulla alla accettati risposta
  18. -4

    Ho lavorato il seguente script per ottenere schema di 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 di simile a un operatore di concatenazione (unione di stringhe insieme)

Lascia un commento