PostgreSQL "DESCRIBE TABLE"

¿Cómo se realiza el equivalente de Oracle DESCRIBE TABLEen PostgreSQL (usando el comando psql)?

Pruebe esto (en la psqlherramienta de línea de comandos):

\d+ tablename

Vea el manual para más información.

Además de la forma PostgreSQL (\ d 'algo' o \ dt 'tabla' o \ ds 'secuencia' y así sucesivamente)

La forma estándar de SQL, como se muestra aquí :

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

Es compatible con muchos motores db.

Si desea obtenerlo de la consulta en lugar de psql, puede consultar el esquema del catálogo. Aquí hay una consulta compleja que hace eso:

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 bastante complejo, pero le muestra el poder y la flexibilidad del catálogo del sistema PostgreSQL y debería ayudarlo a alcanzar el dominio de pg_catalog ;-). Asegúrese de cambiar los% s en la consulta. El primero es Schema y el segundo es el nombre de la tabla.

Puede hacerlo con un comando psql slash:

 \d myTable describe table

También funciona para otros objetos:

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

Fuente: faqs.org

El equivalente psql de DESCRIBE TABLEes \d table.

Consulte la parte psql del manual de PostgreSQL para obtener más detalles.

Esta debería ser la solución:

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

Puede hacer un \d *search pattern * asterisco para encontrar tablas que coincidan con el patrón de búsqueda que le interesa.

Además de la línea de comando \d+ <table_name>que ya encontró, también puede usar el esquema de información para buscar los datos de la columna, usando info_schema.columns

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

Use la siguiente instrucción SQL

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

Si reemplaza tbl_name y col_name, muestra el tipo de datos de la columna particular que está buscando.

Puedes usar esto:

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

Esta variación de la consulta (como se explica en otras respuestas) funcionó para mí.

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

Se describe aquí en detalle: http://www.postgresqltutorial.com/postgresql-describe-table/

En MySQL , DESCRIBE nombre_tabla

En PostgreSQL , \ d nombre_tabla

O puede usar este comando largo:

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

Para mejorar la consulta SQL de la otra respuesta (¡lo cual es genial!), Aquí hay una consulta revisada. También incluye nombres de restricciones, información de herencia y tipos de datos divididos en sus partes constituyentes (tipo, longitud, precisión, escala). También filtra las columnas que se han descartado (que todavía existen en la base de datos).

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
;

También puede verificar usando la consulta a continuación

Select * from schema_name.table_name limit 0;

Ejemplo: mi tabla tiene 2 columnas nombre y pwd. Dando captura de pantalla a continuación.

* Usando PG admin3

La mejor manera de describir una tabla como una columna, tipo, modificadores de columnas, 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) TABLA DE DESCRIBA PostgreSQL usando psql

En la herramienta de línea de comando psql, \ d table_name o \ d + table_name para encontrar la información en las columnas de una tabla

2) TABLA DE DESCRIBA PostgreSQL usando información_esquema

Instrucción SELECT para consultar los nombres de columna, tipo de datos, longitud máxima de caracteres de la tabla de columnas en la base de datos de información_esquema;

SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH de INFORMATION_SCHEMA.COLUMNS donde table_name = 'tablename';

Para más información https://www.postgresqltutorial.com/postgresql-describe-table/

/ dt es el comando que enumera todas las tablas presentes en una base de datos. usando el
comando / d y / d + podemos obtener los detalles de una tabla. La sintaxis será como
* / d nombre_tabla (o) \ d + nombre_tabla

Desarrollé el siguiente script para obtener el esquema de la tabla.

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