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

900

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?

JPashs
quelle
8
Was meinst du mit Größe? Reihenanzahl? Auf der Festplatte aufgenommene Bytes?
Mark Byers
@ Mark Ich möchte Größe auf der Festplatte ist diese richtige Methode? # du -sh /mnt/mysql_data/openx/f_scraper_banner_details.MYI 79G /mnt/mysql_data/openx/f_scraper_banner_details.MYI
Ashish Karpe
3
Verwandte, wenn es von Interesse ist, schrieb ich eine Beschreibung aller Tabellen in dieser Antwort .
Drew

Antworten:

1958

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;
ChapMic
quelle
3
Vielen Dank, es funktioniert einwandfrei, obwohl ich nicht sicher bin, ob es Blobs berücksichtigt.
David
5
Beachten Sie, dass Sie auch "IN" verwenden können, um mehrere Tabellen anzugeben, z. B.AND table_name IN ('table_1', 'table_2', 'table_3');
David Thomas
6
AFAICT, dies zählt nur die Länge der statischen Größenfelder korrekt. Wie würden Sie zählen VARCHARund BLOBtippen?
10.
3
@kasimir Irgendwann wurde die Welt verwirrend und einige Standardorganisationen und Hardwarehersteller entschieden, dass es besser ist, ein Kilobyte auf dem Dezimalsystem zu definieren. Der IEC-Standard nennt die Basis 2 Kilobyte (1024 Bytes) jetzt ein Kibibyte (KiB). Auf jeden Fall weiß MySQL nicht, also wenn Sie IEC-Dezimal-Kilobyte wollen, dividieren Sie durch 1000.
russellpierce
9
Funktioniert dies für die InnoDB-Speicher-Engine? Laut MySQL-Dokument hier - dev.mysql.com/doc/refman/5.7/en/show-table-status.html enthält das Feld data_length für diese Engine die Größe des Clustered-Index. Die Größe der Daten wird dadurch nicht korrekt dargestellt. Wird es?
Euphorie83
96
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.

Sumith Harshan
quelle
41
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).

Gank
quelle
31

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;
Zainengineer
quelle
5
Oder noch kürzer (ohne Unterabfrage): SELECT table_name, round (((data_length + index_length) / 1024/1024), 2) SIZE_MBFROM information_schema.TABLES WHERE table_schema = DATABASE () ORDER BY (data_length + index_length) ASC;
Onkeltem
15

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.

Guppy
quelle
Ich hatte nicht die Registerkarte "Info" auf meinem Mac-Client 6.0.9
Neil
Großartig!!! In MySQL Workbench gibt es auch einen "Tabelleninspektor" für jede Tabelle. Nicht richtig schnell, aber sehr praktisch!
T30
11
  • 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)
Nurul Akter Towhid
quelle
8

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
Kenorb
quelle
6

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

user1380599
quelle
6

Wenn Sie phpmyadmin verwenden, gehen Sie einfach zur Tabellenstruktur

z.B

Space usage
Data    1.5 MiB
Index   0   B
Total   1.5 Mi
Almis
quelle
4

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;
dev101
quelle
3

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

exic
quelle
Endlich eine Antwort, die nicht auf information_schema beruht. In meinem Fall wurden 660 MB gemeldet, während die tatsächliche Größe des Dateisystems 1,8
GB
2

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

Nav
quelle
2

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
Ryum Aayur
quelle
1

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"
)
MINGSONG HU
quelle
1
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

Wilhelm
quelle
1

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; 
Wilhelm
quelle
Dies könnte zwar die Frage des Autors beantworten, es fehlen jedoch einige erklärende Wörter und / oder Links zur Dokumentation. Rohcode-Schnipsel sind ohne einige Ausdrücke nicht sehr hilfreich. Möglicherweise ist es auch sehr hilfreich , eine gute Antwort zu schreiben . Bitte bearbeiten Sie Ihre Antwort - Aus der Bewertung
Nick
@ Nick warum immer noch verboten?
William
Entschuldigung, ich kenne die Antwort darauf nicht - ich bin kein Moderator.
Nick