Dela via

Felsöka accelererad databasåterställning

  • Artikel

gäller för: SQL Server 2019 (15.x) och senare versioner Azure SQL DatabaseAzure SQL Managed InstanceSQL-databas i Microsoft Fabric

Den här artikeln hjälper dig att diagnostisera problem med accelererad databasåterställning (ADR) i SQL Server 2019 (15.x) och senare, Azure SQL Managed Instance, Azure SQL Database och SQL Database i Microsoft Fabric.

Granska storleken på PVS

Använd sys.dm_tran_persistent_version_store_stats DMV för att identifiera om PVS-storleken (Persistent Version Store) är större än förväntat.

Följande exempelfråga visar information om den aktuella PVS-storleken, rensningsprocesserna och annan information:

SELECT  DB_NAME(pvss.database_id) AS database_name,
        pvss.persistent_version_store_size_kb / 1024. / 1024 AS persistent_version_store_size_gb,
        100 * pvss.persistent_version_store_size_kb / df.total_db_size_kb AS pvs_pct_of_database_size,
        df.total_db_size_kb/ 1024. / 1024 AS total_db_size_gb,
        pvss.online_index_version_store_size_kb / 1024. / 1024 AS online_index_version_store_size_gb,
        pvss.current_aborted_transaction_count,
        pvss.aborted_version_cleaner_start_time,
        pvss.aborted_version_cleaner_end_time,
        dt.database_transaction_begin_time AS oldest_transaction_begin_time,
        asdt.session_id AS active_transaction_session_id,
        asdt.elapsed_time_seconds AS active_transaction_elapsed_time_seconds,
        pvss.pvs_off_row_page_skipped_low_water_mark,
        pvss.pvs_off_row_page_skipped_min_useful_xts,
        pvss.pvs_off_row_page_skipped_oldest_aborted_xdesid
FROM sys.dm_tran_persistent_version_store_stats AS pvss
CROSS APPLY (
            SELECT SUM(size * 8.) AS total_db_size_kb
            FROM sys.database_files
            WHERE state = 0
                  AND
                  type = 0
            ) AS df
LEFT JOIN sys.dm_tran_database_transactions AS dt
ON pvss.oldest_active_transaction_id = dt.transaction_id
   AND
   pvss.database_id = dt.database_id
LEFT JOIN sys.dm_tran_active_snapshot_database_transactions AS asdt
ON pvss.min_transaction_timestamp = asdt.transaction_sequence_num
   OR
   pvss.online_index_min_transaction_timestamp = asdt.transaction_sequence_num
WHERE pvss.database_id = DB_ID();

Kontrollera kolumnen pvs_pct_of_database_size för att se storleken på PVS i förhållande till den totala databasstorleken. Observera eventuella skillnader från den typiska PVS-storleken jämfört med baslinjer som visas under andra perioder av programaktivitet. PVS anses vara stort om det är betydligt större än baslinjen eller om det är nära 50% av databasstorleken. Använd följande felsökningssteg för att hitta orsaken till den stora PVS-storleken.

Om PVS-storleken är större än förväntat kontrollerar du följande:

Sök efter långvariga aktiva transaktioner

Långvariga aktiva transaktioner kan förhindra PVS-rensning i databaser som har ADR aktiverat. Kontrollera starttiden för den äldsta aktiva transaktionen med hjälp av kolumnen oldest_transaction_begin_time. Mer information om långvariga transaktioner finns i följande exempelfråga. Du kan ange tröskelvärden för transaktionsvaraktighet och mängden genererad transaktionslogg:

DECLARE @LongTxThreshold int = 1800;  /* The number of seconds to use as a duration threshold for long-running transactions */
DECLARE @LongTransactionLogBytes bigint = 1073741824; /* The number of bytes to use as a log amount threshold for long-running transactions */

SELECT  dbtr.database_id,
        transess.session_id,
        transess.transaction_id,
        atr.name,
        sess.login_time,
        dbtr.database_transaction_log_bytes_used,
        CASE WHEN GETDATE() >= DATEADD(second, @longTxThreshold, tr.transaction_begin_time) THEN 'DurationThresholdExceeded' 
                WHEN dbtr.database_transaction_log_bytes_used >= @LongTransactionLogBytes THEN 'LogThresholdExceeded' 
                ELSE 'Unknown'
        END AS Reason
FROM sys.dm_tran_active_transactions AS tr
INNER JOIN sys.dm_tran_session_transactions AS transess
ON tr.transaction_id = transess.transaction_id
INNER JOIN sys.dm_exec_sessions AS sess
ON transess.session_id = sess.session_id
INNER JOIN sys.dm_tran_database_transactions AS dbtr
ON tr.transaction_id = dbtr.transaction_id
INNER JOIN sys.dm_tran_active_transactions AS atr
ON atr.transaction_id = transess.transaction_id
WHERE GETDATE() >= DATEADD(second, @LongTxThreshold, tr.transaction_begin_time)
        OR
        dbtr.database_transaction_log_bytes_used >= @LongTransactionLogBytes;

När sessionerna har identifierats kan du överväga att döda sessionen om det tillåts. Granska programmet för att fastställa typen av problematiska aktiva transaktioner för att undvika problemet i framtiden.

Mer information om hur du felsöker långvariga frågor finns i:

Sök efter långvariga aktiva ögonblicksbildsgenomsökningar

Långvariga aktiva ögonblicksbildsgenomsökningar kan förhindra PVS-rensning i databaser som har ADR aktiverat. Uttalanden som använder READ COMMITTED ögonblicksbildisolering (RCSI) eller SNAPSHOTisoleringsnivåer får tidsstämplar på instansnivå. En ögonblicksbildsgenomsökning använder tidsstämpeln för att bestämma versionsradens synlighet för RCSI- eller SNAPSHOT-transaktionen. Varje instruktion som använder RCSI har en egen tidsstämpel, medan SNAPSHOT isolering har en tidsstämpel på transaktionsnivå.

Dessa transaktionstidsstämplar på instansnivå används även i transaktioner med en databas, eftersom alla transaktioner kan uppmana till en transaktion mellan databaser. Genomsökningar av ögonblicksbilder kan därför förhindra PVS-rensning i alla databaser på samma databasmotorinstans. På samma sätt kan ögonblicksbildsgenomsökningar förhindra rensning av versionsarkivet i tempdbnär ADR inte är aktiverat. Därför kan PVS växa i storlek när långvariga transaktioner som använder SNAPSHOT eller RCSI finns.

I felsökningsfråga i början av den här artikeln visar kolumnen pvs_off_row_page_skipped_min_useful_xts antalet sidor som har hoppats över för att återkrävas på grund av en lång genomsökning av ögonblicksbilder. Om den här kolumnen visar ett större värde än normalt innebär det att en långvarig genomsökning av snapshots förhindrar PVS-rensning.

Använd följande exempelfråga för att hitta sessionen med den långvariga SNAPSHOT- eller RCSI-transaktionen:

SELECT snap.transaction_id,
        snap.transaction_sequence_num,
        session.session_id,
        session.login_time,
        GETUTCDATE() AS [now],
        session.host_name,
        session.program_name,
        session.login_name,
        session.last_request_start_time
FROM sys.dm_tran_active_snapshot_database_transactions AS snap
INNER JOIN sys.dm_exec_sessions AS session
ON snap.session_id = session.session_id
ORDER BY snap.transaction_sequence_num ASC;

Så här förhindrar du PVS-rensningsfördröjningar:

  • Överväg att ta bort den långa aktiva transaktionssessionen som fördröjer PVS-rensningen, om möjligt.
  • Justera långvariga sökfrågor för att minska körtiden för frågorna.
  • Granska programmet för att fastställa typen av problematisk aktiv ögonblicksbildsgenomsökning. Överväg en annan isoleringsnivå, till exempel READ COMMITTED, i stället för SNAPSHOT eller RCSI för långvariga frågor som fördröjer PVS-rensningen. Det här problemet uppstår oftare med SNAPSHOT isoleringsnivå.
  • I elastiska pooler i Azure SQL Database bör du överväga att flytta databaser som har långvariga transaktioner med hjälp av SNAPSHOT isoleringsnivå eller RCSI från den elastiska poolen.

Sök efter långvariga frågekommandon på sekundära repliker

Om databasen har sekundära repliker kontrollerar du om den sekundära lågvattenstämpeln avancerar.

Kör följande DMV:er på den primära repliken för att identifiera långvariga frågor på den sekundära repliken som kan förhindra PVS-rensning:

I sys.dm_tran_persistent_version_store_stats DMV kan också pvs_off_row_page_skipped_low_water_mark kolumnerna ge en indikation på en fördröjning av rensning på grund av en långvarig frågeställning på en sekundär replik.

Anslut till en sekundär replik, leta reda på den session som kör den långa frågan och överväg att avsluta sessionen om det är tillåtet. Den långvariga frågan på den sekundära repliken kan innehålla PVS-rensning och förhindra spökrensning.

Sök efter ett stort antal avbrutna transaktioner

Om inget av de tidigare scenarierna gäller för dina arbetsbelastningar är det troligt att rensningen hålls på grund av ett stort antal avbrutna transaktioner. Kontrollera aborted_version_cleaner_last_start_time och aborted_version_cleaner_last_end_time kolumner för att se om den senaste avbrutna transaktionsrensningen har slutförts. oldest_aborted_transaction_id bör röra sig uppåt när den avbrutna transaktionsrensningen har slutförts. Om oldest_aborted_transaction_id är mycket lägre än oldest_active_transaction_id, och current_abort_transaction_count har ett större värde, finns det sannolikt en gammal avbruten transaktion som förhindrar PVS-rensning.

Tänk på följande för att hantera ett stort antal avbrutna transaktioner:

  • Stoppa om möjligt arbetsbelastningen för att versionsrensaren ska kunna fortsätta.
  • Optimera arbetsbelastningen för att minska lås på objektnivå.
  • Granska programmet för att identifiera problemet med hög transaktionsabstakt. Avbrotten kan komma från en hög frekvens av dödlägen, duplicerade nycklar, begränsningsöverträdelser eller förfrågningsavbrott.
  • Om du använder SQL Server inaktiverar du ADR som ett steg endast för nödsituationer för att kontrollera PVS-storleken. Se Inaktivera ADR.
  • Om den avbrutna transaktionsrensningen inte nyligen har slutförts, kontrollerar du felloggen för meddelanden som rapporterar VersionCleaner-problem.
  • Om PVS-storleken inte minskas som förväntat, även efter att en rensning har slutförts, bör du kontrollera kolumnen pvs_off_row_page_skipped_oldest_aborted_xdesid. Stora värden anger att utrymme fortfarande används av radversioner från avbrutna transaktioner.

Starta PVS-rensningsprocessen manuellt

Om du har en arbetsbelastning med en hög volym DML-instruktioner (INSERT, UPDATE, DELETE, MERGE), till exempel vid högvolyms-OLTP, kan det kräva en period av vila/återhämtning för PVS-rensningsprocessen för att frigöra utrymme.

Om du vill aktivera PVS-rensningsprocessen manuellt mellan arbetsbelastningar eller under underhållsperioder använder du den system lagrade proceduren sys.sp_persistent_version_cleanup.

Till exempel:

EXEC sys.sp_persistent_version_cleanup [WideWorldImporters];

Fånga upp städningsfel

Från och med SQL Server 2022 (16.x) registreras PVS-rensningsbeteendet i felloggen. Detta resulterar vanligtvis i en ny logghändelse som registreras var 10:e minut. Rensningsstatistik rapporteras också av den tx_mtvc2_sweep_statsutökade händelsen.

Relaterat innehåll