PostgreSQL "TABELLE BESCHREIBEN"

Wie führen Sie das Äquivalent von Oracle DESCRIBE TABLEin PostgreSQL aus (mit dem Befehl psql)?

Versuchen Sie dies (im psqlBefehlszeilentool):

\d+ tablename

Weitere Informationen finden Sie im Handbuch .

Zusätzlich zum PostgreSQL-Weg (\ d 'etwas' oder \ dt 'Tabelle' oder \ ds 'Sequenz' und so weiter)

Der SQL-Standardweg, wie hier gezeigt :

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

Es wird von vielen DB-Engines unterstützt.

Wenn Sie es von der Abfrage anstelle von psql erhalten möchten, können Sie das Katalogschema abfragen. Hier ist eine komplexe Abfrage, die das tut:

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
;

Es ist ziemlich komplex, aber es zeigt Ihnen die Leistungsfähigkeit und Flexibilität des PostgreSQL-Systemkatalogs und sollte Sie auf den Weg zur pg_catalog-Meisterschaft bringen ;-). Stellen Sie sicher, dass Sie die% s in der Abfrage ändern. Das erste ist Schema und das zweite ist der Tabellenname.

Sie können dies mit einem psql-Schrägstrich tun:

 \d myTable describe table

Es funktioniert auch für andere Objekte:

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

Quelle: faqs.org

Das psql-Äquivalent von DESCRIBE TABLEist \d table.

Weitere Informationen finden Sie im psql-Teil des PostgreSQL-Handbuchs.

Dies sollte die Lösung sein:

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

Sie können ein \d *search pattern * Sternchen verwenden , um Tabellen zu finden, die dem Suchmuster entsprechen, an dem Sie interessiert sind.

Zusätzlich zu der \d+ <table_name>bereits gefundenen Befehlszeile können Sie auch das Informationsschema verwenden, um die Spaltendaten mithilfe von info_schema.columns nachzuschlagen

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

Verwenden Sie die folgende SQL-Anweisung

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

Wenn Sie tbl_name und col_name ersetzen, wird der Datentyp der jeweiligen Spalte angezeigt, nach der Sie suchen.

Sie können dies verwenden:

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

Diese Variante der Abfrage (wie in anderen Antworten erläutert) hat bei mir funktioniert.

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

Es wird hier ausführlich beschrieben: http://www.postgresqltutorial.com/postgresql-describe-table/

Beschreiben Sie in MySQL den Tabellennamen DESCRIBE

In PostgreSQL \ d Tabellenname

Oder Sie können diesen langen Befehl verwenden:

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

Hier ist eine überarbeitete Abfrage, um die SQL-Abfrage der anderen Antwort zu verbessern (was großartig ist!). Es enthält auch Einschränkungsnamen, Vererbungsinformationen und Datentypen, die in die Bestandteile (Typ, Länge, Genauigkeit, Skalierung) unterteilt sind. Es werden auch Spalten herausgefiltert, die gelöscht wurden (die noch in der Datenbank vorhanden sind).

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
;

Sie können dies auch mit der folgenden Abfrage überprüfen

Select * from schema_name.table_name limit 0;

Beispiel: Meine Tabelle hat 2 Spaltennamen und pwd. Screenshot unten geben.

* Verwenden von PG admin3

Der beste Weg, um eine Tabelle wie eine Spalte, einen Typ, Modifikatoren von Spalten usw. zu beschreiben.

\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 mit psql

Im psql-Befehlszeilentool \ d Tabellenname oder \ d + Tabellenname , um die Informationen zu den Spalten einer Tabelle zu finden

2) PostgreSQL DESCRIBE TABLE mit information_schema

SELECT-Anweisung zum Abfragen der Spaltennamen, des Datentyps und der maximalen Zeichenlänge der Spaltentabelle in der Datenbank information_schema.

SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH aus INFORMATION_SCHEMA.COLUMNS wobei table_name = 'tablename';

Weitere Informationen finden Sie unter https://www.postgresqltutorial.com/postgresql-describe-table/

/ dt ist der Befehl, der alle in einer Datenbank vorhandenen Tabellen auflistet. Mit dem
Befehl / d und / d + können wir die Details einer Tabelle abrufen. Die Systemsteuer lautet
* / d Tabellenname (oder) \ d + Tabellenname

Ich habe das folgende Skript für das Abrufen des Tabellenschemas ausgearbeitet.

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