Freigeben über

Schätzen der Größe eines gruppierten Indexes

Gilt für:SQL ServerAzure SQL-DatenbankVerwaltete Azure SQL-InstanzSQL-Datenbank in Microsoft Fabric

Mit den folgenden Schritten können Sie den Umfang des Speicherplatzes schätzen, der zum Speichern eines gruppierten Indexes erforderlich ist:

  1. Berechnen des Speicherplatzes, der zum Speichern der Daten in der Blattebene des gruppierten Indexes erforderlich ist.
  2. Berechnen des Speicherplatzes, der zum Speichern von Indexinformationen für den gruppierten Index verwendet wird.
  3. Addieren Sie die berechneten Werte.

Schritt 1. Berechnen des zum Speichern von Daten auf Blattebene verwendeten Speicherplatz

  1. Geben Sie die Anzahl der Zeilen an, die in der Tabelle vorhanden sind:

    • Num_Rows = Anzahl der Zeilen in der Tabelle

  2. Geben Sie die Anzahl der Spalten mit fester und mit variabler Länge an, und berechnen Sie den Speicherplatz, der für deren Speicherung erforderlich ist:

    Berechnen Sie den Speicherplatz, der zum Speichern jeder dieser Spaltengruppen innerhalb der Datenzeile erforderlich ist. Die Größe einer Spalte hängt von der Angabe für Datentyp und -länge ab.

    • Num_Cols = Gesamtzahl der Spalten (mit fester und variabler Länge)
    • Fixed_Data_Size = Gesamtzahl der Bytes in allen Spalten mit fester Länge
    • Num_Variable_Cols = Anzahl der Spalten mit variabler Länge
    • Max_Var_Size = Maximale Bytegröße aller Spalten mit variabler Länge

  3. Wenn der gruppierte Index nicht eindeutig ist, müssen Sie die Eindeutigerspalte berücksichtigen:

    Die Uniqueifier-Spalte ist eine Spalte variabler Länge mit NULL-Zulässigkeit. Es ist ungleich null und 4 Byte groß in Zeilen mit nicht eindeutigen Key-Werten. Dieser Wert ist Teil des Indexschlüssels und für die Sicherstellung erforderlich, dass jede Zeile über einen eindeutigen Schlüsselwert verfügt.

    • Num_Cols = Num_Cols + 1
    • Num_Variable_Cols = Num_Variable_ColsNum_Variable_Cols + 1
    • Max_Var_Size = Max_Var_SizeMax_Var_Size + 4

    Bei diesen Änderungen wird davon ausgegangen, dass alle Werte nicht ununique sind.

  4. Ein Teil der Zeile, der als NULL-Bitmuster (Null_Bitmap) bezeichnet wird, wird für das Verwalten der NULL-Zulässigkeit der Spalte reserviert. Berechnen Sie dessen Größe:

    • Null_Bitmap = 2 + ((Num_Cols + 7) / 8)

    Nur der ganzzahlige Teil des oben aufgeführten Ausdrucks sollte verwendet werden; verwerfen Sie den Nachkommateil.

  5. Berechnen Sie die Größe der Daten variabler Länge:

    Wenn die Tabelle Spalten variabler Länge enthält, müssen Sie den Speicherplatz ermitteln, der von den Spalten innerhalb der Zeile verwendet wird:

    • Variable_Data_Size = 2 + (Num_Variable_Cols x 2) + Max_Var_Size

    Die zu Max_Var_Size hinzugefügten Bytes dienen der Nachverfolgung jeder einzelnen variablen Spalte. Bei dieser Formel wird angenommen, dass alle Spalten variabler Länge zu 100 % gefüllt sind. Wenn sich abzeichnet, dass ein niedrigerer Prozentsatz des Speicherplatzes für Spalten variabler Länge verwendet wird, können Sie den Wert Max_Var_Size mithilfe dieses Prozentsatzes anpassen, um einen genaueren Schätzwert für die Gesamtgröße der Tabelle zu erhalten.

    Sie können varchar-, nvarchar-, varbinary- oder sql_variant -Spalten kombinieren, mit dem Ergebnis, dass die definierte Tabellengesamtbreite größer als 8.060 Byte ist. Die Länge jeder einzelnen Spalte unterliegt auch weiterhin der Beschränkung von 8.000 Byte für eine varchar-, varbinary- oder sql_variant -Spalte und von 4.000 Byte für nvarchar -Spalten. Die kombinierten Breiten können jedoch den Grenzwert von 8.060 Byte in einer Tabelle überschreiten.

    Wenn keine Spalten variabler Länge vorhanden sind, legen Sie Variable_Data_Size auf 0 fest.

  6. Berechnen Sie die Gesamtzeilenlänge:

    • = Row_Size + Fixed_Data_Size + Variable_Data_SizeNull_Bitmap + 4

    Der Wert 4 ist der Zeilenüberschriftenaufwand der Datenzeile.

  7. Berechnen sie die Anzahl der Zeilen pro Seite (8.096 freie Bytes pro Seite):

    • Rows_Per_Page = 8096 / (Row_Size + 2)

    Da Zeilen keine Seiten umfassen, sollte die Anzahl der Zeilen pro Seite auf die nächste ganze Zeile abgerundet werden. Die Angabe 2 in der Formel bezieht sich auf den Eingang der Zeile in das Slotarray der Seite.

  8. Berechnen Sie die Anzahl der reservierten freien Zeilen pro Seite anhand des angegebenen Füllfaktors :

    • Free_Rows_Per_Page = 8096 x ((100 - Fill_Factor) / 100) / (Row_Size + 2)

    Bei dem in der Berechnung verwendeten Füllfaktor handelt es sich nicht um einen Prozentwert, sondern um einen ganzzahligen Wert. Da Zeilen keine Seiten umfassen, sollte die Anzahl der Zeilen pro Seite auf die nächste ganze Zeile abgerundet werden. Wenn der Füllfaktor wächst, werden mehr Daten auf jeder Seite gespeichert, und es gibt weniger Seiten. Die Angabe 2 in der Formel bezieht sich auf den Eingang der Zeile in das Slotarray der Seite.

  9. Berechnen Sie die Anzahl der Seiten, die zum Speichern aller Zeilen benötigt werden:

    • = Num_Leaf_PagesNum_Rows / (Rows_Per_Page - Free_Rows_Per_Page)

    Die geschätzte Seitenanzahl muss auf die nächste ganze Seite aufgerundet werden.

  10. Berechnen Sie den Speicherplatz, der zum Speichern der Daten auf der Blattebene erforderlich ist (8.192 Bytes pro Seite):

    • Leaf_space_used = 8192 x Num_Leaf_Pages

Schritt 2. Berechnen des zum Speichern von Indexinformationen verwendeten Speicherplatzes

Mit den folgenden Schritten können Sie den Umfang des Speicherplatzes schätzen, der zum Speichern der oberen Ebenen des Indexes erforderlich ist:

  1. Geben Sie die Anzahl der Spalten mit fester und mit variabler Länge im Indexschlüssel an, und berechnen Sie den Speicherplatz, der für deren Speicherung erforderlich ist:

    Die Schlüsselspalten eines Indexes können Spalten fester und variabler Länge enthalten. Um die Größe der Indexzeilen auf der inneren Ebene zu schätzen, müssen Sie den Speicherplatz berechnen, der von jeder dieser Spaltengruppen innerhalb der Indexzeile belegt wird. Die Größe einer Spalte hängt von der Angabe für Datentyp und -länge ab.

    • Num_Key_Cols = Gesamtzahl der Schlüsselspalten (mit fester und variabler Länge)
    • Fixed_Key_Size = Gesamtzahl der Bytes in allen Schlüsselspalten mit fester Länge
    • Num_Variable_Key_Cols = Anzahl der Schlüsselspalten mit variabler Länge
    • Max_Var_Key_Size = Maximale Bytegröße aller Schlüsselspalten mit variabler Länge

  2. Berücksichtigen Sie jede erforderliche Eindeutigkeitsersteller, wenn der Index nicht eindeutig ist.

    Die Uniqueifier-Spalte ist eine Spalte variabler Länge mit NULL-Zulässigkeit. Es ist nicht null und hat eine Größe von 4 Byte in Zeilen, die nicht eindeutige Indexschlüsselwerte enthalten. Dieser Wert ist Teil des Indexschlüssels und für die Sicherstellung erforderlich, dass jede Zeile über einen eindeutigen Schlüsselwert verfügt.

    • = Num_Key_ColsNum_Key_Cols + 1
    • = Num_Variable_Key_ColsNum_Variable_Key_Cols + 1
    • Max_Var_Key_Size = Max_Var_Key_SizeMax_Var_Key_Size + 4

    Bei diesen Änderungen wird davon ausgegangen, dass alle Werte nicht ununique sind.

  3. Berechnen der Größe des NULL-Bitmusters:

    Wenn der Index Spalten mit NULL-Zulässigkeit enthält, ist ein Teil der Indexzeile dem NULL-Bitmuster zugeordnet. Berechnen Sie dessen Größe:

    • Index_Null_Bitmap = 2 + ((Anzahl der Spalten in der Indexzeile + 7) / 8)

    Nur der ganzzahlige Teil des vorherigen Ausdrucks darf verwendet werden. Der Rest wird verworfen.

    Wenn keine Schlüsselspalten vorhanden sind, die NULL-Werte zulassen, legen Sie Index_Null_Bitmap auf 0 (null) fest.

  4. Berechnen Sie die Größe der Daten variabler Länge:

    Wenn der Index Spalten variabler Länge enthält, müssen Sie den Speicherplatz ermitteln, der von den Spalten innerhalb der Indexzeile verwendet wird:

    • Variable_Key_Size = 2 + (Num_Variable_Key_Cols x 2) + Max_Var_Key_Size

    Die zu Max_Var_Key_Size hinzugefügten Bytes dienen der Nachverfolgung der einzelnen Spalten mit variabler Länge. Bei dieser Formel wird angenommen, dass alle Spalten variabler Länge zu 100 % gefüllt sind. Wenn sich abzeichnet, dass ein niedrigerer Prozentsatz des Speicherplatzes für Spalten mit variabler Länge verwendet wird, können Sie den Wert Max_Var_Key_Size mithilfe dieses Prozentsatzes anpassen, um einen genaueren Schätzwert für die Gesamtgröße der Tabelle zu erhalten.

    Wenn keine Spalten mit variabler Länge vorhanden sind, legen Sie Variable_Key_Size auf 0 (null) fest.

  5. Berechnen Sie die Länge der Indexzeile:

    • Index_Row_Size = Fixed_Key_Size + Variable_Key_Size + Index_Null_Bitmap + 1 (für Zeilenheaderaufwand einer Indexzeile) + 6 (für ID-Zeiger der untergeordneten Seite)

  6. Berechnen der Anzahl von Indexzeilen pro Seite (8.096 freie Bytes pro Seite):

    • Index_Rows_Per_Page = 8096 / (Index_Row_Size + 2)

    Da Indexzeilen keine Seiten umfassen, sollte die Anzahl der Indexzeilen pro Seite auf die nächste ganze Zeile abgerundet werden. Das 2 in der Formel bezieht sich auf den Eintrag der Zeile im Slot-Array der Seite.

  7. Berechnen Sie die Anzahl der Ebenen im Index:

    • Nicht-Blatt_Level = 1 + logarithmus (Index_Rows_Per_Page) (Num_Leaf_Pages / Index_Rows_Per_Page)

    Runden Sie diese Zahl auf die nächste ganze Zahl auf. Dieser Wert enthält nicht die Blattebene des gruppierten Indexes.

  8. Berechnen Sie die Anzahl nicht leerer Seiten im Index:

    • Num_Index_Pages = ∑Level (Num_Leaf_Pages / (Index_Rows_Per_Page^Level))

      wobei 1 <= Level <= Non-leaf_Levels

    Runden Sie jeden Summanden auf die nächste ganze Zahl auf. Stellen Sie sich als einfaches Beispiel einen Index vor, bei dem Num_Leaf_Pages = 1000 and Index_Rows_Per_Page = 25. Die erste Indexebene über der Blattebene speichert 1.000 Indexzeilen, also eine Indexzeile pro Blattseite, und 25 Indexzeilen können pro Seite passen. Dies bedeutet, dass 40 Seiten erforderlich sind, um diese 1.000 Indexzeilen zu speichern. Die nächste Ebene des Indexes muss 40 Zeilen speichern. Dies bedeutet, dass es zwei Seiten erfordert. Die letzte Ebene des Indexes muss zwei Zeilen speichern. Dies bedeutet, dass eine Seite erforderlich ist. Dadurch ergibt sich eine Anzahl von 43 Nichtblatt-Indexseiten. Wenn Sie diese Werte in den oben genannten Formeln verwenden, ergibt sich Folgendes:

    • Nicht-Blatt_Ebenen = 1 + log(25) (1000 / 25) = 3

    • Num_Index_Pages = 1000/(25^3)+ 1000/(25^2) + 1000/(25^1) = 1 + 2 + 40 = 43, was der Anzahl der Seiten in diesem Beispiel entspricht.

  9. Berechnen sie die Größe des Indexes (8.192 Bytes pro Seite):

    • Index_Speicherplatz_Verwendet = 8192 x Anzahl_Index_Seiten

Schritt 3. Summe der berechneten Werte

Addieren Sie die Werte, die in den beiden vorherigen Schritten erzielt wurden:

  • Größe des gruppierten Indexes (in Bytes) = Leaf_Space_Used + Index_Space_used

Diese Berechnung berücksichtigt nicht die folgenden Bedingungen:

  • Partitionierung: Der Speicherplatzaufwand bei der Partitionierung ist minimal, aber komplex zu berechnen. Es ist nicht wichtig, es einzuschließen.

  • Zuordnungsseiten: Es gibt mindestens eine IAM-Seite, die verwendet wird, um die einem Heap zugeordneten Seiten nachzuverfolgen. Der Platzaufwand ist minimal, und es gibt keinen Algorithmus, um genau zu berechnen, wie viele IAM-Seiten verwendet werden.

  • Werte für große Objekte (LOB): Der Algorithmus, der genau bestimmt, wie viel Speicherplatz verwendet wird, um die LOB-Datentypen varchar(max), varbinary(max), nvarchar(max), Text, ntext, XML und Bildwerte zu speichern, ist komplex. Es reicht aus, nur die durchschnittliche Größe der erwarteten LOB-Werte hinzuzufügen, mit Num_Rows zu multiplizieren und dies zur Gesamtgröße des gruppierten Indexes hinzuzufügen.

  • Komprimierung: Sie können die Größe eines komprimierten Indexes nicht vorab berechnen.

  • Spalten mit geringem Abstand: Informationen zu den Platzanforderungen von Spalten mit geringem Abstand finden Sie unter Verwenden von Spalten mit geringem Abstand.

Verwandte Inhalte

  • Last updated on