Semplifica una query SQL Postgres per elencare le dimensioni di tabelle e indici?

Question

La seguente query SQL Postgres elencherà tutte le tabelle di tutti gli schemi e le loro dimensioni e dimensioni dell'indice. Se una tabella è solo una tabella indice, verrà mostrata come indice 100%.

SELECT schema, 
     name, 
     pg_size_pretty(CASE WHEN is_index THEN 0 ELSE s  END) AS size, 
     pg_size_pretty(CASE WHEN is_index THEN s ELSE st - s END) AS index, 
     CASE WHEN st = 0 THEN 0 
      WHEN is_index THEN 100 
          ELSE 100 - ((s*100)/st) END || '%' as ratio, 
     pg_size_pretty(st) as total 
    FROM (SELECT *, 
       st = s AS is_index 
      FROM (SELECT nspname as schema, 
         relname as name, 
         pg_relation_size(nspname || '.' || relname) as s, 
         pg_total_relation_size(nspname || '.' || relname) as st 
        FROM pg_class 
      JOIN pg_namespace ON (relnamespace = pg_namespace.oid)) AS p)               
    AS pp                 
ORDER BY st DESC LIMIT 30; 

vi darà i seguenti risultati:

schema   |   name   | size | index | ratio | total 
----------------+------------------------+---------+---------+-------+--------- 
public   | conf     | 4072 kB | 4360 kB | 52% | 8432 kB 
archive  | product_param   | 4048 kB | 3968 kB | 50% | 8016 kB             
public   | conf_pkey    | 0 bytes | 4320 kB | 100% | 4320 kB 
archive  | product_value   | 1568 kB | 1136 kB | 43% | 2704 kB 
public   | param_mapping   | 1472 kB | 832 kB | 37% | 2304 kB 
archive  | supplie_price   | 944 kB | 896 kB | 49% | 1840 kB 
public   | product_param_param_id | 0 bytes | 1552 kB | 100% | 1552 kB 
archive  | product_param_id  | 0 bytes | 1536 kB | 100% | 1536 kB 

Sono venuto a un punto in cui non riesco a vedere la foresta per tutti gli alberi, e sta cominciando a diventare un po 'ingombrante.

Mi chiedo se ci sia qualcosa che può essere semplificato o reso ridondante? Le colonne non devono necessariamente rimanere uguali se la query può essere resa molto più semplice.

Answer 1

ottengo risultati comparabili (con formattazione diversa) con questa query:

select 
    nspname as schema, 
    relname as name, 
    pg_relation_size(pg_class.oid) as size, 
    pg_indexes_size(pg_class.oid) as index, 
    pg_total_relation_size(pg_class.oid) as total, 
    100 * case when relkind = 'i' then pg_relation_size(pg_class.oid) 
            else pg_indexes_size(pg_class.oid) end 
     /pg_total_relation_size(pg_class.oid) as i_ratio 
from 
    pg_class 
    join pg_namespace on relnamespace = pg_namespace.oid 
order by 5 desc 

Answer 2

Prima di tutto perché non utilizzare le CTE renderanno il codice un po 'più leggibile. allora non tornare is_index così sembra essere redundunt

with p as (
SELECT nspname as schema, 
     relname as name, 
     pg_relation_size(nspname || '.' || relname) as s, 
     pg_total_relation_size(nspname || '.' || relname) as st 
    FROM pg_class 
     JOIN pg_namespace 
      ON (relnamespace = pg_namespace.oid) 
), 
pp as (
SELECT *, 
     case when st = s then 0 else s end as size, 
     case when st = s then s else st-s end as index 

    FROM p 
) 
select schema, 
     name, 
     pg_size_pretty(size) as size,   
     pg_size_pretty(index) as index, 
     (case st 
      when 0 then 0 
      else index*100/st 
     end) || '%' ratio, 
     st total 
from pp 
order by st desc limit 30; 

Answer 3

Tutto quello che veramente voglio fare è sottolineare che la risposta di quzary dovrebbe essere l'uso di oid e non la creazione di stringhe che non verranno riesaminate in oid.

Ora ho avuto modo di scrivere un post corretta (forse questo è il punto di arresto neofiti dal commentare?) Ecco un'altra versione puliti e prettied up:

WITH p AS (
    SELECT n.nspname AS schema, 
     c.relname AS name, 
     pg_relation_size(c.oid) AS s, 
     pg_total_relation_size(c.oid) AS st 
    FROM pg_class c, pg_namespace n 
    WHERE c.relnamespace = n.oid 
) 
SELECT schema, name, 
    pg_size_pretty(s) AS size,   
    pg_size_pretty(st - s) AS index, 
    (100.0 * s/NULLIF(st, 0))::numeric(10,1) AS "% data of total", 
    st AS total 
FROM p 
ORDER BY st DESC 
LIMIT 30; 

Si noti che può essere utile per aggiungere nella riga seguente:

AND c.relkind = 'r' 

nella clausola WHERE di p. Questo limiterà solo le relazioni/le tabelle e renderà il codice utile per un riepilogo generale delle dimensioni delle tabelle.

Answer 4

E non dimenticare che pg_relation_size e pg_total_relation_size non fanno distinzione tra maiuscole e minuscole!

pg_relation_size(nspname || '.' || relname) 

dovrebbe essere effettivamente:

pg_relation_size('"' || nspname || '.' || relname || '"') 

in modo che funziona con i casi superiori anche. (Mi ci è voluto un po 'per capirlo)