sys.dm_db_index_physical_stats (Transact-SQL)sys.dm_db_index_physical_stats (Transact-SQL)

S’APPLIQUE À : ouiSQL Server (à partir de 2008) ouiAzure SQL Database nonAzure SQL Data Warehouse nonParallel Data Warehouse APPLIES TO: yesSQL Server (starting with 2008) yesAzure SQL Database noAzure SQL Data Warehouse noParallel Data Warehouse

Renvoie les informations de taille et de fragmentation pour les données et les index de la table ou de la vue spécifiée dans SQL ServerSQL Server.Returns size and fragmentation information for the data and indexes of the specified table or view in SQL ServerSQL Server. Pour un index, une ligne est retournée pour chaque niveau de l'arbre B (B-tree) dans chaque partition.For an index, one row is returned for each level of the B-tree in each partition. Pour un segment de mémoire, une ligne est retournée pour l'unité d'allocation IN_ROW_DATA de chaque partition.For a heap, one row is returned for the IN_ROW_DATA allocation unit of each partition. Pour les données LOB, une ligne est retournée pour l'unité d'allocation LOB_DATA de chaque partition.For large object (LOB) data, one row is returned for the LOB_DATA allocation unit of each partition. S'il existe des données en dépassement de capacité des lignes dans la table, une ligne est retournée pour l'unité d'allocation ROW_OVERFLOW_DATA dans chaque partition.If row-overflow data exists in the table, one row is returned for the ROW_OVERFLOW_DATA allocation unit in each partition. Ne retourne pas d'informations sur les index ColumnStore xVelocity avec mémoire optimisée.Does not return information about xVelocity memory optimized columnstore indexes.

Important

Si vous interrogez sys.dm_db_index_physical_stats sur une instance de serveur qui héberge un Always On réplica secondaire lisible, vous pouvez rencontrer un problème de blocage REDO.If you query sys.dm_db_index_physical_stats on a server instance that is hosting an Always On readable secondary replica, you might encounter a REDO blocking issue. Ce problème est dû au fait que la vue de gestion dynamique acquiert un verrou IS sur la table ou la vue utilisateur spécifiée qui peut bloquer les demandes d'un thread de phase de restauration par progression concernant un verrou X sur la table ou vue utilisateur en question.This is because this dynamic management view acquires an IS lock on the specified user table or view that can block requests by a REDO thread for an X lock on that user table or view.

Sys.dm_db_index_physical_stats ne retourne pas d’informations sur les index optimisés en mémoire.sys.dm_db_index_physical_stats does not return information about memory-optimized indexes. Pour plus d’informations sur l’utilisation d’un index optimisé en mémoire, consultez sys.dm_db_xtp_index_stats (Transact-SQL).For information about memory-optimized index use, see sys.dm_db_xtp_index_stats (Transact-SQL).

Icône de lien de rubrique Conventions de la syntaxe Transact-SQLTopic link icon Transact-SQL Syntax Conventions

SyntaxeSyntax

  
sys.dm_db_index_physical_stats (   
    { database_id | NULL | 0 | DEFAULT }  
  , { object_id | NULL | 0 | DEFAULT }  
  , { index_id | NULL | 0 | -1 | DEFAULT }  
  , { partition_number | NULL | 0 | DEFAULT }  
  , { mode | NULL | DEFAULT }  
)  

ArgumentsArguments

database_id | NULL | 0 | DEFAULTdatabase_id | NULL | 0 | DEFAULT
Est l’ID de la base de données.Is the ID of the database. database_id est smallint.database_id is smallint. Les entrées autorisées sont l'ID d'une base de données ou la valeur NULL, 0 ou DEFAULT.Valid inputs are the ID number of a database, NULL, 0, or DEFAULT. La valeur par défaut est 0.The default is 0. Les valeurs NULL, 0 et DEFAULT sont des valeurs équivalentes dans ce contexte.NULL, 0, and DEFAULT are equivalent values in this context.

Spécifiez NULL pour retourner des informations concernant toutes les bases de données de l'instance de SQL ServerSQL Server.Specify NULL to return information for all databases in the instance of SQL ServerSQL Server. Si vous spécifiez NULL pour database_id, vous devez également spécifier NULL pour object_id, index_id, et partition_number.If you specify NULL for database_id, you must also specify NULL for object_id, index_id, and partition_number.

La fonction intégrée DB_ID peut être spécifiée.The built-in function DB_ID can be specified. Si vous utilisez DB_ID sans spécifier de nom de base de données, le niveau de compatibilité de la base de données active doit être égal à 90 ou plus.When using DB_ID without specifying a database name, the compatibility level of the current database must be 90 or greater.

object_id | NULL | 0 | DEFAULTobject_id | NULL | 0 | DEFAULT
ID d’objet de la table ou vue de l’index se trouve sur.Is the object ID of the table or view the index is on. l’object_id est int.object_id is int.

Les entrées autorisées sont l'ID d'une table et d'une vue ou la valeur NULL, 0 ou DEFAULT.Valid inputs are the ID number of a table and view, NULL, 0, or DEFAULT. La valeur par défaut est 0.The default is 0. Les valeurs NULL, 0 et DEFAULT sont des valeurs équivalentes dans ce contexte.NULL, 0, and DEFAULT are equivalent values in this context. En tant que de SQL Server 2016 (13.x)SQL Server 2016 (13.x), les entrées valides incluent également le nom de file d’attente service broker ou le nom de table interne de file d’attente.As of SQL Server 2016 (13.x)SQL Server 2016 (13.x), valid inputs also include the service broker queue name or the queue internal table name. Lorsque les paramètres par défaut sont appliquées (par exemple, tous les objets, tous les index, etc.), les informations de fragmentation pour toutes les files d’attente sont inclus dans le jeu de résultats.When default parameters are applied (i.e. all objects, all indexes, etc), fragmentation information for all queues are included in the result set.

Spécifiez la valeur NULL pour retourner des informations sur toutes les tables et les vues de la base de données spécifiée.Specify NULL to return information for all tables and views in the specified database. Si vous spécifiez NULL pour object_id, vous devez également spécifier NULL pour index_id et partition_number.If you specify NULL for object_id, you must also specify NULL for index_id and partition_number.

index_id | 0 | NULL | -1 | DEFAULTindex_id | 0 | NULL | -1 | DEFAULT
Identificateur de l’index.Is the ID of the index. index_id est int. Les entrées autorisées sont l’ID d’un index, 0 si object_id est un segment, NULL, -1 ou DEFAULT.index_id is int. Valid inputs are the ID number of an index, 0 if object_id is a heap, NULL, -1, or DEFAULT. La valeur par défaut est -1.The default is -1. NULL, -1 et par défaut sont des valeurs équivalentes dans ce contexte.NULL, -1, and DEFAULT are equivalent values in this context.

Spécifiez la valeur NULL pour retourner des informations sur tous les index d'une table de base ou d'une vue.Specify NULL to return information for all indexes for a base table or view. Si vous spécifiez NULL pour index_id, vous devez également spécifier NULL pour partition_number.If you specify NULL for index_id, you must also specify NULL for partition_number.

partition_number | NULL | 0 | DEFAULTpartition_number | NULL | 0 | DEFAULT
Numéro de partition dans l'objet.Is the partition number in the object. partition_number est int. Les entrées valides sont les partion_number d’un index ou le segment, NULL, 0 ou DEFAULT.partition_number is int. Valid inputs are the partion_number of an index or heap, NULL, 0, or DEFAULT. La valeur par défaut est 0.The default is 0. Les valeurs NULL, 0 et DEFAULT sont des valeurs équivalentes dans ce contexte.NULL, 0, and DEFAULT are equivalent values in this context.

Spécifiez NULL pour retourner des informations sur toutes les partitions de l'objet propriétaire.Specify NULL to return information for all partitions of the owning object.

partition_number est basé sur 1.partition_number is 1-based. Un index non partitionné ou un segment a partition_number défini sur 1.A nonpartitioned index or heap has partition_number set to 1.

mode | NULL | PAR DÉFAUTmode | NULL | DEFAULT
Nom du mode.Is the name of the mode. mode Spécifie le niveau d’analyse qui est utilisé pour obtenir des statistiques.mode specifies the scan level that is used to obtain statistics. mode est sysname.mode is sysname. Les entrées autorisées sont DEFAULT, NULL, LIMITED, SAMPLED ou DETAILED.Valid inputs are DEFAULT, NULL, LIMITED, SAMPLED, or DETAILED. La valeur par défaut (NULL) est LIMITED.The default (NULL) is LIMITED.

Table retournéeTable Returned

Nom de colonneColumn name Type de donnéesData type DescriptionDescription
database_iddatabase_id smallintsmallint ID de base de données de la table ou de la vue.Database ID of the table or view.
object_idobject_id Intint ID d'objet de la table ou de la vue vers laquelle pointe l'index.Object ID of the table or view that the index is on.
index_idindex_id Intint ID d'index d'un index.Index ID of an index.

0 = Segment de mémoire.0 = Heap.
partition_numberpartition_number Intint Numéro de partition de base 1 dans l'objet propriétaire : une table, une vue ou un index.1-based partition number within the owning object; a table, view, or index.

1 = Index ou segment de mémoire non partitionné.1 = Nonpartitioned index or heap.
index_type_descindex_type_desc nvarchar(60)nvarchar(60) Description du type d’index :Description of the index type:

HEAPHEAP

CLUSTERED INDEXCLUSTERED INDEX

NONCLUSTERED INDEXNONCLUSTERED INDEX

PRIMARY XML INDEXPRIMARY XML INDEX

INDEX ÉTENDUEXTENDED INDEX

XML INDEXXML INDEX

MAPPAGE des INDEX COLUMNSTORE (interne)COLUMNSTORE MAPPING INDEX (internal)

INDEX de DELETEBUFFER COLUMNSTORE (interne)COLUMNSTORE DELETEBUFFER INDEX (internal)

INDEX de DELETEBITMAP COLUMNSTORE (interne)COLUMNSTORE DELETEBITMAP INDEX (internal)
hobt_idhobt_id bigintbigint Segment de mémoire ou l’ID de B-Tree de l’index ou de la partition.Heap or B-Tree ID of the index or partition.

En plus de retourner hobt_id des index définis par l’utilisateur, il retourne également hobt_id des index columnstore interne.Besides returning the hobt_id of user-defined indexes, this also returns the hobt_id of the internal columnstore indexes.
alloc_unit_type_descalloc_unit_type_desc nvarchar(60)nvarchar(60) Description du type d'unité d'allocation :Description of the allocation unit type:

IN_ROW_DATAIN_ROW_DATA

LOB_DATALOB_DATA

ROW_OVERFLOW_DATAROW_OVERFLOW_DATA

L’unité d’allocation LOB_DATA contient les données stockées dans des colonnes de type texte, ntext, image, varchar (max), nvarchar (max), varbinary (max), et xml.The LOB_DATA allocation unit contains the data that is stored in columns of type text, ntext, image, varchar(max), nvarchar(max), varbinary(max), and xml. Pour plus d’informations, consultez Types de données (Transact-SQL).For more information, see Data Types (Transact-SQL).

L’unité d’allocation ROW_OVERFLOW_DATA contient les données stockées dans des colonnes de type varchar (n), nvarchar (n), varbinary (n), et sql_ variante qui ont été déplacées hors ligne.The ROW_OVERFLOW_DATA allocation unit contains the data that is stored in columns of type varchar(n), nvarchar(n), varbinary(n), and sql_variant that have been pushed off-row.
index_depthindex_depth tinyinttinyint Nombre de niveaux d'index.Number of index levels.

1 = Segment de mémoire ou unité d'allocation LOB_DATA ou ROW_OVERFLOW_DATA.1 = Heap, or LOB_DATA or ROW_OVERFLOW_DATA allocation unit.
index_levelindex_level tinyinttinyint Niveau actuel de l'index.Current level of the index.

0 pour des index de niveau feuille, des segments de mémoire et des unités d'allocation LOB_DATA ou ROW_OVERFLOW_DATA.0 for index leaf levels, heaps, and LOB_DATA or ROW_OVERFLOW_DATA allocation units.

Supérieur à 0 pour les index de niveaux non-feuille.Greater than 0 for nonleaf index levels. index_level sera le plus élevé au niveau racine d’un index.index_level will be the highest at the root level of an index.

Les niveaux non-feuille des index sont uniquement traitée lorsque mode = DETAILED.The nonleaf levels of indexes are only processed when mode = DETAILED.
avg_fragmentation_in_percentavg_fragmentation_in_percent floatfloat Fragmentation logique des index ou fragmentation de l'étendue des segments de mémoire dans l'unité d'allocation IN_ROW_DATA.Logical fragmentation for indexes, or extent fragmentation for heaps in the IN_ROW_DATA allocation unit.

La valeur est mesurée en pourcentage et prend en compte plusieurs fichiers.The value is measured as a percentage and takes into account multiple files. Pour les définitions de la fragmentation logique et de la fragmentation de l'étendue, consultez la section Notes.For definitions of logical and extent fragmentation, see Remarks.

0 pour les unités d'allocation LOB_DATA et ROW_OVERFLOW_DATA.0 for LOB_DATA and ROW_OVERFLOW_DATA allocation units.

NULL pour les segments de mémoire lorsque mode = SAMPLED.NULL for heaps when mode = SAMPLED.
fragment_countfragment_count bigintbigint Nombre de fragments dans le niveau feuille d'une unité d'allocation IN_ROW_DATA.Number of fragments in the leaf level of an IN_ROW_DATA allocation unit. Pour plus d'informations sur les fragments, consultez la section Notes.For more information about fragments, see Remarks.

NULL pour les niveaux non-feuille d'un index et les unités d'allocation LOB_DATA ou ROW_OVERFLOW_DATA.NULL for nonleaf levels of an index, and LOB_DATA or ROW_OVERFLOW_DATA allocation units.

NULL pour les segments de mémoire lorsque mode = SAMPLED.NULL for heaps when mode = SAMPLED.
avg_fragment_size_in_pagesavg_fragment_size_in_pages floatfloat Nombre moyen de pages dans un fragment dans le niveau feuille d'une unité d'allocation IN_ROW_DATA.Average number of pages in one fragment in the leaf level of an IN_ROW_DATA allocation unit.

NULL pour les niveaux non-feuille d'un index et les unités d'allocation LOB_DATA ou ROW_OVERFLOW_DATA.NULL for nonleaf levels of an index, and LOB_DATA or ROW_OVERFLOW_DATA allocation units.

NULL pour les segments de mémoire lorsque mode = SAMPLED.NULL for heaps when mode = SAMPLED.
page_countpage_count bigintbigint Nombre total d'index ou de pages de données.Total number of index or data pages.

Pour un index, il s'agit du nombre total de pages d'index au niveau actuel de l'arbre B (B-tree) dans l'unité d'allocation IN_ROW_DATA.For an index, the total number of index pages in the current level of the b-tree in the IN_ROW_DATA allocation unit.

Pour un segment de mémoire, il s'agit du nombre total de pages de données dans l'unité d'allocation IN_ROW_DATA.For a heap, the total number of data pages in the IN_ROW_DATA allocation unit.

Pour les unités d'allocation LOB_DATA or ROW_OVERFLOW_DATA, il s'agit du nombre total de pages dans l'unité d'allocation.For LOB_DATA or ROW_OVERFLOW_DATA allocation units, total number of pages in the allocation unit.
avg_page_space_used_in_percentavg_page_space_used_in_percent floatfloat Pourcentage moyen d'espace de stockage disponible utilisé dans toutes les pages.Average percentage of available data storage space used in all pages.

Pour un index, la moyenne s'applique au niveau actuel de l'arbre B (B-tree) dans l'unité d'allocation IN_ROW_DATA.For an index, average applies to the current level of the b-tree in the IN_ROW_DATA allocation unit.

Pour un segment de mémoire, il s'agit de la moyenne de toutes les pages de données dans l'unité d'allocation IN_ROW_DATA.For a heap, the average of all data pages in the IN_ROW_DATA allocation unit.

Pour les unités d'allocation LOB_DATA or ROW_OVERFLOW_DATA, il s'agit de la moyenne de toutes les pages dans l'unité d'allocation.For LOB_DATA or ROW_OVERFLOW DATA allocation units, the average of all pages in the allocation unit.

La valeur NULL lorsque mode = LIMITED.NULL when mode = LIMITED.
record_countrecord_count bigintbigint Nombre total d'enregistrements.Total number of records.

Pour un index, le nombre total d'enregistrements s'applique au niveau actuel de l'arbre B (B-tree) dans l'unité d'allocation IN_ROW_DATA.For an index, total number of records applies to the current level of the b-tree in the IN_ROW_DATA allocation unit.

Pour un segment de mémoire, il s'agit du nombre total d'enregistrements dans l'unité d'allocation IN_ROW_DATA.For a heap, the total number of records in the IN_ROW_DATA allocation unit.

Remarque : Pour un segment de mémoire, le nombre d’enregistrements renvoyés par cette fonction ne peut pas correspondre le nombre de lignes qui sont retournées en exécutant une commande SELECT COUNT (*) sur le tas.Note: For a heap, the number of records returned from this function might not match the number of rows that are returned by running a SELECT COUNT(*) against the heap. Cela est dû au fait qu'une ligne peut contenir plusieurs enregistrements.This is because a row may contain multiple records. Par exemple, lors de certaines mises à jour, une ligne de segment unique peut comporter un enregistrement de transfert et un enregistrement transféré suite à l'opération de mise à jour.For example, under some update situations, a single heap row may have a forwarding record and a forwarded record as a result of the update operation. Par ailleurs, la plupart des lignes LOB de grande taille sont fractionnées en plusieurs enregistrements dans le stockage LOB_DATA.Also, most large LOB rows are split into multiple records in LOB_DATA storage.

Pour les unités d'allocation LOB_DATA or ROW_OVERFLOW_DATA, il s'agit du nombre total d'enregistrements dans toute l'unité d'allocation.For LOB_DATA or ROW_OVERFLOW_DATA allocation units, the total number of records in the complete allocation unit.

La valeur NULL lorsque mode = LIMITED.NULL when mode = LIMITED.
ghost_record_countghost_record_count bigintbigint Nombre d'enregistrements fantômes prêts à être supprimés par la tâche de nettoyage des enregistrements fantômes dans l'unité d'allocation.Number of ghost records ready for removal by the ghost cleanup task in the allocation unit.

0 pour les niveaux non-feuille d'un index dans l'unité d'allocation IN_ROW_DATA.0 for nonleaf levels of an index in the IN_ROW_DATA allocation unit.

La valeur NULL lorsque mode = LIMITED.NULL when mode = LIMITED.
version_ghost_record_countversion_ghost_record_count bigintbigint Nombre d'enregistrements fantômes retenus par une transaction d'isolation d'instantané en attente dans une unité d'allocation.Number of ghost records retained by an outstanding snapshot isolation transaction in an allocation unit.

0 pour les niveaux non-feuille d'un index dans l'unité d'allocation IN_ROW_DATA.0 for nonleaf levels of an index in the IN_ROW_DATA allocation unit.

La valeur NULL lorsque mode = LIMITED.NULL when mode = LIMITED.
min_record_size_in_bytesmin_record_size_in_bytes Intint Taille minimale des enregistrements en octets.Minimum record size in bytes.

Pour un index, la taille minimale des enregistrements s'applique au niveau actuel de l'arbre B (B-tree) dans l'unité d'allocation IN_ROW_DATA.For an index, minimum record size applies to the current level of the b-tree in the IN_ROW_DATA allocation unit.

Pour un segment de mémoire, il s'agit de la taille minimale des enregistrements dans l'unité d'allocation IN_ROW_DATA.For a heap, the minimum record size in the IN_ROW_DATA allocation unit.

Pour les unités d'allocation LOB_DATA ou ROW_OVERFLOW_DATA, il s'agit de la taille minimale des enregistrements dans toute l'unité d'allocation.For LOB_DATA or ROW_OVERFLOW_DATA allocation units, the minimum record size in the complete allocation unit.

La valeur NULL lorsque mode = LIMITED.NULL when mode = LIMITED.
max_record_size_in_bytesmax_record_size_in_bytes Intint Taille maximale des enregistrements en octets.Maximum record size in bytes.

Pour un index, la taille maximale des enregistrements s'applique au niveau actuel de l'arbre B (B-tree) dans l'unité d'allocation IN_ROW_DATA.For an index, the maximum record size applies to the current level of the b-tree in the IN_ROW_DATA allocation unit.

Pour un segment de mémoire, il s'agit de la taille maximale des enregistrements dans l'unité d'allocation IN_ROW_DATA.For a heap, the maximum record size in the IN_ROW_DATA allocation unit.

Pour les unités d'allocation LOB_DATA ou ROW_OVERFLOW_DATA, il s'agit de la taille maximale des enregistrements dans toute l'unité d'allocation.For LOB_DATA or ROW_OVERFLOW_DATA allocation units, the maximum record size in the complete allocation unit.

La valeur NULL lorsque mode = LIMITED.NULL when mode = LIMITED.
avg_record_size_in_bytesavg_record_size_in_bytes floatfloat Taille moyenne des enregistrements en octets.Average record size in bytes.

Pour un index, la taille moyenne des enregistrements s'applique au niveau actuel de l'arbre B (B-tree) dans l'unité d'allocation IN_ROW_DATA.For an index, the average record size applies to the current level of the b-tree in the IN_ROW_DATA allocation unit.

Pour un segment de mémoire, il s'agit de la taille moyenne des enregistrements dans l'unité d'allocation IN_ROW_DATA.For a heap, the average record size in the IN_ROW_DATA allocation unit.

Pour les unités d'allocation LOB_DATA ou ROW_OVERFLOW_DATA, il s'agit de la taille moyenne des enregistrements dans toute l'unité d'allocation.For LOB_DATA or ROW_OVERFLOW_DATA allocation units, the average record size in the complete allocation unit.

La valeur NULL lorsque mode = LIMITED.NULL when mode = LIMITED.
forwarded_record_countforwarded_record_count bigintbigint Nombre d'enregistrements d'un segment de mémoire qui contiennent des pointeurs avant vers un autre emplacement de données.Number of records in a heap that have forward pointers to another data location. (Cet état se produit pendant une mise à jour, lorsque l'espace disponible est insuffisant pour stocker la nouvelle ligne à l'emplacement d'origine.)(This state occurs during an update, when there is not enough room to store the new row in the original location.)

NULL pour toute unité d'allocation différente des unités d'allocation IN_ROW_DATA d'un segment de mémoire.NULL for any allocation unit other than the IN_ROW_DATA allocation units for a heap.

NULL pour les segments de mémoire lorsque mode = LIMITED.NULL for heaps when mode = LIMITED.
compressed_page_countcompressed_page_count bigintbigint Nombre de pages compressées.The number of compressed pages.

Pour les segments de mémoire, les pages allouées récemment ne sont pas compressées avec le mode PAGE.For heaps, newly allocated pages are not PAGE compressed. Un segment de mémoire est compressé avec le mode PAGE sous deux conditions spéciales : lorsque les données sont importées en bloc ou lorsqu'un segment de mémoire est reconstruit.A heap is PAGE compressed under two special conditions: when data is bulk imported or when a heap is rebuilt. Les opérations DML par défaut qui provoquent des allocations de page ne sont pas compressées avec le mode PAGE.Typical DML operations that cause page allocations will not be PAGE compressed. Reconstruisez un segment de mémoire lorsque la valeur compressed_page_count dépasse le seuil que vous souhaitez.Rebuild a heap when the compressed_page_count value grows larger than the threshold you want.

Pour les tables qui ont un index cluster, la valeur compressed_page_count indique l'efficacité de la compression PAGE.For tables that have a clustered index, the compressed_page_count value indicates the effectiveness of PAGE compression.
hobt_idhobt_id BIGINTbigint S’applique à: SQL ServerSQL Server (SQL Server 2016 (13.x)SQL Server 2016 (13.x) jusqu’à la version actuelle), Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (SQL Server 2016 (13.x)SQL Server 2016 (13.x) through current version), Azure SQL DatabaseAzure SQL Database.

Pour les index columnstore uniquement, il s’agit de l’ID pour un ensemble de lignes qui assure le suivi des données columnstore interne d’une partition.For columnstore indexes only, this is the ID for a rowset that tracks internal columnstore data for a partition. Les ensembles de lignes sont stockées comme données de segments de mémoire ou binaire arborescences.The rowsets are stored as data heaps or binary trees. Ils ont le même ID d’index en tant que l’index columnstore de parent.They have the same index ID as the parent columnstore index. Pour plus d’informations, consultez sys.internal_partitions (Transact-SQL).For more information, see sys.internal_partitions (Transact-SQL).

NULL siNULL if
column_store_delete_buffer_statecolumn_store_delete_buffer_state TINYINTtinyint S’applique à: SQL ServerSQL Server (SQL Server 2016 (13.x)SQL Server 2016 (13.x) jusqu’à la version actuelle), Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (SQL Server 2016 (13.x)SQL Server 2016 (13.x) through current version), Azure SQL DatabaseAzure SQL Database.

0 = NOT_APPLICABLE0 = NOT_APPLICABLE

1 = OPEN1 = OPEN

2 = DRAINAGE2 = DRAINING

3 = VIDAGE3 = FLUSHING

4 = MISE HORS SERVICE4 = RETIRING

5 = PRÊT5 = READY
column_store_delete_buff_state_desccolumn_store_delete_buff_state_desc S’applique à: SQL ServerSQL Server (SQL Server 2016 (13.x)SQL Server 2016 (13.x) jusqu’à la version actuelle), Azure SQL DatabaseAzure SQL Database.Applies to: SQL ServerSQL Server (SQL Server 2016 (13.x)SQL Server 2016 (13.x) through current version), Azure SQL DatabaseAzure SQL Database.

NON valide - l’index de parent n’est pas un index columnstore.NOT VALID -the parent index is not a columnstore index.

Ouvrez - deleters et utilisent scanneurs.OPEN - deleters and scanners use this.

DRAINAGE - deleters sont drainage mais scanneurs toujours l’utiliser.DRAINING - deleters are draining out but scanners still use it.

Le vidage - mémoire tampon est fermé et lignes dans la mémoire tampon sont écrits dans la bitmap de suppression.FLUSHING - buffer is closed and rows in the buffer are being written to the delete bitmap.

Mise hors service - lignes dans le tampon de suppression fermé ont été écrits dans la bitmap de suppression, mais la mémoire tampon n’a pas été tronquée, car les analyseurs sont toujours l’utiliser.RETIRING - rows in the closed delete buffer have been written to the delete bitmap, but the buffer has not been truncated because scanners are still using it. Nouveaux analyseurs n’avez pas besoin d’utiliser la mémoire tampon de retraite, car la mémoire tampon open est suffisant.New scanners don't need to use the retiring buffer because the open buffer is enough.

PRÊT - cette mémoire tampon de suppression est prêt à être utilisé.READY - This delete buffer is ready for use.

NotesRemarks

La fonction de gestion dynamique sys.dm_db_index_physical_stats remplace l'instruction DBCC SHOWCONTIG.The sys.dm_db_index_physical_stats dynamic management function replaces the DBCC SHOWCONTIG statement.

Modes d'analyseScanning Modes

Le mode d'exécution de la fonction détermine le niveau de l'analyse effectuée pour obtenir les données statistiques utilisées par la fonction.The mode in which the function is executed determines the level of scanning performed to obtain the statistical data that is used by the function. mode est spécifié avec LIMITED, SAMPLED ou DETAILED.mode is specified as LIMITED, SAMPLED, or DETAILED. La fonction traverse les chaînes de pages des unités d'allocation qui composent les partitions spécifiées de la table ou de l'index.The function traverses the page chains for the allocation units that make up the specified partitions of the table or index. Sys.dm_db_index_physical_stats ne nécessite qu’un verrou de table Intent-Shared (IS), quel que soit le mode d’exécution dans.sys.dm_db_index_physical_stats requires only an Intent-Shared (IS) table lock, regardless of the mode that it runs in.

Le mode LIMITED est le mode plus rapide : il analyse le plus petit nombre de pages.The LIMITED mode is the fastest mode and scans the smallest number of pages. Pour un index, seules les pages de niveau parent de l'arbre B (B-tree) (autrement dit, les pages au-dessus du niveau feuille) sont analysées.For an index, only the parent-level pages of the B-tree (that is, the pages above the leaf level) are scanned. Pour un segment de mémoire, les pages PFS et IAM associées sont examinées et les pages de données d'un segment de mémoire sont analysées en mode LIMITED.For a heap, the associated PFS and IAM pages are examined and the data pages of a heap are scanned in LIMITED mode.

En mode LIMITED, compressed_page_count a la valeur NULL, car le Moteur de base de donnéesDatabase Engine recherche uniquement les pages non-feuilles de l’arborescence et les pages IAM et PFS du segment de mémoire.With LIMITED mode, compressed_page_count is NULL because the Moteur de base de donnéesDatabase Engine only scans non-leaf pages of the B-tree and the IAM and PFS pages of the heap. Utilisez le mode SAMPLED pour obtenir une valeur estimée de compressed_page_count et utilisez le mode DETAILED pour obtenir la valeur réelle de compressed_page_count.Use SAMPLED mode to get an estimated value for compressed_page_count, and use DETAILED mode to get the actual value for compressed_page_count. Le mode SAMPLED retourne des statistiques basées sur 1 pour cent d'exemple de toutes les pages dans l'index ou le segment de mémoire.The SAMPLED mode returns statistics based on a 1 percent sample of all the pages in the index or heap. Les résultats en mode SAMPLED doivent être considérés comme étant approximatifs.Results in SAMPLED mode should be regarded as approximate. Si l'index ou le segment de mémoire comporte moins de 10 000 pages, le mode DETAILED est utilisé à la place du mode SAMPLED.If the index or heap has fewer than 10,000 pages, DETAILED mode is used instead of SAMPLED.

Le mode DETAILED analyse toutes les pages et retourne toutes les statistiques.The DETAILED mode scans all pages and returns all statistics.

Les modes sont graduellement plus lents de LIMITED à DETAILED, du fait qu'ils exécutent plus de travail.The modes are progressively slower from LIMITED to DETAILED, because more work is performed in each mode. Pour évaluer rapidement la taille ou le niveau de fragmentation d'une table ou d'un index, utilisez le mode LIMITED.To quickly gauge the size or fragmentation level of a table or index, use the LIMITED mode. Il s'agit du mode le plus rapide qui ne retourne pas de ligne pour chaque niveau non-feuille dans l'unité d'allocation IN_ROW_DATA de l'index.It is the fastest and will not return a row for each nonleaf level in the IN_ROW_DATA allocation unit of the index.

Utilisation de fonctions système pour spécifier des valeurs de paramètresUsing System Functions to Specify Parameter Values

Vous pouvez utiliser la Transact-SQLTransact-SQL fonctions DB_ID et OBJECT_ID pour spécifier une valeur pour le database_id et object_id paramètres.You can use the Transact-SQLTransact-SQL functions DB_ID and OBJECT_ID to specify a value for the database_id and object_id parameters. Toutefois, la transmission de valeurs non valides à ces fonctions peut entraîner des résultats imprévisibles.However, passing values that are not valid to these functions may cause unintended results. Par exemple, si le nom de la base de données ou de l'objet est introuvable car il n'existe pas ou il est mal orthographié, les deux fonctions retournent la valeur NULL.For example, if the database or object name cannot be found because they do not exist or are spelled incorrectly, both functions will return NULL. La fonction sys.dm_db_index_physical_stats interprète NULL comme une valeur générique qui spécifie toutes les bases de données ou tous les objets.The sys.dm_db_index_physical_stats function interprets NULL as a wildcard value specifying all databases or all objects.

En outre, la fonction OBJECT_ID est traitée avant la fonction sys.dm_db_index_physical_stats est appelée et est par conséquent évaluée dans le contexte de la base de données actuelle, pas la base de données spécifié dans database_id.Additionally, the OBJECT_ID function is processed before the sys.dm_db_index_physical_stats function is called and is therefore evaluated in the context of the current database, not the database specified in database_id. Il est possible que la fonction OBJECT_ID retourne une valeur NULL ; ou, si le nom d'objet existe dans le contexte de la base de données active et la base de données spécifiée, un message d'erreur peut être retourné.This behavior may cause the OBJECT_ID function to return a NULL value; or, if the object name exists in both the current database context and the specified database, an error message may be returned. Les exemples suivants présentent ces résultats inattendus.The following examples demonstrate these unintended results.

USE master;  
GO  
-- In this example, OBJECT_ID is evaluated in the context of the master database.   
-- Because Person.Address does not exist in master, the function returns NULL.  
-- When NULL is specified as an object_id, all objects in the database are returned.  
-- The same results are returned when an object that is not valid is specified.  
SELECT * FROM sys.dm_db_index_physical_stats  
    (DB_ID(N'AdventureWorks'), OBJECT_ID(N'Person.Address'), NULL, NULL , 'DETAILED');  
GO  
-- This example demonstrates the results of specifying a valid object name  
-- that exists in both the current database context and  
-- in the database specified in the database_id parameter of the   
-- sys.dm_db_index_physical_stats function.  
-- An error is returned because the ID value returned by OBJECT_ID does not  
-- match the ID value of the object in the specified database.  
CREATE DATABASE Test;  
GO  
USE Test;  
GO  
CREATE SCHEMA Person;  
GO  
CREATE Table Person.Address(c1 int);  
GO  
USE AdventureWorks2012;  
GO  
SELECT * FROM sys.dm_db_index_physical_stats  
    (DB_ID(N'Test'), OBJECT_ID(N'Person.Address'), NULL, NULL , 'DETAILED');  
GO  
-- Clean up temporary database.  
DROP DATABASE Test;  
GO  

Bonne pratiqueBest Practice

Vérifiez systématiquement qu'un ID valide est retourné lorsque vous utilisez DB_ID ou OBJECT_ID.Always make sure that a valid ID is returned when you use DB_ID or OBJECT_ID. Par exemple, lorsque vous utilisez OBJECT_ID, spécifiez un nom en trois parties tel que OBJECT_ID(N'AdventureWorks2012.Person.Address'), ou testez la valeur retournée par les fonctions avant de les utiliser dans la fonction sys.dm_db_index_physical_stats.For example, when you use OBJECT_ID, specify a three-part name such as OBJECT_ID(N'AdventureWorks2012.Person.Address'), or test the value returned by the functions before you use them in the sys.dm_db_index_physical_stats function. Les exemples A et B qui suivent illustrent une méthode sûre pour déterminer des ID de bases de données et d'objets.Examples A and B that follow demonstrate a safe way to specify database and object IDs.

Détection de la fragmentationDetecting Fragmentation

La fragmentation a lieu lors de la modification des données (instructions INSERT, UPDATE et DELETE) effectuées sur la table, et donc dans les index définis sur la table.Fragmentation occurs through the process of data modifications (INSERT, UPDATE, and DELETE statements) that are made against the table and, therefore, to the indexes defined on the table. Comme ces modifications ne sont généralement pas distribuées équitablement entre les lignes de la table et des index, le remplissage de chaque page peut varier dans le temps.Because these modifications are not ordinarily distributed equally among the rows of the table and indexes, the fullness of each page can vary over time. Pour les requêtes qui analysent tout ou partie des index d'une table, ce type de fragmentation peut entraîner des lectures de pages supplémentaires.For queries that scan part or all of the indexes of a table, this kind of fragmentation can cause additional page reads. Cela perturbe l'analyse parallèle des données.This hinders parallel scanning of data.

Le niveau de fragmentation d'un index ou d'un segment de mémoire est affiché dans la colonne avg_fragmentation_in_percent.The fragmentation level of an index or heap is shown in the avg_fragmentation_in_percent column. Pour les segments de mémoire, cette valeur représente la fragmentation de l'étendue du segment.For heaps, the value represents the extent fragmentation of the heap. Pour les index, cette valeur représente la fragmentation logique de l'index.For indexes, the value represents the logical fragmentation of the index. À la différence de DBCC SHOWCONTIG, les algorithmes de calcul de la fragmentation considèrent dans les deux cas l'espace de stockage qui englobe plusieurs fichiers : ils sont donc précis.Unlike DBCC SHOWCONTIG, the fragmentation calculation algorithms in both cases consider storage that spans multiple files and, therefore, are accurate.

Fragmentation logiqueLogical Fragmentation

Pourcentage de pages hors service dans les pages de feuilles d'un index.This is the percentage of out-of-order pages in the leaf pages of an index. Une page non ordonnée est une page pour laquelle la page physique suivante allouée à l’index n’est pas la page désignée par le pointeur de page suivante dans la page feuille actuelle.An out-of-order page is a page for which the next physical page allocated to the index is not the page pointed to by the next-page pointer in the current leaf page.

Fragmentation de l’étendueExtent Fragmentation

Pourcentage d'étendues hors service dans les pages de feuilles d'un segment de mémoire.This is the percentage of out-of-order extents in the leaf pages of a heap. Une étendue est hors service lorsque l'étendue qui contient la page active d'un segment de mémoire n'est pas physiquement l'étendue suivant l'étendue contenant la page précédente.An out-of-order extent is one for which the extent that contains the current page for a heap is not physically the next extent after the extent that contains the previous page.

La valeur de avg_fragmentation_in_percent doit être aussi proche que possible de zéro pour obtenir des performances maximales.The value for avg_fragmentation_in_percent should be as close to zero as possible for maximum performance. Cependant, des valeurs comprises entre 0 et 10 % sont acceptables.However, values from 0 percent through 10 percent may be acceptable. Toutes les méthodes de réduction de la fragmentation (par exemple, la reconstruction, la réorganisation ou la recréation) peuvent s'utiliser pour diminuer ces valeurs.All methods of reducing fragmentation, such as rebuilding, reorganizing, or re-creating, can be used to reduce these values. Pour plus d’informations sur la manière d’analyser le degré de fragmentation d’un index, consultez réorganiser et reconstruire des index.For more information about how to analyze the degree of fragmentation in an index, see Reorganize and Rebuild Indexes.

Réduction de la fragmentation d'un indexReducing Fragmentation in an Index

Lorsqu'un index est fragmenté de telle façon que la fragmentation nuit aux performances des requêtes, il existe trois possibilités de réduction de la fragmentation :When an index is fragmented in a way that the fragmentation is affecting query performance, there are three choices for reducing fragmentation:

  • Supprimer l'index cluster, puis le recréer.Drop and re-create the clustered index.

    Le fait de recréer un index cluster redistribue les données et produit des pages de données complètes.Re-creating a clustered index redistributes the data and results in full data pages. Vous pouvez configurer le niveau de remplissage à l'aide de l'option FILLFACTOR de l'instruction CREATE INDEX.The level of fullness can be configured by using the FILLFACTOR option in CREATE INDEX. Cette méthode présente deux inconvénients : l'index est en mode hors connexion pendant la suppression et la recréation, et l'opération est atomique.The drawbacks in this method are that the index is offline during the drop and re-create cycle, and that the operation is atomic. Si la création de l'index est interrompue, l'index n'est pas recréé.If the index creation is interrupted, the index is not re-created. Pour plus d’informations, consultez CREATE INDEX (Transact-SQL).For more information, see CREATE INDEX (Transact-SQL).

  • Utilisez l'instruction ALTER INDEX REORGANIZE, qui remplace DBCC INDEXDEFRAG, pour réorganiser dans un ordre logique les pages de niveau feuille de l'index.Use ALTER INDEX REORGANIZE, the replacement for DBCC INDEXDEFRAG, to reorder the leaf level pages of the index in a logical order. Du fait qu'il s'agit d'une opération en ligne, l'index est disponible lorsque l'instruction est en cours d'exécution.Because this is an online operation, the index is available while the statement is running. Il est également possible d'interrompre l'opération sans perdre le travail déjà effectué.The operation can also be interrupted without losing work already completed. L'inconvénient de cette méthode est que la réorganisation des données est moins efficace que la reconstruction d'un index et qu'elle ne met pas à jour les statistiques.The drawback in this method is that it does not do as good a job of reorganizing the data as an index rebuild operation, and it does not update statistics.

  • Utilisez l'instruction ALTER INDEX REBUILD, qui remplace DBCC DBREINDEX, pour reconstruire l'index en ligne ou hors ligne.Use ALTER INDEX REBUILD, the replacement for DBCC DBREINDEX, to rebuild the index online or offline. Pour plus d’informations, consultez ALTER INDEX (Transact-SQL).For more information, see ALTER INDEX (Transact-SQL).

La fragmentation seule n'est pas une raison suffisante pour réorganiser ou reconstruire un index.Fragmentation alone is not a sufficient reason to reorganize or rebuild an index. Le principal effet de la fragmentation est le ralentissement de la lecture anticipée lors de l'analyse d'un index.The main effect of fragmentation is that it slows down page read-ahead throughput during index scans. Les temps de réponse sont donc plus longs.This causes slower response times. Si la charge de travail d'une requête sur une table ou un index fragmenté n'implique pas d'analyses car elle concerne essentiellement des recherches de singletons, la suppression de la fragmentation peut n'avoir aucun effet.If the query workload on a fragmented table or index does not involve scans, because the workload is primarily singleton lookups, removing fragmentation may have no effect.

Notes

Exécution de DBCC SHRINKFILE ou DBCC SHRINKDATABASE peut fragmenter si un index est partiellement ou totalement déplacé pendant l’opération de réduction.Running DBCC SHRINKFILE or DBCC SHRINKDATABASE may introduce fragmentation if an index is partly or completely moved during the shrink operation. Par conséquent, si une opération de compactage doit être effectuée, vous devez l'exécuter avant la suppression de la fragmentation.Therefore, if a shrink operation must be performed, you should do it before fragmentation is removed.

Réduction de la fragmentation d'un segment de mémoireReducing Fragmentation in a Heap

Pour réduire la fragmentation de l'étendue d'un segment de mémoire, créez un index cluster sur la table puis supprimez l'index.To reduce the extent fragmentation of a heap, create a clustered index on the table and then drop the index. Cela redistribue les données pendant la création de l'index cluster.This redistributes the data while the clustered index is created. Si l'on considère l'espace disponible dans la base de données, l'organisation des données est également optimale.This also makes it as optimal as possible, considering the distribution of free space available in the database. Lorsque l'index cluster est par la suite supprimé pour recréer le segment de mémoire, les données ne sont pas déplacées et restent en position optimale.When the clustered index is then dropped to re-create the heap, the data is not moved and remains optimally in position. Pour plus d’informations sur la façon d’effectuer ces opérations, consultez CREATE INDEX et DROP INDEX.For information about how to perform these operations, see CREATE INDEX and DROP INDEX.

Attention

La création et la suppression d'un index cluster sur une table reconstruit deux fois tous les index non cluster sur cette table.Creating and dropping a clustered index on a table, rebuilds all non-clustered indexes on that table twice.

Compactage des données LOBCompacting Large Object Data

Par défaut, l'instruction ALTER INDEX REORGANIZE compacte les pages qui contiennent des données LOB.By default, the ALTER INDEX REORGANIZE statement compacts pages that contain large object (LOB) data. Du fait que les pages LOB ne sont pas libérées lorsqu'elles sont vides, le compactage de ces données peut améliorer l'utilisation de l'espace disque si un grand nombre de données LOB ont été supprimées ou si une colonne LOB est supprimée.Because LOB pages are not deallocated when empty, compacting this data can improve disk space use if lots of LOB data have been deleted, or a LOB column is dropped.

La réorganisation d'un index cluster spécifié compacte toutes les colonnes LOB contenues dans l'index cluster.Reorganizing a specified clustered index compacts all LOB columns that are contained in the clustered index. La réorganisation d'un index non cluster compacte toutes les colonnes LOB qui sont des colonnes non-clés (incluses) dans l'index.Reorganizing a nonclustered index compacts all LOB columns that are nonkey (included) columns in the index. Lorsque l'argument ALL est spécifié dans l'instruction, tous les index associés à la table ou à la vue spécifiée sont réorganisés.When ALL is specified in the statement, all indexes that are associated with the specified table or view are reorganized. De plus, toutes les colonnes LOB associées à l'index cluster, la table sous-jacente ou l'index non cluster avec des colonnes incluses sont compactés.Additionally, all LOB columns that are associated with the clustered index, underlying table, or nonclustered index with included columns are compacted.

Évaluation de l'utilisation de l'espace disqueEvaluating Disk Space Use

La colonne avg_page_space_used_in_percent indique le remplissage des pages.The avg_page_space_used_in_percent column indicates page fullness. Pour une utilisation optimale de l'espace disque, cette valeur doit être aussi proche que possible de 100 % pour un index qui n'aura pas beaucoup d'insertions aléatoires.To achieve optimal disk space use, this value should be close to 100 percent for an index that will not have many random inserts. Cependant, un index qui a beaucoup d'insertions aléatoires et des pages très remplies comportera un nombre plus élevé de fractionnements de pages.However, an index that has many random inserts and has very full pages will have an increased number of page splits. Cela implique une fragmentation plus importante.This causes more fragmentation. Par conséquent, pour réduire les fractionnements, la valeur doit être inférieure à 100 %.Therefore, in order to reduce page splits, the value should be less than 100 percent. La reconstruction d'un index en spécifiant l'option FILLFACTOR permet de modifier le remplissage des pages pour ajuster le modèle de requête à l'index.Rebuilding an index with the FILLFACTOR option specified allows the page fullness to be changed to fit the query pattern on the index. Pour plus d’informations sur le facteur de remplissage, consultez spécifier un facteur de remplissage pour un Index.For more information about fill factor, see Specify Fill Factor for an Index. L'instruction ALTER INDEX REORGANIZE compacte également un index en essayant de remplir les pages en fonction de la dernière valeur FILLFACTOR spécifiée.Also, ALTER INDEX REORGANIZE will compact an index by trying to fill pages to the FILLFACTOR that was last specified. Cela augmente la valeur de avg_space_used_in_percent.This increases the value in avg_space_used_in_percent. Notez que ALTER INDEX REORGANIZE ne peut pas réduire le remplissage des pages.Note that ALTER INDEX REORGANIZE cannot reduce page fullness. Au lieu de cela, une reconstruction de l'index doit avoir lieu.Instead, an index rebuild must be performed.

Évaluation des fragments des indexEvaluating Index Fragments

Un fragment se compose de pages de feuilles physiquement contiguës dans le même fichier d'une unité d'allocation.A fragment is made up of physically consecutive leaf pages in the same file for an allocation unit. Un index comporte au moins un fragment.An index has at least one fragment. Le nombre maximal de fragments d'un index est égal au nombre de pages du niveau feuille de l'index.The maximum fragments an index can have are equal to the number of pages in the leaf level of the index. Des fragments plus importants signifient que moins d'opérations d'entrées/sorties sur le disque sont nécessaires pour lire le même nombre de pages.Larger fragments mean that less disk I/O is required to read the same number of pages. Par conséquent, plus la valeur avg_fragment_size_in_pages est élevée, meilleures sont les performances d'analyse.Therefore, the larger the avg_fragment_size_in_pages value, the better the range scan performance. Les valeurs avg_fragment_size_in_pages et avg_fragmentation_in_percent sont inversement proportionnelles.The avg_fragment_size_in_pages and avg_fragmentation_in_percent values are inversely proportional to each other. La reconstruction ou la réorganisation d'un index doit donc réduire la quantité de fragmentation et augmenter la taille des fragments.Therefore, rebuilding or reorganizing an index should reduce the amount of fragmentation and increase the fragment size.

Limitations et restrictionsLimitations and Restrictions

Ne retourne pas de données pour les index columnstore cluster.Does not return data for clustered columnstore indexes.

AutorisationsPermissions

Les autorisations suivantes sont nécessaires :Requires the following permissions:

  • autorisation CONTROL sur l'objet spécifié dans la base de données ;CONTROL permission on the specified object within the database.

  • Autorisation VIEW DATABASE STATE pour retourner des informations sur tous les objets au sein de la base de données spécifié, à l’aide de l’objet générique @object_id= NULL.VIEW DATABASE STATE permission to return information about all objects within the specified database, by using the object wildcard @object_id=NULL.

  • Autorisation VIEW SERVER STATE pour retourner des informations sur toutes les bases de données à l’aide de la base de données générique @database_id = NULL.VIEW SERVER STATE permission to return information about all databases, by using the database wildcard @database_id = NULL.

L'octroi de l'autorisation VIEW DATABASE STATE autorise le renvoi de tous les objets de la base de données, quelles que soient les autorisations CONTROL refusées sur des objets spécifiques.Granting VIEW DATABASE STATE allows all objects in the database to be returned, regardless of any CONTROL permissions denied on specific objects.

Le refus de l'autorisation VIEW DATABASE STATE interdit le retour de tous les objets de la base de données, quelles que soient les autorisations CONTROL accordées sur des objets spécifiques.Denying VIEW DATABASE STATE disallows all objects in the database to be returned, regardless of any CONTROL permissions granted on specific objects. Également, lorsque le caractère de base de données générique @database_id= NULL est spécifiée, la base de données est omis.Also, when the database wildcard @database_id=NULL is specified, the database is omitted.

Pour plus d’informations, consultez fonctions et vues de gestion dynamique (Transact-SQL).For more information, see Dynamic Management Views and Functions (Transact-SQL).

ExemplesExamples

A.A. Retour d'informations sur une table spécifiéeReturning information about a specified table

L'exemple de code suivant retourne des statistiques de taille et de fragmentation sur tous les index et partitions de la table Person.Address.The following example returns size and fragmentation statistics for all indexes and partitions of the Person.Address table. Le mode d'analyse est défini à 'LIMITED' pour améliorer les performances et limiter les statistiques retournées.The scan mode is set to 'LIMITED' for best performance and to limit the statistics that are returned. L'exécution de cette requête nécessite, au minimum, l'autorisation CONTROL sur la table Person.Address.Executing this query requires, at a minimum, CONTROL permission on the Person.Address table.

DECLARE @db_id SMALLINT;  
DECLARE @object_id INT;  
  
SET @db_id = DB_ID(N'AdventureWorks2012');  
SET @object_id = OBJECT_ID(N'AdventureWorks2012.Person.Address');  
  
IF @db_id IS NULL  
BEGIN;  
    PRINT N'Invalid database';  
END;  
ELSE IF @object_id IS NULL  
BEGIN;  
    PRINT N'Invalid object';  
END;  
ELSE  
BEGIN;  
    SELECT * FROM sys.dm_db_index_physical_stats(@db_id, @object_id, NULL, NULL , 'LIMITED');  
END;  
GO  
  

B.B. Retour d'informations sur un segment de mémoireReturning information about a heap

Le code exemple suivant retourne toutes les statistiques sur le segment de mémoire dbo.DatabaseLog de la base de données AdventureWorks2012AdventureWorks2012.The following example returns all statistics for the heap dbo.DatabaseLog in the AdventureWorks2012AdventureWorks2012 database. Comme la table contient des données LOB, une ligne est retournée pour l'unité d'allocation LOB_DATA, en plus de la ligne retournée pour l'unité d'allocation IN_ROW_ALLOCATION_UNIT qui stocke les pages de données du segment de mémoire.Because the table contains LOB data, a row is returned for the LOB_DATA allocation unit in addition to the row returned for the IN_ROW_ALLOCATION_UNIT that is storing the data pages of the heap. L'exécution de cette requête nécessite, au minimum, l'autorisation CONTROL sur la table dbo.DatabaseLog.Executing this query requires, at a minimum, CONTROL permission on the dbo.DatabaseLog table.

DECLARE @db_id SMALLINT;  
DECLARE @object_id INT;  
SET @db_id = DB_ID(N'AdventureWorks2012');  
SET @object_id = OBJECT_ID(N'AdventureWorks2012.dbo.DatabaseLog');  
IF @object_id IS NULL   
BEGIN;  
    PRINT N'Invalid object';  
END;  
ELSE  
BEGIN;  
    SELECT * FROM sys.dm_db_index_physical_stats(@db_id, @object_id, 0, NULL , 'DETAILED');  
END;  
GO  
  

C.C. Retour d'informations sur toutes les bases de donnéesReturning information for all databases

L'exemple suivant retourne toutes les statistiques de l'ensemble des tables et des index dans l'instance de SQL ServerSQL Server en spécifiant la valeur générique NULL pour tous les paramètres.The following example returns all statistics for all tables and indexes within the instance of SQL ServerSQL Server by specifying the wildcard NULL for all parameters. L’exécution de cette requête nécessite l’autorisation VIEW SERVER STATE.Executing this query requires the VIEW SERVER STATE permission.

SELECT * FROM sys.dm_db_index_physical_stats (NULL, NULL, NULL, NULL, NULL);  
GO  
  

D.D. Utilisation de sys.dm_db_index_physical_stats dans un script pour reconstruire ou réorganiser des indexUsing sys.dm_db_index_physical_stats in a script to rebuild or reorganize indexes

Le code exemple suivant réorganise ou reconstruit automatiquement toutes les partitions d'une base de données dont la fragmentation moyenne est supérieure à 10 %.The following example automatically reorganizes or rebuilds all partitions in a database that have an average fragmentation over 10 percent. L'exécution de cette requête nécessite l'autorisation VIEW DATABASE STATE.Executing this query requires the VIEW DATABASE STATE permission. Cet exemple spécifie DB_ID en tant que premier paramètre sans fournir de nom de base de données.This example specifies DB_ID as the first parameter without specifying a database name. Une erreur sera générée si le niveau de compatibilité de la base de données active est inférieur ou égal à 80.An error will be generated if the current database has a compatibility level of 80 or lower. Pour résoudre cette erreur, remplacez DB_ID() par un nom de base de données valide.To resolve the error, replace DB_ID() with a valid database name. Pour plus d’informations sur les niveaux de compatibilité de base de données, consultez ALTER DATABASE Compatibility Level (Transact-SQL).For more information about database compatibility levels, see ALTER DATABASE Compatibility Level (Transact-SQL).

-- Ensure a USE <databasename> statement has been executed first.  
SET NOCOUNT ON;  
DECLARE @objectid int;  
DECLARE @indexid int;  
DECLARE @partitioncount bigint;  
DECLARE @schemaname nvarchar(130);   
DECLARE @objectname nvarchar(130);   
DECLARE @indexname nvarchar(130);   
DECLARE @partitionnum bigint;  
DECLARE @partitions bigint;  
DECLARE @frag float;  
DECLARE @command nvarchar(4000);   
-- Conditionally select tables and indexes from the sys.dm_db_index_physical_stats function   
-- and convert object and index IDs to names.  
SELECT  
    object_id AS objectid,  
    index_id AS indexid,  
    partition_number AS partitionnum,  
    avg_fragmentation_in_percent AS frag  
INTO #work_to_do  
FROM sys.dm_db_index_physical_stats (DB_ID(), NULL, NULL , NULL, 'LIMITED')  
WHERE avg_fragmentation_in_percent > 10.0 AND index_id > 0;  
  
-- Declare the cursor for the list of partitions to be processed.  
DECLARE partitions CURSOR FOR SELECT * FROM #work_to_do;  
  
-- Open the cursor.  
OPEN partitions;  
  
-- Loop through the partitions.  
WHILE (1=1)  
    BEGIN;  
        FETCH NEXT  
           FROM partitions  
           INTO @objectid, @indexid, @partitionnum, @frag;  
        IF @@FETCH_STATUS < 0 BREAK;  
        SELECT @objectname = QUOTENAME(o.name), @schemaname = QUOTENAME(s.name)  
        FROM sys.objects AS o  
        JOIN sys.schemas as s ON s.schema_id = o.schema_id  
        WHERE o.object_id = @objectid;  
        SELECT @indexname = QUOTENAME(name)  
        FROM sys.indexes  
        WHERE  object_id = @objectid AND index_id = @indexid;  
        SELECT @partitioncount = count (*)  
        FROM sys.partitions  
        WHERE object_id = @objectid AND index_id = @indexid;  
  
-- 30 is an arbitrary decision point at which to switch between reorganizing and rebuilding.  
        IF @frag < 30.0  
            SET @command = N'ALTER INDEX ' + @indexname + N' ON ' + @schemaname + N'.' + @objectname + N' REORGANIZE';  
        IF @frag >= 30.0  
            SET @command = N'ALTER INDEX ' + @indexname + N' ON ' + @schemaname + N'.' + @objectname + N' REBUILD';  
        IF @partitioncount > 1  
            SET @command = @command + N' PARTITION=' + CAST(@partitionnum AS nvarchar(10));  
        EXEC (@command);  
        PRINT N'Executed: ' + @command;  
    END;  
  
-- Close and deallocate the cursor.  
CLOSE partitions;  
DEALLOCATE partitions;  
  
-- Drop the temporary table.  
DROP TABLE #work_to_do;  
GO  
  

E.E. Utilisation de sys.dm_db_index_physical_stats pour afficher le nombre de pages compressées par pageUsing sys.dm_db_index_physical_stats to show the number of page-compressed pages

L'exemple suivant montre comment afficher et comparer le nombre total de pages par rapport aux pages qui sont compressées par ligne et par page.The following example shows how to display and compare the total number of pages against the pages that are row and page compressed. Ces informations peuvent être utilisées pour déterminer l'avantage que procure la compression pour un index ou une table.This information can be used to determine the benefit that compression is providing for an index or table.

SELECT o.name,  
    ips.partition_number,  
    ips.index_type_desc,  
    ips.record_count, ips.avg_record_size_in_bytes,  
    ips.min_record_size_in_bytes,  
    ips.max_record_size_in_bytes,  
    ips.page_count, ips.compressed_page_count  
FROM sys.dm_db_index_physical_stats ( DB_ID(), NULL, NULL, NULL, 'DETAILED') ips  
JOIN sys.objects o on o.object_id = ips.object_id  
ORDER BY record_count DESC;  

F.F. Utilisation de sys.dm_db_index_physical_stats en mode SAMPLEDUsing sys.dm_db_index_physical_stats in SAMPLED mode

L'exemple suivant montre comment le mode SAMPLED retourne un nombre approximatif qui est différent de celui résultant du mode DETAILED.The following example shows how SAMPLED mode returns an approximate that is different than the DETAILED mode results.

CREATE TABLE t3 (col1 int PRIMARY KEY, col2 varchar(500)) WITH(DATA_COMPRESSION = PAGE);  
GO  
BEGIN TRAN  
DECLARE @idx int = 0;  
WHILE @idx < 1000000  
BEGIN  
    INSERT INTO t3 (col1, col2)   
    VALUES (@idx,   
    REPLICATE ('a', 100) + CAST (@idx as varchar(10)) + REPLICATE ('a', 380))  
    SET @idx = @idx + 1  
END  
COMMIT;  
GO  
SELECT page_count, compressed_page_count, forwarded_record_count, *   
FROM sys.dm_db_index_physical_stats (db_id(),   
    object_id ('t3'), null, null, 'SAMPLED');  
SELECT page_count, compressed_page_count, forwarded_record_count, *   
FROM sys.dm_db_index_physical_stats (db_id(),   
    object_id ('t3'), null, null, 'DETAILED');  

G.G. Interrogation des files d’attente de service broker pour la fragmentation d’indexQuerying service broker queues for index fragmentation

S'applique à: SQL Server 2016 (13.x)SQL Server 2016 (13.x) jusqu'à SQL ServerSQL Server.Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x) through SQL ServerSQL Server.

Les exemples suivants montre comment interroger les files d’attente de serveur service broker pour la fragmentation.The following examples shows how to query server broker queues for fragmentation.

--Using queue internal table name   
select * from sys.dm_db_index_physical_stats (db_id(), object_id ('sys.queue_messages_549576996'), default, default, default)   
  
--Using queue name directly  
select * from sys.dm_db_index_physical_stats (db_id(), object_id ('ExpenseQueue'), default, default, default)  
  

Voir aussiSee Also

Fonctions et vues de gestion dynamique (Transact-SQL) Dynamic Management Views and Functions (Transact-SQL)
Fonctions et vues de gestion dynamique relatives aux index (Transact-SQL) Index Related Dynamic Management Views and Functions (Transact-SQL)
sys.dm_db_index_operational_stats (Transact-SQL) sys.dm_db_index_operational_stats (Transact-SQL)
sys.dm_db_index_usage_stats (Transact-SQL) sys.dm_db_index_usage_stats (Transact-SQL)
sys.dm_db_partition_stats (Transact-SQL) sys.dm_db_partition_stats (Transact-SQL)
sys.allocation_units (Transact-SQL) sys.allocation_units (Transact-SQL)
System Views (Transact-SQL)System Views (Transact-SQL)