PostgreSQL: Tabellen in PostgreSQL anzeigen

Was entspricht show tables(von MySQL) in PostgreSQL?

Über die psqlBefehlszeilenschnittstelle

Wählen Sie zunächst Ihre Datenbank aus

\c database_name

Dies zeigt dann alle Tabellen im aktuellen Schema:

\dt

Programmatisch (oder psqlnatürlich auch über die Schnittstelle):

SELECT * FROM pg_catalog.pg_tables;

Die Systemtabellen befinden sich in der pg_catalogDatenbank.

Als Superuser anmelden:

sudo -u postgres psql

Sie können alle Datenbanken und Benutzer nach \lBefehl auflisten (andere Befehle nach auflisten \?).

Nun , wenn Sie andere Datenbanken sehen möchten , können Sie Benutzer / Datenbank ändern , indem Sie \cwie Befehl \c template1, \c postgres postgresund die Verwendung \d, \dtoder \dSum zu sehen , Tabellen / Ansichten / etc.

(Zur Vollständigkeit)

Sie können auch das Informationsschema (SQL-Standard) abfragen :

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

Sie können das interaktive Terminal Psql von PostgreSQL verwenden, um Tabellen in PostgreSQL anzuzeigen.

1. Starten Sie Psql

Normalerweise können Sie den folgenden Befehl ausführen, um psql einzugeben:

psql DBNAME USERNAME

Zum Beispiel, psql template1 postgres

Eine Situation, die Sie möglicherweise haben, ist: Angenommen, Sie melden sich als root an und erinnern sich nicht an den Datenbanknamen. Sie können Psql einfach zuerst eingeben, indem Sie Folgendes ausführen:

sudo -u postgres psql

In einigen Systemen ist der Befehl sudo nicht verfügbar. Sie können stattdessen einen der folgenden Befehle ausführen:

psql -U postgres
psql --username=postgres

2. Tabellen anzeigen

Jetzt können Sie in Psql Befehle ausführen wie:

1. \? Listen Sie alle Befehle auf
2. \l Datenbanken auflisten
3. \conninfo Informationen zur aktuellen Verbindung anzeigen
4. \c [DBNAME] Verbindung zu neuer Datenbank herstellen, z. \c template1
5. \dt Listet Tabellen des öffentlichen Schemas auf
6. \dt <schema-name>.* Listen Sie Tabellen bestimmter Schemata auf, z. \dt public.*
7. \dt *.* Liste Tabellen aller Schemata
8. Dann können Sie SQL-Anweisungen ausführen, z. B. SELECT * FROM my_table;(Hinweis: Eine Anweisung muss mit einem Semikolon abgeschlossen werden. ;)
9. \q Beenden Sie psql

1. Erste Anmeldung als Postgres-Benutzer:

   sudo su - postgres

2. Verbindung zur gewünschten Datenbank herstellen: psql -d databaseName

3. \dt würde die Liste aller Tabellen in der Datenbank zurückgeben, mit der Sie verbunden sind.

Wenn Sie psql mit dem Flag -E ausführen, wird die Abfrage wiederholt, die intern zum Implementieren von \ dt und ähnlichem verwendet wird:

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

Melden Sie sich als Superuser an, damit Sie alle Datenbanken und ihre Schemata überprüfen können: -

sudo su - postgres

Dann können wir mit dem folgenden Befehl zur postgresql-Shell gelangen: -

psql

Sie können jetzt die gesamte Datenbankliste mit dem folgenden Befehl überprüfen: -

\l

Wenn Sie auch die Größe der Datenbanken überprüfen möchten, verwenden Sie: -

\l+

Drücken Sie q, um zurückzukehren.

Sobald Sie Ihre Datenbank gefunden haben, können Sie mit dem folgenden Befehl eine Verbindung zu dieser Datenbank herstellen: -

\c database_name

Sobald die Verbindung hergestellt ist, können Sie die Datenbanktabellen oder das Schema überprüfen, indem Sie: -

\d

Um zur Shell zurückzukehren, verwenden Sie: -

q

Um die Details einer bestimmten Tabelle weiter zu sehen, verwenden Sie: -

\d table_name

Um zu postgresql_shell zurückzukehren, drücken Sie \q.

Und um zum Terminal zurückzukehren, drücken Sie exit.

Wenn Sie nur die Liste der von Ihnen erstellten Tabellen anzeigen möchten, können Sie nur sagen:

\dt

Wir haben aber auch welche, mit PATTERNdenen Sie die anzuzeigenden Tabellen anpassen können. Um alle einschließlich pg_catalogSchema anzuzeigen, können Sie hinzufügen *.

\dt *

Wenn Sie tun: \?

\ dt [S +] [MUSTER] Listentabellen

Verwenden Sie nur eine Tabelle sehen

=> \dt

Wenn Sie Schematabellen sehen möchten

=>\dt+

Wenn Sie bestimmte Schematabellen anzeigen möchten

=>\dt schema_name.* 

Stellen Sie zunächst mit dem folgenden Befehl eine Verbindung zur Datenbank her

\c database_name

Und Sie werden diese Nachricht sehen - You are now connected to database database_name. Und sie führen den folgenden Befehl aus

SELECT * FROM table_name;

In Datenbankname und Tabellenname aktualisieren Sie einfach mit Ihrem Datenbank- und Tabellennamen

Wenn Sie pgAdmin4 in PostgreSQL verwenden, können Sie damit die Tabellen in Ihrer Datenbank anzeigen:

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

Beachten Sie, dass \dtnur Tabellen im öffentlichen Schema der von Ihnen verwendeten Datenbank aufgelistet werden. Ich mag es, meine Tabellen in separaten Schemata zu halten, daher hat die akzeptierte Antwort bei mir nicht funktioniert.

Um alle Tabellen innerhalb eines bestimmten Schemas aufzulisten , musste ich:

1) Stellen Sie eine Verbindung zur gewünschten Datenbank her:

psql mydb

2) Geben Sie den Schemanamen an, für den Tabellen nach dem \dtBefehl angezeigt werden sollen, wie folgt:

\dt myschema.*

Dies zeigt mir die Ergebnisse, die mich interessieren:

               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 (kein * erforderlich) - listet alle Tabellen für eine vorhandene Datenbank auf, mit der Sie bereits verbunden sind. Auch nützlich zu beachten:

\ d [Tabellenname] - Zeigt alle Spalten für eine bestimmte Tabelle an, einschließlich Typinformationen, Referenzen und Schlüsseleinschränkungen.

Sie können die Tabellen in der aktuellen Datenbank mit auflisten \dt .

Fwiw \d tablenamezeigt Details zu der angegebenen Tabelle an, ähnlich wie show columns from tablenamein MySQL, jedoch mit etwas mehr Informationen.

Verwenden von psql : \ dt

Oder:

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

Zunächst müssen Sie sich wie mit Ihrer Datenbank verbinden

Meine Datenbank ist Ubuntu

Verwenden Sie diesen Befehl, um eine Verbindung herzustellen

 \c ubuntu

Diese Meldung wird angezeigt

"Sie sind jetzt als Benutzer" postgres "mit der Datenbank" ubuntu "verbunden."

Jetzt

Führen Sie diesen Befehl aus, um alle darin enthaltenen Tabellen anzuzeigen

\d+

Der einfachste Weg, alle Tabellen in der Befehlszeile aufzulisten, ist für meinen Geschmack:

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

Fügen Sie für eine bestimmte Datenbank einfach den Datenbanknamen hinzu:

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

Es funktioniert sowohl unter Linux als auch unter Windows.

als schneller Oneliner

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

oder wenn Sie einen viel klareren json output multi-liner bevorzugen:

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 listet Tabellen auf und "\ pset pager off" zeigt sie im selben Fenster an, ohne zu einer separaten zu wechseln. Lieben Sie dieses Merkmal zu Tode in dbshell.

Führen Sie aus, um fremde Tabellen in psql anzuzeigen \dE

Geben Sie zunächst ein, welche Datenbank Sie verbinden müssen

\c database_name

Dies zeigt dann alle Tabellen im aktuellen Schema:

\dt

Zuerst können Sie sich mit der postgrre.app auf dem Mac oder mit postico mit Ihrer postgres-Datenbank verbinden. Führen Sie den folgenden Befehl aus:

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

Wenn Sie dann Ihr Passwort eingeben, sollte dies den Zugriff auf Ihre Datenbank ermöglichen