SQL-Datenbankgrößen auf einen Blick: Der ultimative Guide

Im Rahmen der Erstellung eines Berichts für das Metadatenmanagement war es erforderlich, eine detaillierte Übersicht über die Größe der Microsoft SQL Server Datenbanken zu erhalten. Dabei war von besonderem Interesse, die Quellen des Speicherplatzverbrauchs zu identifizieren – speziell, ob der Verbrauch primär durch die Datenbankdateien selbst oder durch die Protokoll- bzw. Logdateien bedingt ist. Um diese Anforderungen effizient zu adressieren, habe ich eine spezialisierte Prozedur entwickelt. Zudem können wir auch mit unserer gestrigen Prozedur ShrinkDatabaseLogFiles dies nutzen, um uns einen Überblick zu verschaffen, welche Logdateien eventuell sehr groß sind und mit unserer Prozedur ShrinkDatabaseLogFiles verkleinert werden sollten. Diese ermöglicht nicht nur die Ermittlung der benötigten Informationen, sondern bietet zusätzlich die Flexibilität, die Anzahl der Daten- und Logdateien (MDF und LDF) zu bestimmen. Darüber hinaus wurde die Prozedur so konzipiert, dass sie die Ausgabe der Daten unter Berücksichtigung des bevorzugten Dezimalzeichens und der gewünschten Maßeinheiten (MB, GB, TB etc.) anpassen kann.

Unsere Prozedur dbo.GetDatabaseSizes in unserer META Datenbank angelegt.

CREATE OR ALTER PROCEDURE dbo.GetDatabaseSizes
    @SizeUnit NVARCHAR(2) = 'GB', -- Default Größeneinheit
    @DecimalChar CHAR(1) = '.', -- Default Dezimalzeichen
    @DecimalPlaces INT = 5 -- Default Anzahl Nachkommastellen
AS
BEGIN
    DECLARE @Multiplier FLOAT = CASE @SizeUnit
                    WHEN 'MB' THEN 128 -- 1 Seite = 8 KB, daher 1024 KB / 8 KB pro Seite = 128 Seiten pro MB
                    WHEN 'GB' THEN 128 * 1024 -- MB to GB
                    WHEN 'TB' THEN 128 * 1024 * 1024 -- MB to TB
                    WHEN 'PB' THEN 128 * 1024 * 1024 * 1024 -- MB to PB
                    WHEN 'EB' THEN 128 * 1024 * 1024 * 1024 * 1024 -- MB to EB
                    WHEN 'ZB' THEN 128 * 1024 * 1024 * 1024 * 1024 * 1024 -- MB to ZB
                    WHEN 'YB' THEN 128 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 -- MB to YB
                    WHEN 'BB' THEN 128 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 -- MB to BB
                    ELSE 128 * 1024 -- Standardmäßig GB, falls eine unbekannte Einheit angegeben wird
                    END;

    DECLARE @DynamicSQL NVARCHAR(MAX);
    SET @DynamicSQL = N'SELECT 
                            d.name AS [DBName],
                            COUNT(f.file_id) AS [NumberOfFiles],
                            SUM(CAST(f.size AS NUMERIC(18, 2)) * 8 / 1024 / ' + CAST(@Multiplier AS NVARCHAR) + ') AS [TotalSize_' + @SizeUnit + '],
                            REPLACE(STR(SUM(CAST(f.size AS NUMERIC(18, 2)) * 8 / 1024 / ' + CAST(@Multiplier AS NVARCHAR) + '), 36, ' + CAST(@DecimalPlaces AS NVARCHAR) + '), ''.'', ''' + @DecimalChar + ''') AS [FormattedTotalSize_' + @SizeUnit + '],
							REPLACE(STR(SUM(CASE WHEN f.type_desc = ''ROWS'' THEN CAST(f.size AS NUMERIC(18, 2)) * 8 / 1024 / ' + CAST(@Multiplier AS NVARCHAR) + ' ELSE 0 END), 36, ' + CAST(@DecimalPlaces AS NVARCHAR) + '), ''.'', ''' + @DecimalChar + ''') AS [DataFilesSize_' + @SizeUnit + '],
                            REPLACE(STR(SUM(CASE WHEN f.type_desc = ''LOG'' THEN CAST(f.size AS NUMERIC(18, 2)) * 8 / 1024 / ' + CAST(@Multiplier AS NVARCHAR) + ' ELSE 0 END), 36, ' + CAST(@DecimalPlaces AS NVARCHAR) + '), ''.'', ''' + @DecimalChar + ''') AS [LogFilesSize_' + @SizeUnit + ']
                        FROM 
                            sys.databases d
                            INNER JOIN sys.master_files f ON d.database_id = f.database_id
                        GROUP BY 
                            d.name
                        ORDER BY 
                            [TotalSize_' + @SizeUnit + '] DESC';

    EXEC sp_executesql @DynamicSQL;
END

Aufruf für Größenangaben in Megabytes mit einem Komma als Dezimalzeichen und zwei Nachkommastellen:

EXEC [META].[dbo].[GetDatabaseSizes]
    @SizeUnit = N'MB',
    @DecimalChar = N',',
    @DecimalPlaces = 2

Das Ergebnis schaut dann so aus auf unseren kleinen Testserver:

Natürlich können wir die Prozedur auch ohne Parameter aufrufen, und bekommen die Standardwerte zurück, die wir festgelegt haben.

[META].[dbo].[GetDatabaseSizes]

Kurzer Exkurs zu Maßeinheiten für digitale Informationen

Die Einheiten MB, GB, TB, PB, EB, ZB, YB und BB gehören alle zu Maßeinheiten für digitale Informationen. Sie basieren auf dem Binärsystem, wobei jede Einheit dem 1024-fachen der vorherigen entspricht. Hier ist eine kurze Übersicht:

MB (Megabyte): Ein Megabyte entspricht 1.024 Kilobytes (KB) oder 2 hoch 20 (ungefähr eine Million) Bytes. Es ist eine gängige Einheit für die Größe von Dateien oder Speichermedien.
GB (Gigabyte): Ein Gigabyte entspricht 1.024 Megabytes (MB) oder 2 hoch 30 Bytes. Diese Einheit wird häufig verwendet, um die Speicherkapazität von größeren Geräten wie USB-Sticks oder Festplatten anzugeben.
TB (Terabyte): Ein Terabyte entspricht 1.024 Gigabytes (GB) oder 2 hoch 40 Bytes. Terabytes sind üblich für die Messung der Speicherkapazität von Festplatten und Netzwerkspeichern.
PB (Petabyte): Ein Petabyte entspricht 1.024 Terabytes (TB) oder $2 hoch 50$ Bytes. Petabytes werden oft zur Messung der Datenmengen in großen Datenspeichern und Cloud-Speicherinfrastrukturen verwendet.
EB (Exabyte): Ein Exabyte entspricht 1.024 Petabytes (PB) oder 2 hoch 60 Bytes. Exabytes kommen zur Anwendung, wenn es um die Messung extrem großer Datenmengen geht, wie sie beispielsweise von großen Datencentern und im Rahmen von Big-Data-Analysen anfallen.
ZB (Zettabyte): Ein Zettabyte entspricht 1.024 Exabytes (EB) oder 2 hoch 70 Bytes. Zettabytes sind eine Einheit, die zunehmend relevant wird, um das exponentielle Wachstum globaler Datenmengen zu beschreiben.
YB (Yottabyte): Ein Yottabyte entspricht 1.024 Zettabytes (ZB) oder 2 hoch 80 Bytes. Diese fast unvorstellbar große Einheit wird verwendet, um theoretische Speicherkapazitäten oder die gesamten digitalen Informationen der Welt zu beschreiben.
BB (Brontobyte): Obwohl nicht offiziell vom Internationalen Einheitensystem (SI) anerkannt, wird der Begriff Brontobyte manchmal verwendet, um 1.024 Yottabytes (YB) oder 2 hoch 90 Bytes zu beschreiben. Es handelt sich um eine extrem große Datenmenge, die weit über aktuelle Speicherkapazitäten hinausgeht und eher theoretischer Natur ist.

Jede dieser Einheiten zeigt die enorme Skalierbarkeit digitaler Daten. Von Megabytes, die früher für die Speicherung von Dateien ausreichend waren, bis hin zu Brontobytes, die das Potenzial haben, das Wissen und die Daten der gesamten Menschheit zu erfassen, veranschaulicht die Reihe dieser Einheiten das exponentielle Wachstum der digitalen Datenverarbeitung und -speicherung.