Uso del almacén de consultas con OLTP en memoriaUsing the Query Store with In-Memory OLTP

SE APLICA A: síSQL Server síAzure SQL Database noAzure Synapse Analytics (SQL DW) noAlmacenamiento de datos paralelosAPPLIES TO: yesSQL Server yesAzure SQL Database noAzure Synapse Analytics (SQL DW) noParallel Data Warehouse

SQL ServerSQL Server El almacén de consultas permite supervisar el rendimiento del código compilado de forma nativa para cargas de trabajo que ejecuten OLTP en memoria.Query Store allows you to monitor the performance of natively compiled code for workloads running in-memory OLTP.
Las estadísticas de compilación y de runtime se recopilan y exponen de la misma manera que en el caso de cargas de trabajo basadas en disco.Compile and runtime statistics are collected and exposed the same way as for disk-based workloads.
Al migrar a OLTP en memoria, podrá seguir usando las vistas del almacén de consultas en SQL Server Management StudioSQL Server Management Studio , así como los scripts personalizados que haya desarrollado para cargas de trabajo basadas en disco antes de la migración.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. De este modo, no habrá desperdiciado el tiempo invertido en familiarizarse con la tecnología del almacén de consultas y podrá usarlo de forma más generalizada para solucionar problemas de todos los tipos de cargas de trabajo.This saves your investment in learning Query Store technology and makes it generally usable for troubleshooting all type of workloads.
Para obtener información general sobre cómo utilizar el almacén de consultas, consulte Monitoring Performance By Using the Query Store.For general information on using the Query Store, see Monitoring Performance By Using the Query Store.

Para usar el almacén de consultas con OLTP en memoria, no hay que configurar ninguna característica adicional.Using the Query Store with in-memory OLTP does not require any additional feature configuration. Una vez que lo habilite en la base de datos, funcionará para todos los tipos de cargas de trabajo.When you enable it on your database it will work for all types of workloads.
Sin embargo, existen algunos aspectos específicos que los usuarios deben tener en cuenta a la hora de utilizar el almacén de consultas con OLTP en memoria:However, there are some specific aspects that users should be aware of when using Query Store with in-memory OLTP:

  • Cuando se habilita el almacén de consultas, se recopilan de manera predeterminada las consultas, los planes y las estadísticas de tiempo de compilación.When Query Store is enabled, queries, plans and compile-time statistics are collected by default. Pero no se activa la recopilación de estadísticas de runtime, a menos que la habilite explícitamente 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).

  • Al establecer @new_collection_value en 0, el almacén de consultas dejará de recopilar estadísticas en tiempo de ejecución para el procedimiento afectado o para toda la instancia de 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.

  • El valor configurado con sys.sp_xtp_control_query_exec_stats (Transact-SQL) no se conserva.The value configured with sys.sp_xtp_control_query_exec_stats (Transact-SQL) is not persisted. Asegúrese de comprobar y volver a configurar la recopilación de estadísticas después de reiniciar SQL ServerSQL Server.Make sure you check and configure again statistics collection after restarting SQL ServerSQL Server.

  • Como sucede con la recopilación de estadísticas de consulta habitual, el rendimiento puede disminuir si se utiliza el almacén de consultas para efectuar un seguimiento de la ejecución de la carga de trabajo.As in case with regular query statistics collection, performance may decrease when you use Query Store to track workload execution. Habilitar la recopilación de estadísticas únicamente para un subconjunto importante de procedimientos almacenados compilados de forma nativa supone una buena idea.You may want to consider enabling statistics collection only for an important subset of natively compiled stored procedures.

  • Las consultas y los planes se capturan y almacenan en la primera compilación nativa y se actualizan con cada recompilación.Queries and plans are captured and stored on the first native compilation and updated upon every recompilation.

  • Si ha habilitado el almacén de consulta o borrado su contenido después de que se compilaran todos los procedimientos almacenados nativos, tendrá que volver a compilarlos manualmente para que el almacén de consultas pueda capturarlos.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. Esto es igualmente válido si ha quitado consultas manualmente con 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). Use sp_recompile (Transact-SQL) para forzar la recompilación del procedimiento.Use sp_recompile (Transact-SQL) to force procedure recompilation.

  • El almacén de consultas aprovecha mecanismos de generación de planes de OLTP en memoria para capturar el plan de ejecución de la consulta durante la compilación.Query Store leverages plan generation mechanisms from in-memory OLTP to capture query execution plan during the compilation. El plan almacenado es equivalente, desde el punto de vista semántico, al que obtendría usando SET SHOWPLAN_XML ON ; con una diferencia: los planes del almacén de consultas se dividen y almacenan por cada instrucción individual.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.

  • Si ejecuta un almacén de consultas en una base de datos con una carga de trabajo mixta, podrá usar el campo is_natively_compiled de sys.query_store_plan (Transact-SQL) para encontrar rápidamente los planes de consulta que haya generado la compilación de código nativa.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.

  • El modo de captura del almacén de consultas no (el parámetro QUERY_CAPTURE_MODE de la instrucción ALTER TABLE) no afecta a las consultas de módulos compilados de forma nativa, ya que estas se capturan siempre, con independencia del valor configurado.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. Esto incluye la opción QUERY_CAPTURE_MODE = NONE.This includes setting QUERY_CAPTURE_MODE = NONE.

  • En la duración de la compilación de la consulta que captura el almacén de consultas se incluye únicamente el tiempo dedicado a la optimización de la consulta, antes de la generación del código nativo.The duration of query compilation captured by the Query Store includes only time spent in query optimization, before the native code was generated. Más concretamente, no incluye el tiempo de compilación de código de C y la generación de las estructuras internas necesarias para la generación de código de C.More precisely, it doesn't include time for C code compilation and generation of internal structures necessary for C code generation.

  • Las métricas de concesiones de memoria dentro de sys.query_store_runtime_stats (Transact-SQL) no se rellenan en las consultas compiladas de manera nativa; sus valores siempre son 0.Memory grants metrics within sys.query_store_runtime_stats (Transact-SQL) are not populated for natively compiled queries - their values are always 0. Estas son las columnas de concesión de memoria: avg_query_max_used_memory, last_query_max_used_memory, min_query_max_used_memory, max_query_max_used_memory y 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.

Habilitación y uso del almacén de consultas con OLTP en memoriaEnabling and using Query Store with In-Memory OLTP

En el ejemplo siguiente se demuestra el uso del almacén de consultas con OLTP en memoria en un escenario de usuario integral.The following simple example demonstrates using Query Store with in-memory OLTP in an end-to-end user scenario. En este ejemplo, se supone que una base de datos (MemoryOLTP) está habilitada para OLTP en memoria.In this example we assume that a database (MemoryOLTP) is enabled for in-memory OLTP.
Para obtener más información sobre los requisitos previos de las tablas optimizadas para memoria, vea Crear una tabla optimizada para memoria y un procedimiento almacenado compilado de forma nativa.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');  

Consulte tambiénSee Also

Monitoring Performance By Using the Query Store Monitoring Performance By Using the Query Store
Crear una tabla con optimización para memoria y un procedimiento almacenado compilado de forma nativa Creating a Memory-Optimized Table and a Natively Compiled Stored Procedure
Procedimiento recomendado con el Almacén de consultas Best Practice with the Query Store
Query Store Stored Procedures (Transact-SQL) (Procedimientos almacenados del almacén de consultas (Transact-SQL)) Query Store Stored Procedures (Transact-SQL)
Query Store Catalog Views (Transact-SQL) (Vistas de catálogo del almacén de consultas (Transact-SQL))Query Store Catalog Views (Transact-SQL)