Wie die FormatBytes-Funktion Bytes in TB und mehr umrechnet

Ein Byte ist die grundlegende Einheit der Informationsmessung in der Computertechnologie. Doch trotz seiner scheinbaren Einfachheit ist das Byte ein Kernstück der digitalen Welt. In diesem Artikel beleuchten wir, was ein Byte ist, wie es umgerechnet wird und wofür es benötigt wird.

Was ist ein Byte?

Ein Byte besteht aus acht Binärstellen, auch bekannt als Bits. Ein Bit ist die kleinste Datenmenge in einem Computer und kann einen von zwei Werten haben: 0 oder 1. Diese binären Werte repräsentieren die Transistorzustände – ein wesentliches Element der digitalen Schaltkreise –, wobei 0 für „aus“ und 1 für „ein“ steht.

Wie rechnet man Bytes um?

Bytes können in größere oder kleinere Einheiten umgerechnet werden, um die Datenmenge zu beschreiben. Die häufigsten Umrechnungen sind:

Von Bytes zu Kilobytes (KB): Ein Kilobyte entspricht 1.000 Bytes (oder 1.024 Bytes, wenn man den binären Standard verwendet).
Von Kilobytes zu Megabytes (MB): Ein Megabyte sind 1.000 Kilobytes (bzw. 1.024 KB im binären Standard).
Von Megabytes zu Gigabytes (GB): Ein Gigabyte sind 1.000 Megabytes (oder 1.024 MB).

Nach Gigabytes kommt die Einheit Terabyte (TB), gefolgt von weiteren Einheiten, die jeweils um den Faktor 1.000 (im metrischen System) oder 1.024 (im binären System) größer sind. Hier ist die Liste der Einheiten über Gigabytes hinaus:

Terabyte (TB): 1 TB = 1.000 GB (im metrischen System) oder 1.024 GB (im binären System)
Petabyte (PB): 1 PB = 1.000 TB (metrisch) oder 1.024 TB (binär)
Exabyte (EB): 1 EB = 1.000 PB (metrisch) oder 1.024 PB (binär)
Zettabyte (ZB): 1 ZB = 1.000 EB (metrisch) oder 1.024 EB (binär)
Yottabyte (YB): 1 YB = 1.000 ZB (metrisch) oder 1.024 ZB (binär)

Im Kontext des binären Systems werden diese Einheiten oft mit einem „i“ eingefügt (wie TiB, PiB, usw.), um sie von den metrischen Einheiten zu unterscheiden. Das binäre System folgt der Basis 2 (also Potenzen von 2), was näher an der Art und Weise liegt, wie Computer Daten verarbeiten.

Es gibt auch größere Einheiten, die theoretisch existieren, aber in der Praxis selten verwendet werden, da sie extrem große Datenmengen darstellen, die über aktuelle technologische Fähigkeiten hinausgehen:

Brontobyte (BB): 1 BB = 1.000 YB (metrisch)
Geopbyte: Noch größer als ein Brontobyte und selten erwähnt.

Derzeit sind Petabytes und Exabytes in Anwendungsbereichen wie großen Datenzentren, Cloud-Speicherlösungen und bei der Datenanalyse großer Datenmengen (Big Data) gebräuchlich. Zettabytes kommen in die Diskussion, wenn es um die gesamte digitale Datenmenge weltweit geht. Yottabytes sind noch weitgehend theoretisch und nicht in realen Anwendungen anzutreffen.

Die Umrechnung erfolgt meistens durch Division oder Multiplikation mit 1.000 oder 1.024, je nachdem, ob man das metrische System oder das binäre System (auch bekannt als IEC-Standard) verwendet.

Wofür wird das Byte benötigt?

Bytes sind die Bausteine von Informationen und Daten in digitalen Medien und Computern. Alles, von einem einfachen Textdokument bis hin zu komplexen Softwareanwendungen, wird in Bytes gemessen. Hier sind einige Anwendungsbeispiele:

Datenspeicherung: Festplatten, SSDs, USB-Sticks und andere Speichermedien haben Kapazitäten, die in Gigabytes oder Terabytes (1.000 GB) angegeben sind.
Internetbandbreite: Die Geschwindigkeit der Datenübertragung im Internet wird oft in Megabits pro Sekunde (Mbps) oder Gigabits pro Sekunde (Gbps) angegeben. Hier wird ein Byte in 8 Bits umgerechnet.
Bild- und Videodateigrößen: Digitale Medien wie Fotos und Videos werden ebenfalls in Bytes ausgedrückt, um die Dateigröße zu beschreiben.

CREATE FUNCTION FormatBytes(
    @Bytes BIGINT,
    @DecimalPlaces INT = 2,
    @UseBinaryPrefix BIT = 1 -- 1 für binäre Präfixe (KiB, MiB...), 0 für metrische Präfixe (KB, MB...)
)
RETURNS NVARCHAR(20)
AS
BEGIN
    DECLARE @Output NVARCHAR(50)
    DECLARE @Magnitude INT
    DECLARE @Divisor FLOAT
    DECLARE @Unit NVARCHAR(5)
    DECLARE @SizeInUnit FLOAT
    DECLARE @Units TABLE (ID INT, Name NVARCHAR(5))

    -- Wählt den richtigen Divisor und die Einheitenliste basierend auf dem Präfix-Typ aus
    IF @UseBinaryPrefix = 1
    BEGIN
        SET @Divisor = 1024.0
        INSERT INTO @Units (ID, Name) VALUES (0, 'B'), (1, 'KiB'), (2, 'MiB'), (3, 'GiB'), (4, 'TiB'), (5, 'PiB'), (6, 'EiB'), (7, 'ZiB'), (8, 'YiB')
    END
    ELSE
    BEGIN
        SET @Divisor = 1000.0
        INSERT INTO @Units (ID, Name) VALUES (0, 'B'), (1, 'KB'), (2, 'MB'), (3, 'GB'), (4, 'TB'), (5, 'PB'), (6, 'EB'), (7, 'ZB'), (8, 'YB')
    END

    IF @Bytes < @Divisor
    BEGIN
        SET @Output = CAST(@Bytes AS NVARCHAR(20)) + ' B'
    END
    ELSE
    BEGIN
        -- Berechnet die Magnitude der Bytes
        SET @Magnitude = FLOOR(LOG(@Bytes) / LOG(@Divisor))

        -- Teilt die Bytes durch die entsprechende Potenz des Divisors basierend auf der Magnitude
        SET @SizeInUnit = @Bytes / POWER(@Divisor, @Magnitude)

        -- Ermittelt die Einheit aus der Tabelle basierend auf der Magnitude
        SELECT @Unit = Name FROM @Units WHERE ID = @Magnitude

        -- Setzt das Ergebnis zusammen
        SET @Output = FORMAT(@SizeInUnit, 'N' + CAST(@DecimalPlaces AS NVARCHAR)) + ' ' + @Unit
    END

    RETURN @Output
END
GO

Aufrufbeispiel:

SELECT dbo.FormatBytes(1536, 2, 1) -- Ergebnis: '1.50 KiB'

Diese SQL-Funktion FormatBytes ist eine benutzerdefinierte Funktion, die eine große Ganzzahl (BIGINT), die eine Byte-Zahl repräsentiert, zusammen mit zwei optionalen Parametern (@DecimalPlaces und @UseBinaryPrefix) nimmt und diese Zahl in ein leicht lesbares Format umwandelt, das verschiedene Einheiten wie KB, MB, GB usw. verwendet. Hier ist die schrittweise Erklärung:

Parameter der Funktion:
- @Bytes: Die Anzahl der Bytes, die formatiert werden sollen.
- @DecimalPlaces: Die Anzahl der Dezimalstellen, die im Ergebnis verwendet werden soll; standardmäßig ist dies auf 2 festgelegt.
- @UseBinaryPrefix: Ein boolescher Wert, der bestimmt, ob binäre (GiB, MiB, …) oder metrische (GB, MB, …) Präfixe verwendet werden sollen. Standardmäßig ist dies auf 1 (binär) gesetzt.
Variablendeklaration:
- @Output: Der String, der das Ergebnis hält.
- @Magnitude: Eine Variable, die dazu dient, die Größenordnung der Bytes zu bestimmen.
- @Divisor: Der Wert, durch den Bytes geteilt werden (1024 oder 1000, je nach Präfix).
- @Unit: Die Einheit, die dem Wert zugeordnet wird (z.B. KB, MB).
- @SizeInUnit: Die Größe in der jeweiligen Einheit nach der Division durch den Divisor.
- @Units: Eine temporäre Tabelle, die die Einheiten und ihre entsprechenden IDs enthält.
Logik für die Präfixauswahl:
- Basierend auf @UseBinaryPrefix wird der Divisor auf 1024 oder 1000 gesetzt und die temporäre Tabelle @Units mit entsprechenden Einheiten (binär oder metrisch) gefüllt.
Formatierung für Werte unter dem Divisor:
- Wenn @Bytes kleiner als der Divisor ist, wird der Wert direkt in Bytes (B) zurückgegeben.
Berechnung für größere Werte:
- Die Funktion berechnet zuerst @Magnitude durch die Verwendung des Logarithmus des Bytes-Wertes, geteilt durch den Logarithmus des Divisors.
- Anschließend wird @Bytes durch @Divisor zur Potenz von @Magnitude geteilt, um @SizeInUnit zu erhalten.
- Die entsprechende Einheit wird aus der @Units-Tabelle basierend auf der @Magnitude abgerufen.
Ausgabe:
- Die Funktion setzt das endgültige Format zusammen, indem sie @SizeInUnit formatiert, sodass es die spezifizierte Anzahl von Dezimalstellen hat, und fügt dann die entsprechende Einheit hinzu.
- Dieses Ergebnis wird dann als @Output zurückgegeben.
Rückgabewert:
- Die Funktion gibt den formatierten String @Output zurück, der die Größe in der am besten geeigneten Einheit mit der richtigen Anzahl von Dezimalstellen zeigt.

Mit GO wird das Ende des Batches markiert, was bedeutet, dass die Funktion jetzt in der Datenbank verfügbar ist und für die Konvertierung von Bytes in ein formatiertes String-Format verwendet werden kann.