¿Cómo obtener los tamaños de las tablas de una base de datos MySQL?

Puede usar esta consulta para mostrar el tamaño de una tabla (aunque primero debe sustituir las variables):

SELECT 
    table_name AS `Table`, 
    round(((data_length + index_length) / 1024 / 1024), 2) `Size in MB` 
FROM information_schema.TABLES 
WHERE table_schema = "$DB_NAME"
    AND table_name = "$TABLE_NAME";

o esta consulta para enumerar el tamaño de cada tabla en cada base de datos, la más grande primero:

SELECT 
     table_schema as `Database`, 
     table_name AS `Table`, 
     round(((data_length + index_length) / 1024 / 1024), 2) `Size in MB` 
FROM information_schema.TABLES 
ORDER BY (data_length + index_length) DESC;

SELECT TABLE_NAME AS "Table Name", 
table_rows AS "Quant of Rows", ROUND( (
data_length + index_length
) /1024, 2 ) AS "Total Size Kb"
FROM information_schema.TABLES
WHERE information_schema.TABLES.table_schema = 'YOUR SCHEMA NAME/DATABASE NAME HERE'
LIMIT 0 , 30

Puede obtener el nombre del esquema de "information_schema"-> ESQUEMA tabla -> "ESQUEMA_NOMBRE"columna

Adicionales Usted puede obtener tamaño de las bases de datos mysql como sigue.

SELECT table_schema "DB Name", 
Round(Sum(data_length + index_length) / 1024 / 1024, 1) "DB Size in MB" 
FROM   information_schema.tables 
GROUP  BY table_schema
ORDER BY `DB Size in MB` DESC;

Resultado

DB Name              |      DB Size in MB

mydatabase_wrdp             39.1
information_schema          0.0

solicite Obtenga detalles adicionales aquí.

SELECT 
    table_name AS "Table",  
    round(((data_length + index_length) / 1024 / 1024), 2) as size   
FROM information_schema.TABLES  
WHERE table_schema = "YOUR_DATABASE_NAME"  
ORDER BY size DESC; 

Esto ordena los tamaños (Tamaño de la base de datos en MB).

Si desea que una consulta utilice la base de datos seleccionada actualmente. simplemente copie y pegue esta consulta. (No se requiere modificación)

SELECT table_name ,
  round(((data_length + index_length) / 1024 / 1024), 2) as SIZE_MB
FROM information_schema.TABLES
WHERE table_schema = DATABASE() ORDER BY SIZE_MB DESC;

• Tamaño de todas las tablas:

  Suponga que su base de datos o TABLE_SCHEMA nombre es "news_alert". Entonces esta consulta mostrará el tamaño de todas las tablas en la base de datos.

  SELECT
    TABLE_NAME AS `Table`,
    ROUND(((DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024),2) AS `Size (MB)`
  FROM
    information_schema.TABLES
  WHERE
    TABLE_SCHEMA = "news_alert"
  ORDER BY
    (DATA_LENGTH + INDEX_LENGTH)
  DESC;
  

  Salida:

      +---------+-----------+
      | Table   | Size (MB) |
      +---------+-----------+
      | news    |      0.08 |
      | keyword |      0.02 |
      +---------+-----------+
      2 rows in set (0.00 sec)
  

• Para la mesa específica:

  Suponga que su TABLE_NAME is "Noticias". Entonces la consulta SQL será-

  SELECT
    TABLE_NAME AS `Table`,
    ROUND(((DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024),2) AS `Size (MB)`
  FROM
    information_schema.TABLES
  WHERE
      TABLE_SCHEMA = "news_alert"
    AND
      TABLE_NAME = "news"
  ORDER BY
    (DATA_LENGTH + INDEX_LENGTH)
  DESC;
  

  Salida:

  +-------+-----------+
  | Table | Size (MB) |
  +-------+-----------+
  | news  |      0.08 |
  +-------+-----------+
  1 row in set (0.00 sec)
  

Hay una manera fácil de obtener mucha información usando Workbench:

• Haga clic con el botón derecho en el nombre del esquema y haga clic en "Inspector de esquema".

• En la ventana resultante tiene varias pestañas. La primera pestaña "Información" muestra una estimación aproximada del tamaño de la base de datos en MB.

• La segunda pestaña, "Tablas", muestra la longitud de los datos y otros detalles de cada tabla.

Pruebe el siguiente comando de shell (reemplace DB_NAME con el nombre de su base de datos):

mysql -uroot <<<"SELECT table_name AS 'Tables', round(((data_length + index_length) / 1024 / 1024), 2) 'Size in MB' FROM information_schema.TABLES WHERE table_schema = \"DB_NAME\" ORDER BY (data_length + index_length) DESC;" | head

Para la solución Drupal / drush, consulte el siguiente script de ejemplo que mostrará las tablas más grandes en uso:

#!/bin/sh
DB_NAME=$(drush status --fields=db-name --field-labels=0 | tr -d '\r\n ')
drush sqlq "SELECT table_name AS 'Tables', round(((data_length + index_length) / 1024 / 1024), 2) 'Size in MB' FROM information_schema.TABLES WHERE table_schema = \"${DB_NAME}\" ORDER BY (data_length + index_length) DESC;" | head -n20

Esta es otra forma de resolver esto usando la línea de comandos de bash.

for i in mysql -NB -e 'show databases'; do echo $i; mysql -e "SELECT table_name AS 'Tables', round(((data_length+index_length)/1024/1024),2) 'Size in MB' FROM information_schema.TABLES WHERE table_schema =\"$i\" ORDER BY (data_length + index_length) DESC" ; done

Si está utilizando phpmyadmin, simplemente vaya a la estructura de la tabla

p.ej

Space usage
Data    1.5 MiB
Index   0   B
Total   1.5 Mi

Adaptado de la respuesta de ChapMic para satisfacer mi necesidad particular.

Solo especifique el nombre de su base de datos, luego ordene todas las tablas en orden descendente, de la tabla MÁS GRANDE a la MÁS PEQUEÑA dentro de la base de datos seleccionada. Solo necesita 1 variable para ser reemplazada = el nombre de su base de datos.

SELECT 
table_name AS `Table`, 
round(((data_length + index_length) / 1024 / 1024), 2) AS `size`
FROM information_schema.TABLES 
WHERE table_schema = "YOUR_DATABASE_NAME_HERE"
ORDER BY size DESC;

Otra forma de mostrar el número de filas y el espacio ocupado y ordenarlo.

SELECT
     table_schema as `Database`,
     table_name AS `Table`,
     table_rows AS "Quant of Rows",
     round(((data_length + index_length) / 1024 / 1024/ 1024), 2) `Size in GB`
FROM information_schema.TABLES
WHERE table_schema = 'yourDatabaseName'
ORDER BY (data_length + index_length) DESC;  

La única cadena que debe sustituir en esta consulta es "yourDatabaseName".

Si tiene ssh acceso, es posible que desee simplemente probar du -hc /var/lib/mysql (o diferente datadir, como se establece en su my.cnf) también.

Encuentro que las respuestas existentes en realidad no dan el tamaño de las tablas en el disco, lo cual es más útil. Esta consulta proporciona una estimación de disco más precisa en comparación con el tamaño de la tabla basada en data_length & index. Tuve que usar esto para una instancia de AWS RDS en la que no puede examinar físicamente el disco y verificar el tamaño de los archivos.

select NAME as TABLENAME,FILE_SIZE/(1024*1024*1024) as ACTUAL_FILE_SIZE_GB
, round(((data_length + index_length) / 1024 / 1024/1024), 2) as REPORTED_TABLE_SIZE_GB 
from INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES s
join INFORMATION_SCHEMA.TABLES t 
on NAME = Concat(table_schema,'/',table_name)
order by FILE_SIZE desc

SELECT TABLE_NAME AS table_name, 
table_rows AS QuantofRows, 
ROUND((data_length + index_length) /1024, 2 ) AS total_size_kb 
FROM information_schema.TABLES
WHERE information_schema.TABLES.table_schema = 'db'
ORDER BY (data_length + index_length) DESC; 

los 2 anteriores se prueban en mysql

Esto debería probarse en mysql, no en postgresql:

SELECT table_schema, # "DB Name", 
Round(Sum(data_length + index_length) / 1024 / 1024, 1) # "DB Size in MB" 
FROM   information_schema.tables 
GROUP  BY table_schema; 

Calcule el tamaño total de la base de datos al final:

(SELECT 
  table_name AS `Table`, 
  round(((data_length + index_length) / 1024 / 1024), 2) `Size in MB` 
  FROM information_schema.TABLES 
  WHERE table_schema = "$DB_NAME"
)
UNION ALL
(SELECT 
  'TOTAL:',
  SUM(round(((data_length + index_length) / 1024 / 1024), 2) )
  FROM information_schema.TABLES 
  WHERE table_schema = "$DB_NAME"
)

select x.dbname as db_name, x.table_name as table_name, x.bytesize as the_size from
  (select
     table_schema as dbname,
     sum(index_length+data_length) as bytesize,
     table_name
   from
     information_schema.tables
   group by table_schema
  ) x
where
  x.bytesize > 999999
order by x.bytesize desc;

Hice este script de shell para realizar un seguimiento del tamaño de la tabla (en bytes y en número de filas)

#!/bin/sh

export MYSQL_PWD=XXXXXXXX
TABLES="table1 table2 table3"

for TABLE in $TABLES;
do
        FILEPATH=/var/lib/mysql/DBNAME/$TABLE.ibd
        TABLESIZE=`wc -c $FILEPATH | awk '{print $1}'`
        #Size in Bytes
        mysql -D scarprd_self -e "INSERT INTO tables_sizes (table_name,table_size,measurement_type) VALUES ('$TABLE', '$TABLESIZE', 'BYTES');"
        #Size in rows
        ROWSCOUNT=$(mysql -D scarprd_self -e "SELECT COUNT(*) AS ROWSCOUNT FROM $TABLE;")
        ROWSCOUNT=${ROWSCOUNT//ROWSCOUNT/}
        mysql -D scarprd_self -e "INSERT INTO tables_sizes (table_name,table_size,measurement_type) VALUES ('$TABLE', '$ROWSCOUNT', 'ROWSCOUNT');"
        mysql -D scarprd_self -e "DELETE FROM tables_sizes WHERE measurement_datetime < TIMESTAMP(DATE_SUB(NOW(), INTERVAL 365 DAY));"
done

Presupone tener esta tabla MySQL

CREATE TABLE `tables_sizes` (
  `table_name` VARCHAR(128) NOT NULL,
  `table_size` VARCHAR(25) NOT NULL,
  `measurement_type` VARCHAR(10) NOT NULL CHECK (measurement_type IN ('BYTES','ROWSCOUNT')),
  `measurement_datetime` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP()
) ENGINE=INNODB DEFAULT CHARSET=utf8