Wie erhalte ich die Größe der Tabellen einer MySQL-Datenbank?

Ich kann diese Abfrage ausführen, um die Größe aller Tabellen in einer MySQL-Datenbank zu ermitteln:

show table status from myDatabaseName;

Ich hätte gerne Hilfe beim Verständnis der Ergebnisse. Ich suche Tische mit den größten Größen.

Welche Spalte soll ich mir ansehen?

Mit dieser Abfrage können Sie die Größe einer Tabelle anzeigen (obwohl Sie zuerst die Variablen ersetzen müssen):

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

oder diese Abfrage, um die Größe jeder Tabelle in jeder Datenbank aufzulisten, die größte zuerst:

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

Sie können den Schemanamen aus der Spalte " information_schema " -> Tabelle SCHEMATA -> Spalte " SCHEMA_NAME " abrufen

Zusätzliche Sie können die Größe der MySQL-Datenbanken wie folgt ermitteln.

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; 

Ergebnis

DB Name              |      DB Size in MB

mydatabase_wrdp             39.1
information_schema          0.0

Sie können hier weitere Details erhalten.

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; 

Dadurch werden die Größen sortiert (DB-Größe in MB).

Wenn Sie möchten, dass eine Abfrage die aktuell ausgewählte Datenbank verwendet. Kopieren Sie einfach diese Abfrage einfügen. (Keine Änderung erforderlich)

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;

Es gibt eine einfache Möglichkeit, mit Workbench viele Informationen abzurufen:

• Klicken Sie mit der rechten Maustaste auf den Schemanamen und klicken Sie auf "Schemainspektor".

• Im resultierenden Fenster haben Sie eine Reihe von Registerkarten. Die erste Registerkarte "Info" zeigt eine grobe Schätzung der Datenbankgröße in MB.

• Die zweite Registerkarte "Tabellen" zeigt die Datenlänge und andere Details für jede Tabelle.

• Größe aller Tabellen:

  Angenommen, Ihre Datenbank oder Ihr TABLE_SCHEMAName lautet "news_alert". Diese Abfrage zeigt dann die Größe aller Tabellen in der Datenbank an.

  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;

  Ausgabe:

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

• Für die spezifische Tabelle:

  Angenommen, Sie TABLE_NAMEsind "Nachrichten" . Dann wird die SQL-Abfrage

  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;

  Ausgabe:

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

Versuchen Sie den folgenden Shell-Befehl (durch DB_NAMEIhren Datenbanknamen ersetzen ):

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

Überprüfen Sie für die Drupal / Drush-Lösung das folgende Beispielskript, in dem die größten verwendeten Tabellen angezeigt werden:

#!/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

Hier ist eine andere Möglichkeit, dies anhand der Bash-Befehlszeile herauszufinden.

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

Wenn Sie phpmyadmin verwenden, gehen Sie einfach zur Tabellenstruktur

z.B

Space usage
Data    1.5 MiB
Index   0   B
Total   1.5 Mi

Angepasst an die Antwort von ChapMic, um meinen besonderen Bedürfnissen gerecht zu werden.

Geben Sie nur Ihren Datenbanknamen an und sortieren Sie dann alle Tabellen in absteigender Reihenfolge - von der GRÖSSTEN bis zur KLEINSTEN Tabelle in der ausgewählten Datenbank. Es muss nur 1 Variable ersetzt werden = Ihr Datenbankname.

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;

Wenn Sie sshZugriff haben, können Sie es auch einfach versuchen du -hc /var/lib/mysql(oder anders datadir, wie in Ihrem festgelegt my.cnf).

Eine andere Möglichkeit, die Anzahl der Zeilen und den belegten Platz anzuzeigen und zu ordnen.

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;  

Die einzige Zeichenfolge, die Sie in dieser Abfrage ersetzen müssen, ist "yourDatabaseName".

Ich finde, dass die vorhandenen Antworten nicht die Größe der Tabellen auf der Festplatte angeben, was hilfreicher ist. Diese Abfrage bietet eine genauere Festplattenschätzung im Vergleich zur Tabellengröße basierend auf data_length & index. Ich musste dies für eine AWS RDS-Instanz verwenden, bei der Sie die Festplatte nicht physisch untersuchen und die Dateigröße überprüfen können.

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

Berechnen Sie die Gesamtgröße der Datenbank am Ende:

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

Alle 2 oben sind auf MySQL getestet

Dies sollte in MySQL getestet werden, nicht in 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;