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

Puedo ejecutar esta consulta para obtener los tamaños de todas las tablas en una base de datos MySQL:

show table status from myDatabaseName;

Me gustaría recibir ayuda para comprender los resultados. Busco mesas con los tamaños más grandes.

¿Qué columna debería mirar?

preguntado el 08 de marzo de 12 a las 15:03

¿A qué te refieres con tamaño? ¿Número de filas? ¿Bytes tomados en el disco? -

@Mark quiero el tamaño en el disco, ¿es este el método correcto? # du -sh /mnt/mysql_data/openx/f_scraper_banner_details.MYI 79G /mnt/mysql_data/openx/f_scraper_banner_details.MYI -

Relacionado, si es de interés, escribí un Describir todas las tablas in esta respuesta. -

18 Respuestas

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;

Respondido el 06 de enero de 16 a las 09:01

Gracias, está funcionando bien, aunque no estoy seguro de que tenga en cuenta a Blobs. - David

Tenga en cuenta que también puede utilizar "IN" para especificar varias tablas, p. Ej. AND table_name IN ('table_1', 'table_2', 'table_3'); - David Thomas

AFAICT, esto solo contará correctamente las longitudes de los campos de tamaño estático. ¿Cómo contarías? VARCHAR y BLOB tipos? - l0b0

@kasimir En algún momento, el mundo se volvió confuso y algunas organizaciones de estándares y fabricantes de hardware decidieron que era mejor definir un kilobyte en el sistema decimal. El estándar IEC ahora llama kibibyte (KiB) a la base de 2 kilobytes (1024 bytes). En cualquier caso, MySQL no lo sabe, así que si quieres kilobytes decimales IEC, divídelos por 1000. - Russellpierce

¿Funcionará esto para el motor de almacenamiento InnoDB? De acuerdo con mysql doc aquí: dev.mysql.com/doc/refman/5.7/en/show-table-status.html, el campo data_length para ese motor contiene el tamaño del índice agrupado. Eso no representará correctamente el tamaño de los datos. ¿Lo hará? - euforia83

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

Puede Obtenga detalles adicionales aquí.

Respondido 17 Oct 21, 08:10

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).

Respondido 03 Abr '18, 08:04

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;

Respondido 04 Abr '18, 08:04

O incluso más corto (sin subconsulta): SELECT table_name, round (((data_length + index_length) / 1024/1024), 2) SIZE_MB FROM information_schema.TABLES WHERE table_schema = DATABASE () ORDER BY (data_length + index_length) ASC; - Onkeltem

  • 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)
    

contestado el 02 de mayo de 20 a las 05:05

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.

Respondido 27 Feb 15, 15:02

No tenía la pestaña 'información' en mi cliente Mac v 6.0.9 - Neil

¡¡¡Estupendo!!! En MySQL Workbench también hay un "Inspector de tabla" para cada tabla. ¡No es muy rápido pero muy útil! - T30

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

Respondido 08 Jul 16, 15:07

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

respondido 10 nov., 14:11

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

respondido 21 mar '15, 14:03

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;

Respondido 01 Abr '17, 00:04

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".

Respondido 13 Feb 17, 06:02

Si no 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.

Respondido 17 Jul 17, 16:07

Finalmente, una respuesta que no se basa en information_schema. En mi caso, informó 660 MB, mientras que el tamaño real en el sistema de archivos es de 1.8 GB. php_nub_qq

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

contestado el 02 de mayo de 19 a las 10:05

esta debería ser la respuesta, al menos para INNODB. Simplemente sumando DATA_LENGTH, INDEX_LENGTH & DATA_FREE no obtiene el tamaño en Disk si tiene grandes campos de datos fuera de fila (como blobs). Para INNODB, debe usar INNDB_SYS_TABLESPACES.FILE_SIZE para obtener un preciso leer el tamaño del disco, pero también necesita el privilegio PROCESO para seleccionar de esta tabla. - MNB

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

Respondido el 04 de Septiembre de 18 a las 04:09

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; 

Respondido 19 Abr '20, 18:04

Si bien esto podría responder a la pregunta de los autores, carece de algunas palabras explicativas y / o enlaces a la documentación. Los fragmentos de código sin formato no son muy útiles sin algunas frases a su alrededor. También puede encontrar cómo escribir una buena respuesta muy útil. Edite su respuesta - De la revisión - Nick

@Nick, ¿por qué todavía está prohibido? - William

Lo siento, no sé la respuesta a eso, no soy moderador. - Nick

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"
)

Respondido 18 Jul 18, 08:07

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;

respondido 18 nov., 20:20

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

Respondido el 23 de Septiembre de 21 a las 13:09

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.