Wie finden Sie die Festplattengröße einer Postgres / PostgreSQL-Tabelle und ihrer Indizes?

Ich komme von Oracle zu Postgres und suche nach einer Möglichkeit, die Tabellen- und Indexgröße in Bezug auf bytes/MB/GB/etcoder noch besser die Größe für alle Tabellen zu ermitteln. In Oracle hatte ich eine böse lange Abfrage, die user_lobs und user_segments untersuchte, um eine Antwort zurückzugeben.

Ich information_schemagehe davon aus, dass ich in Postgres etwas in den Tabellen verwenden kann, aber ich sehe nicht, wo.

Probieren Sie die Funktionen für die Datenbankobjektgröße aus . Ein Beispiel:

SELECT pg_size_pretty(pg_total_relation_size('"<schema>"."<table>"'));

Für alle Tabellen gilt Folgendes:

SELECT
    table_schema || '.' || table_name AS table_full_name,
    pg_size_pretty(pg_total_relation_size('"' || table_schema || '"."' || table_name || '"')) AS size
FROM information_schema.tables
ORDER BY
    pg_total_relation_size('"' || table_schema || '"."' || table_name || '"') DESC;

Bearbeiten: Hier ist die von @phord übermittelte Abfrage.

SELECT
    table_name,
    pg_size_pretty(table_size) AS table_size,
    pg_size_pretty(indexes_size) AS indexes_size,
    pg_size_pretty(total_size) AS total_size
FROM (
    SELECT
        table_name,
        pg_table_size(table_name) AS table_size,
        pg_indexes_size(table_name) AS indexes_size,
        pg_total_relation_size(table_name) AS total_size
    FROM (
        SELECT ('"' || table_schema || '"."' || table_name || '"') AS table_name
        FROM information_schema.tables
    ) AS all_tables
    ORDER BY total_size DESC
) AS pretty_sizes;

Ich habe es leicht modifiziert pg_table_size(), um Metadaten einzuschließen und die Größen zu addieren.

Datenbankgrößen anzeigen:

\l+

z.B

=> \l+
 berbatik_prd_commerce    | berbatik_prd     | UTF8     | en_US.UTF-8 | en_US.UTF-8 |                       | 19 MB   | pg_default | 
 berbatik_stg_commerce    | berbatik_stg     | UTF8     | en_US.UTF-8 | en_US.UTF-8 |                       | 8633 kB | pg_default | 
 bursasajadah_prd         | bursasajadah_prd | UTF8     | en_US.UTF-8 | en_US.UTF-8 |                       | 1122 MB | pg_default | 

Tischgrößen anzeigen:

\d+

z.B

=> \d+
 public | tuneeca_prd | table | tomcat | 8192 bytes | 
 public | tuneeca_stg | table | tomcat | 1464 kB    | 

Funktioniert nur in psql.

(Zusammenfassung der Antwort von @ zkutch .)

Wenn der Datenbankname lautet snort, gibt der folgende Satz die Größe an:

psql -c "\l+ snort" | awk -F "|" '{print $7}'

Tyr this: (Indexgröße / Nutzungsstatistik)

SELECT
    t.tablename,
    indexname,
    c.reltuples AS num_rows,
    pg_size_pretty(pg_relation_size(quote_ident(t.tablename)::text)) AS table_size,
    pg_size_pretty(pg_relation_size(quote_ident(indexrelname)::text)) AS index_size,
    CASE WHEN indisunique THEN 'Y'
       ELSE 'N'
    END AS UNIQUE,
    idx_scan AS number_of_scans,
    idx_tup_read AS tuples_read,
    idx_tup_fetch AS tuples_fetched
FROM pg_tables t
LEFT OUTER JOIN pg_class c ON t.tablename=c.relname
LEFT OUTER JOIN
    ( SELECT c.relname AS ctablename, ipg.relname AS indexname, x.indnatts AS number_of_columns, idx_scan, idx_tup_read, idx_tup_fetch, indexrelname, indisunique FROM pg_index x
           JOIN pg_class c ON c.oid = x.indrelid
           JOIN pg_class ipg ON ipg.oid = x.indexrelid
           JOIN pg_stat_all_indexes psai ON x.indexrelid = psai.indexrelid )
    AS foo
    ON t.tablename = foo.ctablename
WHERE t.schemaname='public'
ORDER BY 1,2;

PostgreSQL-Tabellen bestehen aus drei Komponenten: der Tabelle selbst, etwaigen Indizes und möglicherweise TOAST-Daten. Unter http://wiki.postgresql.org/wiki/Disk_Usage finden Sie einige Beispiele, wie Sie die verfügbaren Informationen auf verschiedene Arten verschieben und würfeln können

Nur zur Information, ich habe die hervorragende Antwort von @aib erhalten und sie ein wenig geändert für:

• Nur Tabellen aus dem "öffentlichen" Schema abrufen
• Zeigen Sie auch materialisierte Ansichtsdaten und Indexgröße an

In der materialisierten Ansicht können wir den Index verwenden, um materialisierte Ansichten gleichzeitig zu aktualisieren, sodass Sie sie während der Aktualisierung verwenden können.

Nun, meine Anfrage lautet wie folgt:

SELECT
    table_name,
    pg_size_pretty(table_size) AS table_size,
    pg_size_pretty(indexes_size) AS indexes_size,
    pg_size_pretty(total_size) AS total_size
FROM (
    SELECT
        table_name,
        pg_table_size(table_name) AS table_size,
        pg_indexes_size(table_name) AS indexes_size,
        pg_total_relation_size(table_name) AS total_size
    FROM (
        -- tables from 'public'
        SELECT table_name
        FROM information_schema.tables
        where table_schema = 'public' and table_type = 'BASE TABLE'
        union
        -- materialized views
        SELECT oid::regclass::text as table_name
        FROM pg_class
        WHERE relkind = 'm'
        order by table_name
    ) AS all_tables
    -- ORDER BY total_size DESC
    order by table_name
) AS pretty_sizes

Die folgende Abfrage wird Ihnen dienen

SELECT nspname || '.' || relname AS "relation",
  pg_size_pretty(pg_total_relation_size(C.oid)) AS "total_size"
FROM pg_class C
LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
WHERE nspname NOT IN ('pg_catalog', 'information_schema')
  AND C.relkind <> 'i'
  AND nspname !~ '^pg_toast'
ORDER BY pg_total_relation_size(C.oid) DESC
LIMIT 20;

Siehe diesen Link: https://wiki.postgresql.org/wiki/Disk_Usage

Überprüfen Sie dieses Wiki. https://wiki.postgresql.org/wiki/Disk_Usage

SELECT *, pg_size_pretty (total_bytes) AS total
    , pg_size_pretty (index_bytes) AS INDEX
    , pg_size_pretty (toast_bytes) AS-Toast
    , pg_size_pretty (table_bytes) AS TABLE
  VON (
  SELECT *, total_bytes-index_bytes-COALESCE (toast_bytes, 0) AS table_bytes FROM (
      SELECT c.oid, nspname AS table_schema, relname AS TABLE_NAME
              , c.reltuples AS row_estimate
              , pg_total_relation_size (c.oid) AS total_bytes
              , pg_indexes_size (c.oid) AS index_bytes
              , pg_total_relation_size (reltoastrelid) AS toast_bytes
          FROM pg_class c
          LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
          WO relkind = 'r'
  ) ein
) ein

Versuchen Sie dieses Skript, um alle Tabellengrößen zu finden:

SELECT
    table_schema || '.' || table_name AS TableName,
    pg_size_pretty(pg_total_relation_size('"' || table_schema || '"."' || table_name || '"')) AS TableSize
FROM information_schema.tables
ORDER BY
    pg_total_relation_size('"' || table_schema || '"."' || table_name || '"') DESC

Weitere Skripts für die Größe in PostgreSQL finden Sie unter folgender URL: http://www.dbrnd.com/2015/05/how-to-find-size-of-database-and-table-in-postgresql/