Condividi tramite

sys.dm_db_column_store_row_group_physical_stats (Transact-SQL)

Applies to: SQL Server 2016 (13.x) and later Azure SQL DatabaseAzure SQL Managed Instance

Fornisce informazioni correnti a livello di rowgroup su tutti gli indici columnstore nel database corrente.

This DMV extends the catalog view sys.column_store_row_groups.

Column name Data type Description
object_id int ID della tabella sottostante.
index_id int ID di questo indice columnstore nella object_id tabella.
partition_number int ID della partizione di tabella che contiene row_group_id. È possibile usare partition_number per aggiungere questa DMV a sys.partitions
row_group_id int ID del gruppo di righe. Per le tabelle partizionate, il valore è univoco all'interno della partizione.

-1 per una coda in memoria.
delta_store_hobt_id bigint Il hobt_id per un gruppo di righe nell'archivio differenziale.

NULL se il gruppo di righe non si trova nell'archivio differenziale.

NULL per la parte finale di una tabella in memoria.
state tinyint Numero ID associato.state_description

0 = INVISIBLE
1= OPEN
2 = CLOSED
3 = COMPRESSED
4 = TOMBSTONE

COMPRESSED è l'unico stato applicabile alle tabelle in memoria.
state_desc nvarchar(60) Descrizione dello stato del gruppo di righe:

0 - INVISIBLE - Gruppo di righe da compilare. For example:

Un gruppo di righe nel columnstore è INVISIBLE mentre i dati vengono compressi. Al termine della compressione, un'opzione di metadati modifica lo stato del gruppo di righe columnstore da INVISIBLE a COMPRESSEDe lo stato del gruppo di righe deltastore da CLOSED a TOMBSTONE.

1 - OPEN - Gruppo di righe deltastore che accetta nuove righe. Un gruppo di righe aperto è ancora in formato rowstore e non è stato compresso in formato columnstore.

2 - CLOSED - Un gruppo di righe nell'archivio differenziale che contiene il numero massimo di righe ed è in attesa del processo di spostamento delle tuple per comprimerlo nel columnstore.

3 - COMPRESSED : gruppo di righe compresso con compressione columnstore e archiviato nel columnstore.

4 - TOMBSTONE - Un gruppo di righe precedentemente incluso nell'archivio differenziale e non viene più usato.
total_rows bigint Righe di totali archiviate fisicamente nell'apposito gruppo. Per i gruppi di righe compressi. Include le righe contrassegnate come eliminate.
deleted_rows bigint Numero di righe archiviate fisicamente in un gruppo di righe compresso contrassegnate per l'eliminazione.

0 per i gruppi di righe presenti nell'archivio differenziale.

Per gli indici columnstore non cluster, questo valore non include le righe eliminate archiviate nel buffer di eliminazione. For more information, and to find the number of deleted rows in the delete buffer, see sys.internal_partitions.
size_in_bytes bigint Dimensioni combinate, in byte, di tutte le pagine di questo gruppo di righe. Questa dimensione non include le dimensioni necessarie per archiviare i metadati o i dizionari condivisi.
trim_reason tinyint Motivo per cui il COMPRESSED gruppo di righe ha attivato un numero inferiore al numero massimo di righe.

0 - UNKNOWN_UPGRADED_FROM_PREVIOUS_VERSION
1 - NO_TRIM
2 - BULKLOAD
3 - REORG
4 - DICTIONARY_SIZE
5 - MEMORY_LIMITATION
6 - RESIDUAL_ROW_GROUP
7 - STATS_MISMATCH
8 - SPILLOVER
9 - AUTO_MERGE
trim_reason_desc nvarchar(60) Descrizione di trim_reason.

0 - UNKNOWN_UPGRADED_FROM_PREVIOUS_VERSION: si è verificato durante l'aggiornamento dalla versione precedente di SQL Server.

1 - NO_TRIM: il gruppo di righe non è stato tagliato. Il gruppo di righe è stato compresso con il numero massimo di 1.048.576 righe. Il numero di righe potrebbe essere minore se un subset di righe è stato eliminato dopo la chiusura del rowgroup differenziale

2 - BULKLOAD: le dimensioni del batch di caricamento bulk limitano il numero di righe.

3 - REORG: compressione forzata come parte del REORG comando.

4 - DICTIONARY_SIZE: le dimensioni del dizionario sono aumentate troppo grandi per comprimere tutte le righe insieme.

5 - MEMORY_LIMITATION: memoria disponibile insufficiente per comprimere tutte le righe insieme.

6 - RESIDUAL_ROW_GROUP: chiuso come parte dell'ultimo gruppo di righe con righe < 1 milione durante l'operazione di compilazione dell'indice.

Note: A partition build with multiple cores can result in more than one trim of this type.

7 - STATS_MISMATCH: solo per columnstore nella tabella in memoria. Se le statistiche indicate >in modo non corretto = 1 milione di righe qualificate nella parte finale, ma è stato rilevato un minor numero di righe, il rowgroup compresso avrà < 1 milione di righe

8 - SPILLOVER: solo per columnstore nella tabella in memoria. Se tail ha > 1 milione di righe qualificate, l'ultimo batch rimanente righe viene compresso se il conteggio è compreso tra 100.000 e 1 milione

9 - AUTO_MERGE: un'operazione di unione di Tuple Mover in esecuzione in background ha consolidato uno o più rowgroup in questo rowgroup.
transition_to_compressed_state tinyint Mostra come questo rowgroup è stato spostato dall'archivio differenziale a uno stato compresso nel columnstore.

1 - NOT_APPLICABLE
2 - INDEX_BUILD
3 - TUPLE_MOVER
4 - REORG_NORMAL
5 - REORG_FORCED
6 - BULKLOAD
7 - MERGE
transition_to_compressed_state_desc nvarchar(60) 1 - NOT_APPLICABLE - l'operazione non si applica al deltastore. In alternativa, il rowgroup è stato compresso prima dell'aggiornamento a SQL Server 2016 (13.x), nel qual caso la cronologia non viene mantenuta.

2 - INDEX_BUILD - Creazione di un indice o ricompilazione dell'indice compresso per il rowgroup.

3 - TUPLE_MOVER - Lo spostamento della tupla in esecuzione in background comprimeva il rowgroup. Lo spostamento tuple si verifica dopo che il rowgroup cambia lo stato da OPEN a CLOSED.

4 - REORG_NORMAL - Operazione di riorganizzazione, ALTER INDEX ... REORG, spostato il CLOSED rowgroup dal deltastore al columnstore. Questo problema si è verificato prima che il tuple-mover avesse tempo per spostare il rowgroup.

5 - REORG_FORCED - Questo rowgroup è stato aperto nel deltastore ed è stato forzato nel columnstore prima di avere un numero completo di righe.

6 - BULKLOAD - Un'operazione di caricamento bulk comprime il rowgroup direttamente senza usare l'archivio differenziale.

7 - MERGE - Operazione di merge consolidata uno o più rowgroup in questo rowgroup e quindi eseguita la compressione columnstore.
has_vertipaq_optimization bit L'ottimizzazione vertiPaq migliora la compressione columnstore riorganizzando l'ordine delle righe nel rowgroup per ottenere una compressione più elevata. Questa ottimizzazione viene eseguita automaticamente nella maggior parte dei casi. Esistono due casi in cui l'ottimizzazione VertiPaq non viene usata:

a. quando un rowgroup differenziale viene spostato nel columnstore e sono presenti uno o più indici non cluster nell'indice columnstore. In questo caso, l'ottimizzazione vertiPaq viene ignorata per ridurre al minimo le modifiche apportate all'indice di mapping;

b. per gli indici columnstore nelle tabelle ottimizzate per la memoria.

0 = No
1 = Sì
generation bigint Generazione di gruppi di righe associata a questo gruppo di righe.
created_time datetime2 Ora di clock per la creazione di questo rowgroup.

NULL : per un indice columnstore in una tabella in memoria.
closed_time datetime2 Ora di ora in cui questo rowgroup è stato chiuso.

NULL : per un indice columnstore in una tabella in memoria.

Results

Restituisce una riga per ogni rowgroup nel database corrente.

Permissions

È richiesta CONTROL l'autorizzazione per la tabella e VIEW DATABASE STATE l'autorizzazione per il database.

Autorizzazioni per SQL Server 2022 e versioni successive

È richiesta l'autorizzazione VIEW DATABASE PERFORMANCE STATE per il database.

Examples

A. Calcolare la frammentazione per decidere quando riorganizzare o ricompilare un indice columnstore

Per gli indici columnstore, la percentuale di righe eliminate è una misura valida per la frammentazione in un rowgroup. Quando la frammentazione è pari o superiore al 20%, rimuovere le righe eliminate. Per altri esempi, vedere Ottimizzare la manutenzione degli indici per migliorare le prestazioni delle query e ridurre l'utilizzo delle risorse.

Questo esempio viene unito sys.dm_db_column_store_row_group_physical_stats ad altre tabelle di sistema e quindi calcola la Fragmentation colonna come stima dell'efficienza di ogni gruppo di righe nel database corrente. Per trovare informazioni su una singola tabella, rimuovere i trattini di commento davanti alla WHERE clausola e specificare un nome di tabella.

SELECT i.object_id,
       object_name(i.object_id) AS TableName,
       i.name AS IndexName,
       i.index_id,
       i.type_desc,
       CSRowGroups.*,
       100 * (ISNULL(deleted_rows, 0)) / NULLIF (total_rows, 0) AS 'Fragmentation'
FROM sys.indexes AS i
     INNER JOIN sys.dm_db_column_store_row_group_physical_stats AS CSRowGroups
         ON i.object_id = CSRowGroups.object_id
        AND i.index_id = CSRowGroups.index_id
-- WHERE object_name(i.object_id) = 'table_name'
ORDER BY object_name(i.object_id), i.name, row_group_id;

Related content