PostgreSQL: Mostrar tablas en PostgreSQL

¿Cuál es el equivalente a show tables(de MySQL) en PostgreSQL?

Desde la psqlinterfaz de línea de comando,

Primero, elige tu base de datos

\c database_name

Luego, esto muestra todas las tablas en el esquema actual:

\dt

Programáticamente (o desde la psqlinterfaz también, por supuesto):

SELECT * FROM pg_catalog.pg_tables;

Las tablas del sistema viven en la pg_catalogbase de datos.

Inicie sesión como superusuario:

sudo -u postgres psql

Puede enumerar todas las bases de datos y usuarios por \lcomando (enumerar otros comandos por \?).

Ahora, si desea ver otras bases de datos, puede cambiar el usuario / base de datos mediante un \ccomando como \c template1, \c postgres postgresy usar \d, \dto \dSpara ver tablas / vistas / etc.

(Por completitud)

También puede consultar el esquema de información (estándar SQL) :

SELECT
    table_schema || '.' || table_name
FROM
    information_schema.tables
WHERE
    table_type = 'BASE TABLE'
AND
    table_schema NOT IN ('pg_catalog', 'information_schema');

Puede usar el terminal interactivo Psql de PostgreSQL para mostrar tablas en PostgreSQL.

1. Inicie Psql

Por lo general, puede ejecutar el siguiente comando para ingresar a psql:

psql DBNAME USERNAME

Por ejemplo, psql template1 postgres

Una situación que puede tener es: suponga que inicia sesión como root y no recuerda el nombre de la base de datos. Puede ingresar primero en Psql ejecutando:

sudo -u postgres psql

En algunos sistemas, el comando sudo no está disponible, en su lugar puede ejecutar cualquiera de los siguientes comandos:

psql -U postgres
psql --username=postgres

2. Mostrar tablas

Ahora en Psql puede ejecutar comandos como:

1. \? enumerar todos los comandos
2. \l lista de bases de datos
3. \conninfo mostrar información sobre la conexión actual
4. \c [DBNAME] conectarse a una nueva base de datos, por ejemplo, \c template1
5. \dt listar tablas del esquema público
6. \dt <schema-name>.* enumerar tablas de cierto esquema, por ejemplo, \dt public.*
7. \dt *.* listar tablas de todos los esquemas
8. Luego puede ejecutar sentencias SQL, por ejemplo, SELECT * FROM my_table;(Nota: una sentencia debe terminar con punto y coma ;)
9. \q salir de psql

1. Primer inicio de sesión como usuario de postgres:

   sudo su - postgres

2. conectarse a la base de datos requerida: psql -d databaseName

3. \dt devolvería la lista de todas las tablas de la base de datos a la que está conectado.

La ejecución de psql con el indicador -E hará eco de la consulta utilizada internamente para implementar \ dt y similares:

sudo -u postgres psql -E

postgres=# \dt       
********* QUERY **********
SELECT n.nspname as "Schema",
c.relname as "Name", 
CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 's' THEN 'special' END as "Type",
pg_catalog.pg_get_userbyid(c.relowner) as "Owner"
FROM pg_catalog.pg_class c
    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
WHERE c.relkind IN ('r','')
    AND n.nspname <> 'pg_catalog'
    AND n.nspname <> 'information_schema'
    AND n.nspname !~ '^pg_toast'
AND pg_catalog.pg_table_is_visible(c.oid)
ORDER BY 1,2;        
**************************

Inicie sesión como superusuario para que pueda verificar todas las bases de datos y sus esquemas: -

sudo su - postgres

Entonces podemos llegar al shell postgresql usando el siguiente comando: -

psql

Ahora puede verificar todas las listas de bases de datos utilizando el siguiente comando: -

\l

Si desea verificar los tamaños de las bases de datos, utilice: -

\l+

Presione qpara regresar.

Una vez que haya encontrado su base de datos ahora puede conectarse a esa base de datos utilizando el siguiente comando: -

\c database_name

Una vez conectado, puede verificar las tablas de la base de datos o el esquema: -

\d

Ahora para volver al uso de la shell: -

q

Ahora para ver más detalles sobre el uso de una tabla determinada: -

\d table_name

Para volver a postgresql_shell presione \q.

Y para volver a la terminal presione exit.

Si solo desea ver la lista de tablas que ha creado, solo puede decir:

\dt

Pero también tenemos PATTERNcuáles lo ayudarán a personalizar qué tablas mostrar. Para mostrar todo, incluido el pg_catalogesquema, puede agregar *.

\dt *

Si lo haces: \?

\ dt [S +] [PATRÓN] tablas de lista

use solo ver tablas

=> \dt

si quieres ver tablas de esquemas

=>\dt+

si quieres ver tablas de esquemas específicos

=>\dt schema_name.* 

Primero conéctese con la base de datos usando el siguiente comando

\c database_name

Y verá este mensaje - You are now connected to database database_name. Y ellos ejecutan el siguiente comando

SELECT * FROM table_name;

En database_name y table_name solo actualice con su base de datos y nombre de tabla

Si está usando pgAdmin4 en PostgreSQL, puede usar esto para mostrar las tablas en su base de datos:

select * from information_schema.tables where table_schema='public';

Tenga en cuenta que \dtsolo enumerará las tablas en el esquema público de la base de datos que está utilizando. Me gusta mantener mis tablas en esquemas separados, por lo que la respuesta aceptada no funcionó para mí.

Para enumerar todas las tablas dentro de un esquema específico , necesitaba:

1) Conéctese a la base de datos deseada:

psql mydb

2) Especifique el nombre del esquema para el que quiero ver las tablas después del \dtcomando, así:

\dt myschema.*

Esto me muestra los resultados que me interesan:

               List of relations
 Schema   |       Name      | Type  |  Owner   
----------+-----------------+-------+----------
 myschema | users           | table | postgres
 myschema | activity        | table | postgres
 myschema | roles           | table | postgres

select 
  * 
from 
  pg_catalog.pg_tables 
where 
  schemaname != 'information_schema' 
  and schemaname != 'pg_catalog';

\ dt (no * requerido): enumerará todas las tablas de una base de datos existente a la que ya está conectado. También es útil tener en cuenta:

\ d [nombre_tabla]: mostrará todas las columnas de una tabla determinada, incluida la información de tipo, referencias y restricciones de clave.

Puede enumerar las tablas en la base de datos actual con \dt .

Fwiw, \d tablenamemostrará detalles sobre la tabla dada, algo así como show columns from tablenameen MySQL, pero con un poco más de información.

Usando psql : \ dt

O:

SELECT c.relname AS Tables_in FROM pg_catalog.pg_class c
        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
WHERE pg_catalog.pg_table_is_visible(c.oid)
        AND c.relkind = 'r'
        AND relname NOT LIKE 'pg_%'
ORDER BY 1

En primer lugar, debe conectarse con su base de datos como

mi base de datos es ubuntu

usa este comando para conectarte

 \c ubuntu

Este mensaje mostrará

"Ahora está conectado a la base de datos" ubuntu "como usuario" postgres "."

Ahora

Ejecute este comando para mostrar todas las tablas en él

\d+

La forma más sencilla de enumerar todas las tablas en la línea de comandos es, para mi gusto:

psql -a -U <user> -p <port> -h <server> -c "\dt"

Para una base de datos dada, simplemente agregue el nombre de la base de datos:

psql -a -U <user> -p <port> -h <server> -c "\dt" <database_name>

Funciona tanto en Linux como en Windows.

como una línea rápida

# just list all the postgres tables sorted in the terminal
db='my_db_name'
clear;psql -d $db -t -c '\dt'|cut -c 11-|perl -ne 's/^([a-z_0-9]*)( )(.*)/$1/; print'

o si prefieres una salida json mucho más clara:

IFS='' read -r -d '' sql_code <<"EOF_CODE"
    select array_to_json(array_agg(row_to_json(t))) from (
        SELECT table_catalog,table_schema,table_name 
        FROM information_schema.tables
        ORDER BY table_schema,table_name ) t
EOF_CODE
psql -d postgres -t -q -c "$sql_code"|jq

\ dt mostrará una lista de tablas y "\ pset pager off" las muestra en la misma ventana, sin cambiar a una separada. Amo esa característica hasta la muerte en dbshell.

Para ver tablas externas en psql, ejecute \dE

Primero, ingrese a qué base de datos necesita conectarse

\c database_name

Luego, esto muestra todas las tablas en el esquema actual:

\dt

Primero puede conectarse con su base de datos postgres usando postgre.app en mac o usando postico. Ejecute el siguiente comando:

psql -h localhost -p port_number -d database_name -U user_name -W

luego ingrese su contraseña, esto debería dar acceso a su base de datos