Uso di Archivio query con OLTP in-memoriaUsing the Query Store with In-Memory OLTP

QUESTO ARGOMENTO SI APPLICA A: sìSQL Server (a partire dalla versione 2016)sìDatabase SQL di AzurenoAzure SQL Data Warehouse noParallel Data Warehouse THIS TOPIC APPLIES TO: yesSQL Server (starting with 2016)yesAzure SQL DatabasenoAzure SQL Data Warehouse noParallel Data Warehouse

SQL ServerSQL Server Archivio query consente di monitorare le prestazioni del codice compilato in modo nativo per i carichi di lavoro che eseguono OLTP in memoria. Query Store allows you to monitor the performance of natively compiled code for workloads running in-memory OLTP.
Le statistiche di compilazione e runtime vengono raccolte ed esposte nello stesso modo valido per i carichi di lavoro basati su disco.Compile and runtime statistics are collected and exposed the same way as for disk-based workloads.
Quando si esegue la migrazione a OLTP in memoria, è possibile continuare a usare le viste di Archivio query in SQL Server Management StudioSQL Server Management Studio oltre agli script personalizzati sviluppati per carichi di lavoro basati su disco prima della migrazione.When you migrate to in-memory OLTP you can continue using Query Store views in SQL Server Management StudioSQL Server Management Studio as well as custom scripts you have developed for disk-based workloads before migration. In questo modo si tutelano gli investimenti effettuati per l'apprendimento della tecnologia di Archivio query perché queste conoscenze diventano utilizzabili a livello generale per la risoluzione dei problemi di tutti i tipi di carichi di lavoro.This saves your investment in learning Query Store technology and makes it generally usable for troubleshooting all type of workloads.
Per informazioni generali sull'uso di Archivio query, vedere Monitoraggio delle prestazioni con Archivio query.For general information on using the Query Store, see Monitoring Performance By Using the Query Store.

L'uso di Archivio query con OLTP in memoria non richiede la configurazione di alcuna funzionalità aggiuntiva.Using the Query Store with in-memory OLTP does not require any additional feature configuration. Dopo averlo abilitato nel database, funzionerà per tutti i tipi di carico di lavoro.When you enable it on your database it will work for all types of workloads.
Esistono tuttavia alcuni aspetti specifici di cui gli utenti dovranno tenere conto durante l'uso di Archivio query con OLTP in memoria:However, there are some specific aspects that users should be aware of when using Query Store with in-memory OLTP:

  • Quando Archivio query è abilitato, vengono raccolte per impostazione predefinita statistiche relative a query, piani e tempi di compilazione.When Query Store is enabled, queries, plans and compile-time statistics are collected by default. La raccolta delle statistiche di runtime non è tuttavia attivata, a meno che non venga abilitata in modo esplicito con sys.sp_xtp_control_query_exec_stats (Transact-SQL).However, runtime statistics collection is not activated unless you explicitly enable it with sys.sp_xtp_control_query_exec_stats (Transact-SQL).

  • Quando si imposta @new_collection_value su 0, Archivio query arresta la raccolta delle statistiche di runtime per la procedura interessata o per l'intera istanza di SQL ServerSQL Server .When you set @new_collection_value to 0 Query Store will stop collecting runtime statistics for affected procedure or for the entire SQL ServerSQL Server instance.

  • Il valore configurato con sys.sp_xtp_control_query_exec_stats (Transact-SQL) non è persistente.The value configured with sys.sp_xtp_control_query_exec_stats (Transact-SQL) is not persisted. Verificare di controllare e configurare nuovamente la raccolta delle statistiche dopo il riavvio di SQL ServerSQL Server.Make sure you check and configure again statistics collection after restarting SQL ServerSQL Server.

  • Come nel caso della normale raccolta di statistiche sulle query, le prestazioni posso risultare ridotte quando si usa Archivio query per tenere traccia dell'esecuzione del carico di lavoro.As in case with regular query statistics collection, performance may decrease when you use Query Store to track workload execution. Si consiglia di valutare la possibilità di abilitare la raccolta delle statistiche solo per un subset importante di stored procedure compilate in modo nativo.You may want to consider enabling statistics collection only for an important subset of natively compiled stored procedures.

  • Le query e i piani vengono acquisiti e archiviati nella prima compilazione nativa e aggiornati per ogni ricompilazione.Queries and plans are captured and stored on the first native compilation and updated upon every recompilation.

  • Se Archivio query viene abilitato o il suo contenuto viene cancellato dopo la compilazione di tutte le stored procedure native, è necessario ricompilarle manualmente per fare in modo che vengano acquisite da Archivio query.If you enabled Query Store or cleared its content after all native stored procedure were compiled you must recompile them manually in order to make them captured by the Query Store. Lo stesso vale in caso di rimozione manuale delle query tramite sp_query_store_remove_query (Transact-SQL) o sp_query_store_remove_plan (Transct-SQL).The same applies if you removed queries manually by using sp_query_store_remove_query (Transact-SQL) or sp_query_store_remove_plan (Transct-SQL). Usare sp_recompile (Transact-SQL) per forzare la ricompilazione delle procedure.Use sp_recompile (Transact-SQL) to force procedure recompilation.

  • Archivio query sfrutta i meccanismi di generazione dei piani di OLTP in memoria per acquisire il piano di esecuzione della query durante la compilazione.Query Store leverages plan generation mechanisms from in-memory OLTP to capture query execution plan during the compilation. Il piano archiviato è equivalente, dal punto di vista semantico, a quello che si otterrebbe usando SET SHOWPLAN_XML ON con una sola differenza: i piani in Archivio query sono sempre suddivisi e archiviati per ogni singola istruzione.Stored plan is semantically equivalent to one that you would get by using SET SHOWPLAN_XML ON with one difference; plans in Query Store are split and stored per individual statement.

  • Quando si esegue Archivio query in un database con un carico di lavoro misto, è quindi possibile usare il campo is_natively_compiled da sys.query_store_plan (Transact-SQL) per trovare rapidamente i piani di query generati dalla compilazione di codice nativo.When you run Query Store in a database with a mixed workload then you can use is_natively_compiled field from sys.query_store_plan (Transact-SQL) to quickly find query plans that are generated by the native code compilation.

  • La modalità di acquisizione di Archivio query (parametro QUERY_CAPTURE_MODE nell'istruzione ALTER TABLE) non influisce sulle query da moduli compilati in modo nativo, perché vengono sempre acquisite indipendentemente dal valore configurato.Query Store capture mode (QUERY_CAPTURE_MODE parameter in ALTER TABLE statement) does not affect queries from natively compiled modules as they are always captured regardless of the configured value. Ciò vale anche per l'impostazione QUERY_CAPTURE_MODE = NONE.This includes setting QUERY_CAPTURE_MODE = NONE.

  • La durata della compilazione della query acquisita da Archivio query include solo tempo dedicato all'ottimizzazione della query, prima della generazione del codice nativo.The duration of query compilation captured by the Query Store includes only time spent in query optimization, before the native code was generated. Più precisamente, non include il tempo per la compilazione del codice C e la generazione delle strutture interne necessarie per la generazione del codice C.More precisely, it doesn’t include time for C code compilation and generation of internal structures necessary for C code generation.

  • Le metriche delle concessioni di memoria in sys.query_store_runtime_stats (Transact-SQL) non vengono popolate per le query compilate in modo nativo e i valori sono sempre pari a 0.Memory grants metrics within sys.query_store_runtime_stats (Transact-SQL) are not populated for natively compiled queries – their values are always 0. Le colonne per le concessioni di memoria sono: avg_query_max_used_memory, last_query_max_used_memory, min_query_max_used_memory, max_query_max_used_memory e stdev_query_max_used_memory.The memory grants columns are: avg_query_max_used_memory, last_query_max_used_memory, min_query_max_used_memory, max_query_max_used_memory, and stdev_query_max_used_memory.

Abilitazione e uso di Archivio query con OLTP in-memoriaEnabling and using Query Store with In-Memory OLTP

Il semplice esempio seguente è una dimostrazione dell'uso di Archivio query con OLTP in memoria in uno scenario utente end-to-end.The following simple example demonstrates using Query Store with in-memory OLTP in an end-to-end user scenario. In questo esempio si presuppone che un database (MemoryOLTP) sia abilitato per OLTP in memoria.In this example we assume that a database (MemoryOLTP) is enabled for in-memory OLTP.
Per altri dettagli sui prerequisiti per le tabelle con ottimizzazione per la memoria, vedere Creazione di una tabella con ottimizzazione per la memoria e di una stored procedure compilata in modo nativo.For more details on prerequisites for memory-optimized tables, see Creating a Memory-Optimized Table and a Natively Compiled Stored Procedure.

USE MemoryOLTP;  
GO  

-- Create a simple memory-optimized table   
CREATE TABLE dbo.Ord  
   (OrdNo INTEGER not null PRIMARY KEY NONCLUSTERED,   
    OrdDate DATETIME not null,   
    CustCode NVARCHAR(5) not null)   
WITH (MEMORY_OPTIMIZED=ON);  
GO  

-- Enable Query Store before native module compilation  
ALTER DATABASE MemoryOLTP SET QUERY_STORE = ON;  
GO  

-- Create natively compiled stored procedure  
CREATE PROCEDURE dbo.OrderInsert(@OrdNo integer, @CustCode nvarchar(5))  
WITH NATIVE_COMPILATION, SCHEMABINDING  
AS   
    BEGIN ATOMIC WITH  
    (TRANSACTION ISOLATION LEVEL = SNAPSHOT,  
    LANGUAGE = N'English')  

    DECLARE @OrdDate DATETIME = GETDATE();  
    INSERT INTO dbo.Ord (OrdNo, CustCode, OrdDate)   
        VALUES (@OrdNo, @CustCode, @OrdDate);  
END;  
GO  

-- Enable runtime stats collection for queries from dbo.OrderInsert stored procedure  
DECLARE @db_id INT = DB_ID()  
DECLARE @proc_id INT = OBJECT_ID('dbo.OrderInsert');  
DECLARE @collection_enabled BIT;  

EXEC [sys].[sp_xtp_control_query_exec_stats] @new_collection_value = 1,   
    @database_id = @db_id, @xtp_object_id = @proc_id;  

-- Check the state of the collection flag  
EXEC sp_xtp_control_query_exec_stats @database_id = @db_id,   
    @xtp_object_id = @proc_id,   
    @old_collection_value= @collection_enabled output;  
SELECT @collection_enabled AS 'collection status';  

-- Execute natively compiled workload  
EXEC dbo.OrderInsert 1, 'A';  
EXEC dbo.OrderInsert 2, 'B';  
EXEC dbo.OrderInsert 3, 'C';  
EXEC dbo.OrderInsert 4, 'D';  
EXEC dbo.OrderInsert 5, 'E';  

-- Check Query Store Data  
-- Compile time data  
SELECT q.query_id, plan_id, object_id, query_hash, p.query_plan,  
    p.initial_compile_start_time, p.last_compile_start_time,   
    p.last_execution_time, p.avg_compile_duration,  
    p.last_force_failure_reason, p.force_failure_count  
FROM sys.query_store_query AS q  
JOIN sys.query_store_plan AS p   
    ON q.query_id = p.plan_id  
WHERE q.object_id = OBJECT_ID('dbo.OrderInsert');  

-- Get runtime stats  
-- Check count_executions field to verify that runtime statistics   
-- have been collected by the Query Store  
SELECT q.query_id, p.plan_id, object_id, rsi.start_time, rsi.end_time,    
    p.last_force_failure_reason, p.force_failure_count, rs.*  
FROM sys.query_store_query AS q  
JOIN sys.query_store_plan AS p   
    ON q.query_id = p.plan_id  
JOIN sys.query_store_runtime_stats AS rs   
    ON rs.plan_id = p.plan_id  
JOIN sys.query_store_runtime_stats_interval AS rsi   
    ON rs.runtime_stats_interval_id = rsi.runtime_stats_interval_id  
WHERE q.object_id = OBJECT_ID('dbo.OrderInsert');  

Vedere ancheSee Also

Monitoraggio delle prestazioni con Archivio query Monitoring Performance By Using the Query Store
Creazione di una tabella con ottimizzazione per la memoria e di una stored procedure compilata in modo nativo Creating a Memory-Optimized Table and a Natively Compiled Stored Procedure
Procedure consigliate per l'archivio query Best Practice with the Query Store
Query Store Stored Procedures (Transact-SQL) (Stored procedure di Archivio query - Transact-SQL) Query Store Stored Procedures (Transact-SQL)
Viste del catalogo di Archivio query (Transact-SQL) Query Store Catalog Views (Transact-SQL)