Schätzen der Größe eines gruppierten Indexes
Mit den folgenden Schritten können Sie den Umfang des Speicherplatzes schätzen, der zum Speichern eines gruppierten Indexes erforderlich ist:
Berechnen des Speicherplatzes, der zum Speichern der Daten in der Blattebene des gruppierten Indexes erforderlich ist.
Berechnen des Speicherplatzes, der zum Speichern von Indexinformationen für den gruppierten Index verwendet wird.
Addieren der berechneten Werte.
Schritt 1.Berechnen des Speicherplatzes, der zum Speichern der Daten in der Blattebene verwendet wird
Geben Sie die Anzahl der Zeilen an, die die Tabelle enthalten wird:
Num_Rows = Anzahl der Zeilen in der Tabelle
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 = Gesamtanzahl der Spalten (mit fester und variabler Länge)
Fixed_Data_Size = Gesamtzahl der Bytes in allen Spalten fester Länge
Num_Variable_Cols = Anzahl der Spalten variabler Länge
Max_Var_Size = Maximale Bytegröße aller Spalten variabler Länge
Wenn der gruppierte Index nicht eindeutig ist, berücksichtigen Sie die uniqueifier-Spalte:
Die Uniqueifier-Spalte ist eine Spalte variabler Länge mit NULL-Zulässigkeit. Sie ist in Spalten Nicht-NULL und 4 Byte lang, deren Schlüsselwerte nicht eindeutig sind. 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_Cols + 1
Max_Var_Size = Max_Var_Size + 4
Diese Änderungen gehen davon aus, dass alle Werte nicht eindeutig sind.
Ein Teil der Zeile, der als NULL-Bitmuster bezeichnet wird, ist für das Verwalten der NULL-Zulässigkeit der Spalte zugeordnet. 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.
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 ***Max\_Var\_Size***-Wert mithilfe dieses Prozentsatzes anpassen, um einen genaueren Schätzwert für die Gesamtgröße der Tabelle zu erhalten.
<table>
<colgroup>
<col style="width: 100%" />
</colgroup>
<thead>
<tr class="header">
<th><img src="images/ms366339.alert_note(SQL.110).gif" title="Hinweis" alt="Hinweis" /><strong>Hinweis</strong></th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td><p>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 kombinierte Breite kann jedoch den Grenzwert von 8.060 Byte in einer Tabelle überschreiten.</p></td>
</tr>
</tbody>
</table>
Wenn keine Spalten variabler Länge vorhanden sind, legen Sie ***Variable\_Data\_Size*** auf 0 fest.
Berechnen Sie die Gesamtzeilenlänge:
Row_Size = Fixed_Data_Size + Variable_Data_Size + Null_Bitmap + 4
Der Wert 4 ist der Zeilenüberschriftenaufwand der Datenzeile.
Berechnen Sie die Anzahl der Zeilen pro Seite (8096 freie Byte pro Seite):
Rows_Per_Page = 8096 / (Row_Size + 2)
Da sich eine Zeile nicht auf zwei Seiten erstreckt, muss die Anzahl der Zeilen pro Seite auf die nächste ganze Zeile abgerundet werden. Der Wert 2 in der Formel bezieht sich auf den Eingang der Zeile in das Slotarray der Seite.
Berechnen Sie die Anzahl der zugeordneten 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 sich eine Zeile nicht auf zwei Seiten erstreckt, muss die Anzahl der Zeilen pro Seite auf die nächste ganze Zeile abgerundet werden. Mit ansteigendem Füllfaktor werden mehr Daten auf jeder Seite gespeichert, und die Anzahl der Seiten nimmt ab. Der Wert 2 in der Formel bezieht sich auf den Eingang der Zeile in das Slotarray der Seite.
Berechnen Sie die Anzahl der Seiten, die zum Speichern aller Zeilen benötigt werden:
Num_Leaf_Pages = Num_Rows / (Rows_Per_Page - Free_Rows_Per_Page)
Die geschätzte Seitenanzahl muss auf die nächste ganze Seite aufgerundet werden.
Berechnen Sie den Umfang des Speicherplatzes, der zum Speichern der Daten in der Blattebene erforderlich ist (insgesamt 8192 Byte pro Seite):
Leaf_space_used* = 8192 x *Num_Leaf_Pages
Schritt 2.Berechnen des Speicherplatzes, der zum Speichern der Indexinformationen verwendet wird
Mit den folgenden Schritten können Sie den Umfang des Speicherplatzes schätzen, der zum Speichern der oberen Ebenen des Indexes erforderlich ist:
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 = Gesamtanzahl der Schlüsselspalten (fester Länge und variabler Länge)
Fixed_Key_Size = Gesamtzahl der Bytes in allen Schlüsselspalten fester Länge
Num_Variable_Key_Cols = Anzahl der Schlüsselspalten variabler Länge
Max_Var_Key_Size = Maximale Bytegröße aller Schlüsselspalten variabler Länge
Berücksichtigen Sie ggf. den Uniqueifier, der erforderlich ist, wenn der Index nicht eindeutig ist:
Die Uniqueifier-Spalte ist eine Spalte variabler Länge mit NULL-Zulässigkeit. Sie ist in Spalten Nicht-NULL und 4 Byte lang, deren Indexschlüsselwerte nicht eindeutig sind. 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_Cols = Num_Key_Cols + 1
Num_Variable_Key_Cols = Num_Variable_Key_Cols + 1
Max_Var_Key_Size = Max_Var_Key_Size + 4
Diese Änderungen gehen davon aus, dass alle Werte nicht eindeutig sind.
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 Spalten vorhanden sind, die NULL-Werte zulassen, legen Sie Index_Null_Bitmap auf 0 fest.
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 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 variabler Länge verwendet wird, können Sie den ***Max\_Var\_Key\_Size***-Wert mithilfe dieses Prozentsatzes anpassen, um einen genaueren Schätzwert für die Gesamtgröße der Tabelle zu erhalten.
Wenn keine Spalten variabler Länge vorhanden sind, legen Sie ***Variable\_Key\_Size*** auf 0 fest.
Berechnen Sie die Länge der Indexzeile:
Index_Row_Size = Fixed_Key_Size + Variable_Key_Size + Index_Null_Bitmap + 1 (für Zeilenüberschriftenaufwand einer Indexzeile) + 6 (für ID-Zeiger der untergeordneten Seite)
Berechnen Sie die Anzahl der Indexzeilen pro Seite (8096 freie Byte pro Seite):
Index_Rows_Per_Page = 8096 / (Index_Row_Size + 2)
Da sich eine Indexzeile nicht auf zwei Seiten erstreckt, muss die Anzahl der Indexzeilen 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.
Berechnen Sie die Anzahl der Ebenen im Index:
Non-leaf_Levels = 1 + log Index_Rows_Per_Page (Num_Leaf_Pages / Index_Rows_Per_Page)
Runden Sie diese Zahl auf die nächste ganze Zahl auf. Dieser Wert schließt die Blattebene des gruppierten Index nicht mit ein.
Berechnen Sie die Anzahl der inneren Knotenseiten im Index:
Num_Index_Pages =∑Level (Num_Leaf_Pages / (Index_Rows_Per_PageLevel))
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 und ***Index\_Rows\_Per\_Page*** = 25 gilt. Die erste Indexebene über der Blattebene speichert 1.000 Indexzeilen, dies bedeutet eine Indexzeile pro Blattseite. Dabei passen 25 Indexzeilen auf eine Seite. Dies bedeutet, dass 40 Seiten zum Speichern dieser 1.000 Indexzeilen erforderlich sind. Die nächste Ebene des Index muss 40 Zeilen speichern. Dies bedeutet, dass 2 Seiten erforderlich sind. Die letzte Ebene des Index muss zwei Zeilen speichern. Dies bedeutet, dass eine Seite erforderlich ist. Daraus ergeben sich 43 innere Knotenseiten im Index. Wenn Sie diese Werte in den oben genannten Formeln verwenden, ergibt sich Folgendes:
***Non-leaf\_Levels*** = 1 + log25 (1000 / 25) = 3
***Num\_Index\_Pages*** = 1000/(253)+ 1000/(252) + 1000/(251) = 1 + 2 + 40 = 43. Dies ist die Anzahl der im Beispiel beschriebenen Seiten.
- Berechnen Sie die Größe des Index (insgesamt 8.192 Bytes pro Seite):
Index_Space_Used* = 8192 x *Num_Index_Pages
Schritt 3.Addieren der berechneten Werte
Addieren Sie die Werte, die in den beiden vorherigen Schritten abgerufen wurden:
Größe des gruppierten Indexes (in Bytes) = Leaf_Space_Used + Index_Space_used
In dieser Berechnung wird Folgendes nicht berücksichtigt:
Partitionierung
Der Speicherplatzaufwand aus der Partitionierung ist geringfügig, seine Berechnung jedoch komplex. Er muss nicht berücksichtigt werden.
Zuordnungsseiten
Mindestens eine IAM-Seite wird zum Nachverfolgen der für einen Heap zugeordneten Seiten verwendet, der Speicherplatzaufwand ist jedoch nur minimal. Außerdem ist kein Algorithmus verfügbar, um deterministisch genau zu berechnen, wie viele IAM-Seiten verwendet werden.
LOB-Werte (Large Object)
Der Algorithmus zum Berechnen des genauen Speicherplatzes, der zum Speichern der Werte der LOB-Datentypen varchar(max), varbinary(max), nvarchar(max), text, ntext, xml und image erforderlich ist, ist komplex. Es ist ausreichend, einfach die durchschnittliche Größe der erwarteten LOB-Werte zu addieren, diese mit Num_Rows zu multiplizieren und das Ergebnis dann zur Gesamtgröße des gruppierten Indexes zu addieren.
Komprimierung
Sie können die Größe eines komprimierten Index nicht im Vorfeld berechnen.
Spalten mit geringer Dichte
Informationen zu den Speicherplatzanforderungen von Spalten mit geringer Dichte finden Sie unter Verwenden von Spalten mit geringer Dichte.
Siehe auch
Konzepte
Beschreibung von gruppierten und nicht gruppierten Indizes
Schätzen der Größe einer Tabelle
Erstellen nicht gruppierter Indizes
Schätzen der Größe eines nicht gruppierten Index
Schätzen der Größe eines Heaps