PostgreSQL: mostra le tabelle in PostgreSQL

Qual è l'equivalente di show tables(da MySQL) in PostgreSQL?

Dall'interfaccia della psqlriga di comando,

Innanzitutto, scegli il tuo database

\c database_name

Quindi, questo mostra tutte le tabelle nello schema corrente:

\dt

Programmaticamente (o psqlanche dall'interfaccia, ovviamente):

SELECT * FROM pg_catalog.pg_tables;

Le tabelle di sistema vivono nel pg_catalogdatabase.

Accedi come superutente:

sudo -u postgres psql

È possibile elencare tutti i database e gli utenti per \lcomando (elencare altri comandi per \?).

Ora se vuoi vedere altri database puoi cambiare utente / database con \ccomandi come \c template1, \c postgres postgrese usare \d, \dto \dSper vedere tabelle / viste / ecc.

(Per completezza)

È inoltre possibile eseguire una query sullo schema di informazioni (standard SQL) :

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

È possibile utilizzare il terminale interattivo Psql di PostgreSQL per mostrare le tabelle in PostgreSQL.

1. Avviare Psql

Di solito è possibile eseguire il comando seguente per accedere a psql:

psql DBNAME USERNAME

Per esempio, psql template1 postgres

Una situazione che potresti avere è: supponi di aver effettuato l'accesso come root e non ricordi il nome del database. Puoi entrare per primo in Psql eseguendo:

sudo -u postgres psql

In alcuni sistemi, il comando sudo non è disponibile, puoi invece eseguire uno dei comandi seguenti:

psql -U postgres
psql --username=postgres

2. Mostra le tabelle

Ora in Psql puoi eseguire comandi come:

1. \? elenca tutti i comandi
2. \l elenca i database
3. \conninfo visualizzare informazioni sulla connessione corrente
4. \c [DBNAME] connettersi a un nuovo database, ad es. \c template1
5. \dt elenca le tabelle dello schema pubblico
6. \dt <schema-name>.* elenca le tabelle di determinati schemi, ad es. \dt public.*
7. \dt *.* elenca le tabelle di tutti gli schemi
8. Quindi è possibile eseguire istruzioni SQL, ad es. SELECT * FROM my_table;(Nota: un'istruzione deve essere terminata con punto e virgola ;)
9. \q uscire da psql

1. Primo accesso come utente postgres:

   sudo su - postgres

2. connettersi al db richiesto: psql -d databaseName

3. \dt restituirà l'elenco di tutte le tabelle nel database a cui sei connesso.

L'esecuzione di psql con il flag -E farà eco alla query utilizzata internamente per implementare \ dt e simili:

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

Accedi come superutente in modo da poter controllare tutti i database e i loro schemi: -

sudo su - postgres

Quindi possiamo arrivare alla shell postgresql usando il seguente comando: -

psql

Ora puoi controllare tutto l'elenco dei database usando il seguente comando: -

\l

Se si desidera verificare anche le dimensioni dei database, utilizzare: -

\l+

Premere qper tornare indietro.

Una volta trovato il database ora è possibile connettersi a quel database utilizzando il seguente comando: -

\c database_name

Una volta connesso è possibile controllare le tabelle o lo schema del database: -

\d

Ora per tornare alla shell usare: -

q

Ora per vedere ulteriormente i dettagli di un determinato tavolo usare: -

\d table_name

Per tornare a postgresql_shell premere \q.

E per tornare al terminale premere exit.

Se vuoi solo vedere l'elenco delle tabelle che hai creato, puoi solo dire:

\dt

Ma abbiamo anche quelli PATTERNche ti aiuteranno a personalizzare le tabelle da mostrare. Per mostrare tutto incluso pg_catalogSchema, puoi aggiungere *.

\dt *

Se fate: \?

\ dt [S +] [PATTERN] elenca le tabelle

usare solo vedere una tabella

=> \dt

se vuoi vedere le tabelle dello schema

=>\dt+

se vuoi vedere tabelle di schemi specifici

=>\dt schema_name.* 

Innanzitutto connettersi con il database utilizzando il seguente comando

\c database_name

E vedrai questo messaggio - You are now connected to database database_name. Ed eseguono il seguente comando

SELECT * FROM table_name;

In database_name e table_name basta aggiornare con il database e il nome della tabella

Se stai usando pgAdmin4 in PostgreSQL, puoi usarlo per mostrare le tabelle nel tuo database:

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

Si noti che \dtda solo elencherà le tabelle in schema pubblico del database che stai utilizzando. Mi piace mantenere i miei tavoli in schemi separati, quindi la risposta accettata non ha funzionato per me.

Per elencare tutte le tabelle all'interno di uno schema specifico , dovevo:

1) Connettiti al database desiderato:

psql mydb

2) Specificare il nome dello schema per cui voglio vedere le tabelle dopo il \dtcomando, in questo modo:

\dt myschema.*

Questo mi mostra i risultati che mi interessano:

               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 * richiesto) - elencherà tutte le tabelle per un database esistente a cui sei già connesso. Utile anche notare:

\ d [nome_tabella] - mostrerà tutte le colonne per una data tabella incluse informazioni sul tipo, riferimenti e vincoli chiave.

È possibile elencare le tabelle nel database corrente con \dt.

Fwiw, \d tablenamemostrerà i dettagli sulla tabella data, qualcosa come show columns from tablenamein MySQL, ma con un po 'più di informazioni.

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

Prima di tutto devi connetterti con il tuo database come

il mio database è ubuntu

usa questo comando per connetterti

 \c ubuntu

Questo messaggio mostrerà

"Ora sei connesso al database" ubuntu "come utente" postgres "."

Adesso

Esegui questo comando per mostrare tutte le tabelle al suo interno

\d+

Il modo più semplice per elencare tutte le tabelle dalla riga di comando è, per i miei gusti:

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

Per un dato database basta aggiungere il nome del database:

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

Funziona su Linux e Windows.

come oneliner veloce

# 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 se preferisci un multi-liner in uscita json molto più chiaro:

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 elencherà le tabelle e "\ pset pager off" le mostrerà nella stessa finestra, senza passare a un'altra. Adoro quella caratteristica fino alla morte in dbshell.

Per visualizzare le tabelle esterne in psql, eseguire \dE

Innanzitutto, inserisci il database che devi connettere

\c database_name

Quindi, questo mostra tutte le tabelle nello schema corrente:

\dt

Per prima cosa puoi connetterti con il tuo database postgres usando postgre.app su mac o usando postico. Esegui il seguente comando:

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

quindi inserisci la tua password, questo dovrebbe dare accesso al tuo database