Leistungsüberwachung mit dem AbfragespeicherMonitoring performance by using the Query Store

Anwendungsbereich:Applies to: JaSQL ServerSQL Server (alle unterstützten Versionen) yesSQL ServerSQL Server (all supported versions) JaAzure SQL-DatenbankAzure SQL DatabaseYesAzure SQL-DatenbankAzure SQL Database JaVerwaltete Azure SQL-InstanzAzure SQL Managed InstanceYesVerwaltete Azure SQL-InstanzAzure SQL Managed Instance JaAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse AnalyticsAnwendungsbereich:Applies to: JaSQL ServerSQL Server (alle unterstützten Versionen) yesSQL ServerSQL Server (all supported versions) JaAzure SQL-DatenbankAzure SQL DatabaseYesAzure SQL-DatenbankAzure SQL Database JaVerwaltete Azure SQL-InstanzAzure SQL Managed InstanceYesVerwaltete Azure SQL-InstanzAzure SQL Managed Instance JaAzure Synapse AnalyticsAzure Synapse AnalyticsyesAzure Synapse AnalyticsAzure Synapse Analytics

Der SQL ServerSQL Server -Abfragespeicher bietet Ihnen Einblick in die Auswahl und die Leistung eines Abfrageplans.The SQL ServerSQL Server Query Store feature provides you with insight on query plan choice and performance. Er vereinfacht das Beheben von Leistungsproblemen, indem er das schnelle Auffinden von Leistungsabweichungen durch Änderungen an Abfrageplänen ermöglicht.It simplifies performance troubleshooting by helping you quickly find performance differences caused by query plan changes. Der Abfragespeicher erfasst automatisch einen Verlauf der Abfragen, Pläne und Laufzeitstatistiken und bewahrt diese zur Überprüfung auf.Query Store automatically captures a history of queries, plans, and runtime statistics, and retains these for your review. Es unterteilt die Daten nach Zeitfenstern, sodass Sie Verwendungsmuster für Datenbanken erkennen können und verstehen, wann Abfrageplanänderungen auf dem Server aufgetreten sind.It separates data by time windows so you can see database usage patterns and understand when query plan changes happened on the server. Sie können den Abfragespeicher mit der Option ALTER DATABASE SET konfigurieren.You can configure query store using the ALTER DATABASE SET option.

Informationen zum Betrieb des Abfragespeichers in Azure SQL-DatenbankSQL Database finden Sie unter Verwenden des Abfragespeichers in Azure SQL-Datenbank.For information about operating the Query Store in Azure SQL-DatenbankSQL Database, see Operating the Query Store in Azure SQL Database.

Wichtig

Wenn Sie den Abfragespeicher für Erkenntnisse zu Just-In-Time-Arbeitsauslastungen in SQL Server 2016 (13.x)SQL Server 2016 (13.x) verwenden, planen Sie baldmöglichst die Installation der Fixes zur Leistungsskalierbarkeit in KB 4340759 ein.If you are using Query Store for just in time workload insights in SQL Server 2016 (13.x)SQL Server 2016 (13.x), plan to install the performance scalability fixes in KB 4340759 as soon as possible.

Aktivieren des AbfragespeichersEnabling the Query Store

Standardmäßig ist der Abfragespeicher für neue SQL Server- und Azure Synapse Analytics-Datenbanken (SQL DW) nicht aktiviert. Für neue Azure SQL-Datenbanken ist er hingegen aktiviert.Query Store is not enabled by default for new SQL Server and Azure Synapse Analytics (SQL DW) databases, and is enabled by default for new Azure SQL Database databases.

Verwenden der Seite „Abfragespeicher“ in SQL Server Management StudioSQL Server Management StudioUse the Query Store Page in SQL Server Management StudioSQL Server Management Studio

  1. Klicken Sie im Objekt-Explorer mit der rechten Maustaste auf eine Datenbank und anschließend auf Eigenschaften.In Object Explorer, right-click a database, and then click Properties.

    Hinweis

    Erfordert mindestens Version 16 von Management StudioManagement Studio.Requires at least version 16 of Management StudioManagement Studio.

  2. Wählen Sie im Dialogfeld Datenbankeigenschaften die Seite Abfragespeicher aus.In the Database Properties dialog box, select the Query Store page.

  3. Wählen Sie im Feld Betriebsmodus (angefordert) die Option Lesen und schreiben aus.In the Operation Mode (Requested) box, select Read Write.

Verwenden von Transact-SQL-AnweisungenUse Transact-SQL Statements

Verwenden Sie die Anweisung ALTER DATABASE, um den Abfragespeicher für eine bestimmte Datenbank zu aktivieren.Use the ALTER DATABASE statement to enable the query store for a given database. Beispiel:For example:

SET QUERY_STORE = ON (OPERATION_MODE = READ_WRITE);

Weitere Syntaxoptionen im Zusammenhang mit dem Abfragespeicher finden Sie unter ALTER DATABASE SET-Optionen (Transact-SQL).For more syntax options related to the Query Store, see ALTER DATABASE SET Options (Transact-SQL).

Hinweis

Der Abfragespeicher kann für die master- oder tempdb-Datenbank nicht aktiviert werden.Query Store cannot be enabled for the master or tempdb databases.

Wichtig

Informationen zum Aktivieren des Abfragespeichers und dazu, wie Sie ihn an Ihre Arbeitsauslastung angepasst halten, finden Sie unter Bewährte Methoden für den Abfragespeicher.For information on enabling Query Store and keeping it adjusted to your workload, refer to Best Practice with the Query Store.

Informationen im AbfragespeicherInformation in the Query Store

Die Ausführungspläne für eine bestimmte Abfrage in SQL ServerSQL Server verändern sich i. Allg. im Laufe der Zeit aufgrund unterschiedlicher Ursachen wie z.B. statischer Änderungen, Schemaänderungen, des Erstellens/Löschens von Indizes usw. Der Prozedurcache (in dem zwischengespeicherte Abfragepläne gespeichert werden) speichert nur den letzten Ausführungsplan.Execution plans for any specific query in SQL ServerSQL Server typically evolve over time due to a number of different reasons such as statistics changes, schema changes, creation/deletion of indexes, etc. The procedure cache (where cached query plans are stored) only stores the latest execution plan. Pläne werden auch bei Speicherplatzknappheit aus dem Plancache entfernt.Plans also get evicted from the plan cache due to memory pressure. Aus diesem Grund kann die Problembehandlung bei einer Regression der Abfrageleistung schwierig und zeitaufwendig sein.As a result, query performance regressions caused by execution plan changes can be non-trivial and time consuming to resolve.

Da der Abfragespeicher mehrere Ausführungspläne pro Abfrage beibehält, kann er über Richtlinien den Abfrageprozessor anweisen, für eine Abfrage einen bestimmten Ausführungsplan zu verwenden.Since the Query Store retains multiple execution plans per query, it can enforce policies to direct the Query Processor to use a specific execution plan for a query. Dies wird als Planerzwingung bezeichnet.This is referred to as plan forcing. Das Erzwingen eines Plans im Abfragespeicher erfolgt ähnlich wie beim Abfragehinweis USE PLAN , es erfordert jedoch keine Änderung an Benutzeranwendungen.Plan forcing in Query Store is provided by using a mechanism similar to the USE PLAN query hint, but it does not require any change in user applications. Durch das Erzwingen eines Plans können Sie eine Regression der Abfrageleistung aufgrund einer Änderung des Plans in sehr kurzer Zeit beheben.Plan forcing can resolve a query performance regression caused by a plan change in a very short period of time.

Hinweis

Der Abfragespeicher sammelt Pläne für DML-Anweisungen wie SELECT, INSERT, UPDATE, DELETE, MERGE und BULK INSERT.Query Store collects plans for DML Statements such as SELECT, INSERT, UPDATE, DELETE, MERGE, and BULK INSERT.

Der Abfragespeicher sammelt standardmäßig keine Daten für systemintern kompilierte gespeicherte Prozeduren.Query Store does not collect data for natively compiled stored procedures by default. Verwenden Sie sys.sp_xtp_control_query_exec_stats, um die Datensammlung für systemintern kompilierte gespeicherte Prozeduren zu aktivieren.Use sys.sp_xtp_control_query_exec_stats to enable data collection for natively compiled stored procedures.

Durch Wartestatistiken erhalten Sie weitere Informationen, die Ihnen bei der Problembehandlung der Leistung in Datenbank-EngineDatabase Engine helfen können.Wait stats are another source of information that helps to troubleshoot performance in the Datenbank-EngineDatabase Engine. Lange Zeit waren Wartestatistiken nur auf Instanzebene verfügbar, wodurch es schwierig war, sie einer bestimmten Abfrage zuzuordnen.For a long time, wait statistics were available only on instance level, which made it hard to backtrack waits to a specific query. Ab SQL Server 2017 (14.x)SQL Server 2017 (14.x) und Azure SQL-DatenbankAzure SQL Database bietet der Abfragespeicher eine Dimension, die Wartestatistiken nachverfolgt. Im folgenden Beispiel wird der Abfragespeicher zum Sammeln von Wartestatistiken aktiviert.Starting with SQL Server 2017 (14.x)SQL Server 2017 (14.x) and Azure SQL-DatenbankAzure SQL Database, Query Store includes a dimension that tracks wait stats. The following example enables the Query Store to collect wait stats.

SET QUERY_STORE = ON ( WAIT_STATS_CAPTURE_MODE = ON );

Häufige Szenarios für die Verwendung des Abfragespeichers:Common scenarios for using the Query Store feature are:

  • Schnelles Auffinden und Beheben von Regressionen der Planleistung durch Erzwingung des vorherigen AbfrageplansQuickly find and fix a plan performance regression by forcing the previous query plan. Korrigieren von Abfragen, die in der Vergangenheit aufgrund von Änderungen am Ausführungsplan die Leistung vermindert habenFix queries that have recently regressed in performance due to execution plan changes.
  • Bestimmen der Ausführungshäufigkeit einer Abfrage in einem festgelegten Zeitraum mit Unterstützung eines DBAs bei der Behandlung von Leistungsproblemen mit RessourcenDetermine the number of times a query was executed in a given time window, assisting a DBA in troubleshooting performance resource problems.
  • Identifizieren der häufigsten n Abfragen (nach Ausführungszeit, Speicherverbrauch usw.) in den letzten x Stunden.Identify top n queries (by execution time, memory consumption, etc.) in the past x hours.
  • Überwachen des Verlaufs von Abfrageplänen für eine bestimmte AbfrageAudit the history of query plans for a given query.
  • Analysieren der Verwendungsmuster einer Ressource (CPU, E/A und Arbeitsspeicher) für eine bestimmte DatenbankAnalyze the resource (CPU, I/O, and Memory) usage patterns for a particular database.
  • Identifizieren Sie Top-N-Abfragen, die auf den Ressourcen warten.Identify top n queries that are waiting on resources.
  • Erhalten Sie Einblick in die Wartedetails einer bestimmten Abfrage oder eines bestimmten Plans.Understand wait nature for a particular query or plan.

Der Abfragespeicher enthält drei Speicher:The Query Store contains three stores:

  • einen Planspeicher, der die Informationen zum Ausführungsplan speicherta plan store for persisting the execution plan information.
  • einen Speicher für Laufzeitstatistiken, der die Informationen zum Ausführungsstatistiken speicherta runtime stats store for persisting the execution statistics information.
  • einen Speicher für Wartestatistiken, der die Informationen zum Wartestatistiken speicherta wait stats store for persisting wait statistics information.

Die Anzahl der eindeutigen Pläne, die für eine Abfrage gespeichert werden können, wird durch die Konfigurationsoption max_plans_per_query begrenzt.The number of unique plans that can be stored for a query in the plan store is limited by the max_plans_per_query configuration option. Zum Verbessern der Leistung werden diese Informationen asynchron in die Speicher geschrieben.To enhance performance, the information is written to the stores asynchronously. Um die Speicherverwendung zu minimieren, werden die statistischen Daten zur Laufzeitausführung im Speicher für Laufzeitstatistiken über ein festes Zeitintervall aggregiert.To minimize space usage, the runtime execution statistics in the runtime stats store are aggregated over a fixed time window. Die Informationen in diesen Speichern können durch Abfragen der Katalogsichten für den Abfragespeicher angezeigt werden.The information in these stores is visible by querying the Query Store catalog views.

Die folgende Abfrage gibt Informationen über Abfragen und Pläne im Abfragespeicher zurück.The following query returns information about queries and plans in the Query Store.

SELECT Txt.query_text_id, Txt.query_sql_text, Pl.plan_id, Qry.*
FROM sys.query_store_plan AS Pl
INNER JOIN sys.query_store_query AS Qry
    ON Pl.query_id = Qry.query_id
INNER JOIN sys.query_store_query_text AS Txt
    ON Qry.query_text_id = Txt.query_text_id ;

Verwenden der Funktion „Rückläufige Abfragen“Use the Regressed Queries feature

Aktualisieren Sie nach der Aktivierung des Abfragespeichers den Datenbankbereich im Objekt-Explorer-Bereich, um den Abschnitt Abfragespeicher hinzuzufügen.After enabling the Query Store, refresh the database portion of the Object Explorer pane to add the Query Store section.

SQL Server 2016: Abfragespeicherstruktur im Objekt-Explorer in SSMS SQL Server 2017: Abfragespeicherstruktur im Objekt-Explorer in SSMSSQL Server 2016 Query Store tree in SSMS Object Explorer SQL Server 2017 Query Store tree in SSMS Object Explorer

Wählen Sie Zurückgestellte Abfragen aus, um den Bereich Zurückgestellte Abfragen in SQL Server Management StudioSQL Server Management Studiozu öffnen.Select Regressed Queries to open the Regressed Queries pane in SQL Server Management StudioSQL Server Management Studio. Im Bereich „Regressed Queries“ werden die Abfragen und Pläne im Abfragespeicher angezeigt.The Regressed Queries pane shows you the queries and plans in the query store. Verwenden Sie die Dropdownfelder im oberen Bereich, um Abfragen anhand verschiedener Kriterien zu filtern: Dauer (ms) (Standard), CPU-Zeit (ms), Logische Lesevorgänge (KB), Logische Schreibvorgänge (KB), Physische Lesevorgänge (KB), CLR-Zeit (ms), DOP, Arbeitsspeicherverbrauch (KB), Zeilenanzahl, Verwendeter Protokollspeicher (KB), Verwendeter temporärer DB-Speicher (KB) und Wartezeit (ms).Use the drop-down boxes at the top to filter queries based on various criteria: Duration (ms) (Default), CPU Time (ms), Logical Reads (KB), Logical Writes (KB), Physical Reads (KB), CLR Time (ms), DOP, Memory Consumption (KB), Row Count, Log Memory Used (KB), Temp DB Memory Used (KB), and Wait Time (ms).

Wählen Sie einen Plan aus, um die grafische Darstellung des Abfrageplans anzuzeigen.Select a plan to see the graphical query plan. Schaltflächen stehen zur Verfügung, um die Quellabfrage anzuzeigen, einen Abfrageplan zu erzwingen bzw. seine Erzwingung aufzuheben, zwischen Raster- und Diagrammformaten umzuschalten, ausgewählte Pläne zu vergleichen (wenn mehrere Pläne ausgewählt sind) und die Anzeige zu aktualisieren.Buttons are available to view the source query, force and unforce a query plan, toggle between grid and chart formats, compare selected plans (if more than one is selected), and refresh the display.

SQL Server 2016: Zurückgestellte Abfragen im Objekt-Explorer in SSMSSQL Server 2016 Regressed Queries in SSMS Object Explorer

Wählen Sie eine Abfrage und einen Plan aus, und klicken Sie anschließend auf Plan erzwingen, um einen Plan zu erzwingen.To force a plan, select a query and plan, and then click Force Plan. Sie können nur Pläne erzwingen, die mit dem Abfrageplanfeature gespeichert wurden und sich noch im Abfrageplancache befinden.You can only force plans that were saved by the query plan feature and are still retained in the query plan cache.

Suchen von Wartestatistiken zu AbfragenFinding waiting queries

Ab SQL Server 2017 (14.x)SQL Server 2017 (14.x) und Azure SQL-DatenbankAzure SQL Database sind im Abfragespeicher Wartestatistiken pro Abfrage im Zeitverlauf verfügbar.Starting with SQL Server 2017 (14.x)SQL Server 2017 (14.x) and Azure SQL-DatenbankAzure SQL Database, wait statistics per query over time are available in Query Store.

Im Abfragespeicher werden Wartetypen in Wartekategorien zusammengefasst.In Query Store, wait types are combined into wait categories. Die Zuordnung von Wartekategorien zu Wartetypen finden Sie unter sys.query_store_wait_stats (Transact-SQL).The mapping of wait categories to wait types is available in sys.query_store_wait_stats (Transact-SQL).

Wählen Sie Abfragewartestatistiken aus, um den Bereich Abfragewartestatistiken in SQL Server Management StudioSQL Server Management Studio v18 oder höher zu öffnen.Select Query Wait Statistics to open the Query Wait Statistics pane in SQL Server Management StudioSQL Server Management Studio v18 or higher. Der Bereich „Abfragewartestatistiken“ zeigt ein Balkendiagramm mit den wichtigsten Wartekategorien im Abfragespeicher an.The Query Wait Statistics pane shows you a bar chart containing the top wait categories in the Query Store. Verwenden Sie die Dropdownliste im oberen Bereich, um ein Aggregatkriterium für die Wartezeit auszuwählen: avg, max, min, std dev oder total (Standard).Use the drop-down at the top to select an aggregate criteria for the wait time: avg, max, min, std dev, and total (default).

SQL Server 2017: Statistik der Abfragewartezeit im Objekt-Explorer in SSMSSQL Server 2017 Query Wait Statistics in SSMS Object Explorer

Wählen Sie eine Wartekategorie aus, indem Sie auf die Leiste klicken. Eine Detailansicht der ausgewählten Wartekategorie wird angezeigt.Select a wait category by clicking on the bar and a detail view on the selected wait category displays. Dieses neue Balkendiagramm enthält die Abfragen, die zu dieser Wartekategorie beigetragen haben.This new bar chart contains the queries that contributed to that wait category.

SQL Server 2017: Detailansicht der Statistik der Abfragewartezeit im Objekt-Explorer in SSMSSQL Server 2017 Query Wait Statistics detail view in SSMS Object Explorer

Verwenden Sie die Dropdownfelder im oberen Bereich, um Abfragen nach verschiedenen Wartezeitkriterien für die ausgewählte Wartekategorie zu filtern: avg, max, min, std dev oder total (Standard).Use the drop-down box at the top to filter queries based on various wait time criteria for the selected wait category: avg, max, min, std dev, and total (default). Wählen Sie einen Plan aus, um die grafische Darstellung des Abfrageplans anzuzeigen.Select a plan to see the graphical query plan. Über verschiedene Schaltflächen können Sie die Quellabfrage anzeigen, einen Abfrageplan erzwingen und die Erzwingung wieder aufheben und die Ansicht aktualisieren.Buttons are available to view the source query, force, and unforce a query plan, and refresh the display.

Wartekategorien fassen mehrere Wartetypen in Buckets zusammen, die sich in ihrer Art ähneln.Wait categories are combining different wait types into buckets similar by nature. Verschiedene Wartekategorien erfordern verschiedene Analysen zur Problembehebung. Wartetypen aus der gleichen Kategorien führen jedoch zu sehr ähnlichen Problembehebungsvorgängen. Wenn nun die betroffenen Abfrage in den Wartezuständen bereitgestellt wird, kann ein Großteil der Überprüfungen erfolgreich abgeschlossen werden.Different wait categories require a different follow up analysis to resolve the issue, but wait types from the same category lead to very similar troubleshooting experiences, and providing the affected query on top of waits would be the missing piece to complete the majority of such investigations successfully.

Im folgenden finden Sie einige Beispiele, wie Sie ausführlicheren Einblick in Ihre Workload erhalten, bevor oder nachdem Wartekategorien im Abfragespeicher eingefügt wurden:Here are some examples how you can get more insights into your workload before and after introducing wait categories in Query Store:

Frühere ErfahrungPrevious experience Neue ErfahrungNew experience AktionAction
Lange Wartezustände von RESOURCE_SEMAPHORE pro DatenbankHigh RESOURCE_SEMAPHORE waits per database Lange Speicherwartezustände im Abfragespeicher für bestimmte AbfragenHigh Memory waits in Query Store for specific queries Suchen Sie die im Abfragespeicher die speicherintensivsten Abfragen.Find the top memory consuming queries in Query Store. Diese Abfragen verzögern wahrscheinlich zusätzlich den Fortschritt der betroffen Abfragen.These queries are probably delaying further progress of the affected queries. Ziehen Sie in Betracht, den Abfragehinweis „MAX_GRANT_PERCENT“ für diese Abfragen oder für die betroffene Abfrage zu verwenden.Consider using MAX_GRANT_PERCENT query hint for these queries, or for the affected queries.
Lange Wartezustände von LCK_M_X pro DatenbankHigh LCK_M_X waits per database Lange Sperrwartezustände im Abfragespeicher für bestimmte AbfragenHigh Lock waits in Query Store for specific queries Überprüfen Sie die Abfragetexte der betroffenen Abfragen, und identifizieren Sie die Zielentitäten.Check the query texts for the affected queries and identify the target entities. Suchen Sie im Abfragespeicher nach anderen Abfragen, die die gleiche Entität modifizieren und die häufig ausgeführt werden bzw. oder eine lange Dauer haben.Look in Query Store for other queries modifying the same entity, which are executed frequently and/or have high duration. Nachdem Sie diese Abfragen ermittelt haben, ändern Sie ggf. die Anwendungslogik, um die Parallelität zu verbessern, oder verwenden Sie eine weniger restriktive Isolationsstufe.After identifying these queries, consider changing the application logic to improve concurrency, or use a less restrictive isolation level.
Lange Wartezustände von PAGEIOLATCH_SH pro DatenbankHigh PAGEIOLATCH_SH waits per database Lange Wartezustände der Puffer-E/A im Abfragespeicher für bestimmte AbfragenHigh Buffer IO waits in Query Store for specific queries Suchen Sie die Abfragen mit einer hohen Anzahl an physischen Lesevorgängen im Abfragespeicher.Find the queries with a high number of physical reads in Query Store. Wenn Sie mit den Abfragen mit langen E/A-Wartezuständen übereinstimmen, denken Sie darüber nach, einen Index auf der zugrunde liegenden Entität einzufügen, damit Suchvorgänge statt Scanvorgängen durchgeführt werden und damit der E/A-Aufwand der Abfragen gesenkt wird.If they match the queries with high IO waits, consider introducing an index on the underlying entity, in order to do seeks instead of scans, and thus minimize the IO overhead of the queries.
Lange Wartezustände von SOS_SCHEDULER_YIELD pro DatenbankHigh SOS_SCHEDULER_YIELD waits per database Lange CPU-Wartezustände im Abfragespeicher für bestimmte AbfragenHigh CPU waits in Query Store for specific queries Machen Sie die Abfragen im Abfragespeicher ausfindig, die am meisten CPU nutzen.Find the top CPU consuming queries in Query Store. Bestimmen Sie dann, welche dieser Abfragen sowohl eine hohe CPU-Auslastung als auch lange CPU-Wartezustände für die betroffenen Abfragen aufweisen.Among them, identify the queries for which high CPU trend correlates with high CPU waits for the affected queries. Konzentrieren Sie sich darauf, diese Abfragen zu optimieren: möglicherweise gibt es eine Planregression, oder es fehlt ein Index.Focus on optimizing those queries - there could be a plan regression, or perhaps a missing index.

KonfigurationsoptionenConfiguration Options

Weitere Informationen zu den verfügbaren Konfigurationsoptionen für Abfragespeicherparameter finden Sie unter ALTER DATABASE SET-Optionen (Transact-SQL).For the available options to configure Query Store parameters, see ALTER DATABASE SET options (Transact-SQL).

Fragen Sie die Sicht sys.database_query_store_options ab, um die aktuellen Optionen des Abfragespeichers zu ermitteln.Query the sys.database_query_store_options view to determine the current options of the Query Store. Weitere Informationen zu den Werten finden Sie unter sys.database_query_store_options.For more information about the values, see sys.database_query_store_options.

Beispiele für das Festlegen der Konfigurationsoptionen mit Transact-SQLTransact-SQL-Anweisungen finden Sie unter Optionsverwaltung.For examples about setting configuration options using Transact-SQLTransact-SQL statements, see Option Management.

Überprüfen und verwalten Sie den Abfragespeicher mit Management StudioManagement Studio oder mithilfe der folgenden Sichten und Prozeduren.View and manage Query Store through Management StudioManagement Studio or by using the following views and procedures.

Funktionen des AbfragespeichersQuery Store Functions

Funktionen unterstützen Sie bei den Vorgängen des Abfragespeichers.Functions help operations with the Query Store.

Katalogsichten des AbfragespeichersQuery Store Catalog Views

Katalogsichten stellen Informationen über den Abfragespeicher bereit.Catalog views present information about the Query Store.

Gespeicherte Prozeduren für den AbfragespeicherQuery Store Stored Procedures

Gespeicherte Prozeduren ermöglichen das Konfigurieren des Abfragespeichers.Stored procedures configure the Query Store.

sp_query_store_consistency_check (Transct-SQL)sp_query_store_consistency_check (Transct-SQL)

Wichtige VerwendungsszenarienKey Usage Scenarios

OptionsverwaltungOption Management

Dieser Abschnitt enthält einige Richtlinien zum Verwalten des Abfragespeichers selbst.This section provides some guidelines on managing Query Store feature itself.

Ist der Abfragespeicher derzeit aktiv?Is Query Store currently active?

Der Abfragespeicher speichert seine Daten in der Benutzerdatenbank und besitzt aus diesem Grund eine Größenbegrenzung (konfiguriert mit MAX_STORAGE_SIZE_MB).Query Store stores its data inside the user database and that is why it has size limit (configured with MAX_STORAGE_SIZE_MB). Wenn die Daten im Abfragespeicher dieses Limit erreichen, ändert sich der Status automatisch vom Lese-/ Schreibzugriff in den schreibgeschützten Modus, und es werden keine neuen Daten mehr erfasst.If data in Query Store hits that limit Query Store will automatically change state from read-write to read-only and stop collecting new data.

Fragen Sie sys.database_query_store_options ab, um zu ermitteln, ob der Abfragespeicher zurzeit aktiv ist und Laufzeitstatistiken erfasst.Query sys.database_query_store_options to determine if Query Store is currently active, and whether it is currently collects runtime stats or not.

SELECT actual_state, actual_state_desc, readonly_reason,
    current_storage_size_mb, max_storage_size_mb
FROM sys.database_query_store_options;

Der Status des Abfragespeichers wird durch die „actual_state“-Spalte bestimmt.Query Store status is determined by actual_state column. Wenn er vom gewünschten Status abweicht, können Sie über die readonly_reason-Spalte weitere Informationen erhalten.If it's different than the desired status, the readonly_reason column can give you more information. Wenn der Abfragespeicher das Kontingent überschreitet, wird das Feature in den Modus „read_only“ versetzt.When Query Store size exceeds the quota, the feature will switch to read_only mode.

Abrufen von Optionen zum AbfragespeicherGet Query Store options

Führen Sie zum Abrufen detaillierter Informationen zum Status des Abfragespeichers Folgendes in einer Benutzerdatenbank aus.To find out detailed information about Query Store status, execute following in a user database.

SELECT * FROM sys.database_query_store_options;

Festlegen des AbfragespeicherintervallsSetting Query Store interval

Sie können das Intervall zum Sammeln von Statistiken zur Abfragelaufzeit überschreiben (der Standardwert ist 60 Minuten).You can override interval for aggregating query runtime statistics (default is 60 minutes).

ALTER DATABASE <database_name>
SET QUERY_STORE (INTERVAL_LENGTH_MINUTES = 15);

Hinweis

Ganzzahlige Werte sind für den Typ INTERVAL_LENGTH_MINUTES nicht zulässig.Arbitrary values are not allowed for INTERVAL_LENGTH_MINUTES. Verwenden Sie einen der folgenden Werte: 1, 5, 10, 15, 30, 60 oder 1440 Minuten.Use one of the following: 1, 5, 10, 15, 30, 60, or 1440 minutes.

Der neue Wert für das Intervall wird über die Sicht sys.database_query_store_options offen gelegt.New value for interval is exposed through sys.database_query_store_options view.

Die Speicherplatzverwendung des AbfragespeichersQuery Store space usage

So überprüfen Sie die aktuelle Größe des Abfragespeichers und begrenzen die folgende Anweisung in der Benutzerdatenbank.To check current the Query Store size and limit execute the following statement in the user database.

SELECT current_storage_size_mb, max_storage_size_mb
FROM sys.database_query_store_options;

Mit der folgenden Anweisung können Sie den Speicher erweitern, wenn der Abfragespeicher voll ist.If the Query Store storage is full use the following statement to extend the storage.

ALTER DATABASE <database_name>
SET QUERY_STORE (MAX_STORAGE_SIZE_MB = <new_size>);

Festlegen von Optionen zum AbfragespeicherSet Query Store options

Sie können mehrere Optionen zum Abfragespeicher gleichzeitig mit einer einzigen ALTER DATABASE-Anweisung festlegen.You can set multiple Query Store options at once with a single ALTER DATABASE statement.

ALTER DATABASE <database name>
SET QUERY_STORE (
    OPERATION_MODE = READ_WRITE,
    CLEANUP_POLICY = (STALE_QUERY_THRESHOLD_DAYS = 30),
    DATA_FLUSH_INTERVAL_SECONDS = 3000,
    MAX_STORAGE_SIZE_MB = 500,
    INTERVAL_LENGTH_MINUTES = 15,
    SIZE_BASED_CLEANUP_MODE = AUTO,
    QUERY_CAPTURE_MODE = AUTO,
    MAX_PLANS_PER_QUERY = 1000,
    WAIT_STATS_CAPTURE_MODE = ON
);

Eine vollständige Liste der Konfigurationsoptionen finden Sie unter ALTER DATABASE SET-Optionen (Transact-SQL).For the full list of configuration options, see ALTER DATABASE SET Options (Transact-SQL).

Bereinigen des SpeicherplatzesCleaning up the space

Die internen Tabellen des Abfragespeichers werden beim Erstellen der Datenbank in der PRIMÄREN Dateigruppe erstellt. Diese Konfiguration kann später nicht mehr geändert werden.Query Store internal tables are created in the PRIMARY filegroup during database creation and that configuration cannot be changed later. Wenn nicht mehr genügend Speicherplatz vorhanden ist, sollten Sie mithilfe der folgenden Anweisung ältere Daten aus dem Abfragespeicher löschen.If you are running out of space you might want to clear older Query Store data by using the following statement.

ALTER DATABASE <db_name> SET QUERY_STORE CLEAR;

Sie können auch nur Ad-hoc-Abfragedaten löschen, da diese evtl. für die Abfrageoptimierung und Plananalyse weniger wichtig sind, aber trotzdem viel Platz einnehmen.Alternatively, you might want to clear up only ad-hoc query data, since it is less relevant for query optimizations and plan analysis but takes up just as much space.

Löschen von Ad-hoc-AbfragenDelete ad-hoc queries

Dadurch werden Ad-hoc- und interne Abfragen alle 3 Minuten aus dem Abfragespeicher gelöscht, damit der Abfragespeicher über ausreichend Speicherplatz verfügt und keine Abfragen entfernt, die unbedingt nachverfolgt werden müssen.This purges adhoc and internal queries from the query store every 3 minutes so that the query store does not run out of space and remove queries we really need to track

SET NOCOUNT ON
-- This purges adhoc and internal queries from the query store every 3 minutes so that the
-- query store does not run out of space and remove queries we really need to track
DECLARE @command varchar(1000)

SELECT @command = 'IF ''?'' NOT IN(''master'', ''model'', ''msdb'', ''tempdb'') BEGIN USE ?
EXEC(''
DECLARE @id int
DECLARE adhoc_queries_cursor CURSOR
FOR
SELECT q.query_id
FROM sys.query_store_query_text AS qt
JOIN sys.query_store_query AS q
ON q.query_text_id = qt.query_text_id
JOIN sys.query_store_plan AS p
ON p.query_id = q.query_id
JOIN sys.query_store_runtime_stats AS rs
ON rs.plan_id = p.plan_id
WHERE q.is_internal_query = 1 ' -- is it an internal query then we dont care to keep track of it

' OR q.object_id = 0' -- if it does not have a valid object_id then it is an adhoc query and we dont care about keeping track of it
' GROUP BY q.query_id
HAVING MAX(rs.last_execution_time) < DATEADD (minute, -5, GETUTCDATE()) ' -- if it has been more than 5 minutes since the adhoc query ran
' ORDER BY q.query_id ;
OPEN adhoc_queries_cursor ;
FETCH NEXT FROM adhoc_queries_cursor INTO @id;
WHILE @@fetch_status = 0
BEGIN
EXEC sp_query_store_remove_query @id
FETCH NEXT FROM adhoc_queries_cursor INTO @id
END
CLOSE adhoc_queries_cursor ;
DEALLOCATE adhoc_queries_cursor;
'') END' ;
EXEC sp_MSforeachdb @command

Sie können eine eigene Prozedur mit abweichender Logik für das Bereinigen von Daten definieren, die Sie nicht mehr benötigen.You can define your own procedure with different logic for clearing up data you no longer want.

Im Beispiel oben wird die erweiterte gespeicherte Prozedur sp_query_store_remove_query verwendet, um nicht benötigte Daten zu entfernen.The example above uses the sp_query_store_remove_query extended stored procedure for removing unnecessary data. Sie können auch Folgendes verwenden:You can also use:

  • sp_query_store_reset_exec_stats, um Laufzeitstatistiken für einen bestimmten Plan zu löschen.sp_query_store_reset_exec_stats to clear runtime statistics for a given plan.
  • sp_query_store_remove_plan, um einen einzelnen Plan zu entfernen.sp_query_store_remove_plan to remove a single plan.

Leistungsüberwachung und ProblembehandlungPerformance Auditing and Troubleshooting

Der Abfragespeicher protokolliert den Verlauf der Kompilierungs- und Laufzeitmetriken während der Abfrageausführungen, sodass Sie Fragen zu Ihrer Arbeitsauslastung stellen können.Query Store keeps a history of compilation and runtime metrics throughout query executions, allowing you to ask questions about your workload.

Welche waren die letzten n Abfragen, die für die Datenbank ausgeführt wurden?Last n queries executed on the database?

SELECT TOP 10 qt.query_sql_text, q.query_id,
    qt.query_text_id, p.plan_id, rs.last_execution_time
FROM sys.query_store_query_text AS qt
JOIN sys.query_store_query AS q
    ON qt.query_text_id = q.query_text_id
JOIN sys.query_store_plan AS p
    ON q.query_id = p.query_id
JOIN sys.query_store_runtime_stats AS rs
    ON p.plan_id = rs.plan_id
ORDER BY rs.last_execution_time DESC;

Wie oft wurde jede Abfrage ausgeführt?Number of executions for each query?

SELECT q.query_id, qt.query_text_id, qt.query_sql_text,
    SUM(rs.count_executions) AS total_execution_count
FROM sys.query_store_query_text AS qt
JOIN sys.query_store_query AS q
    ON qt.query_text_id = q.query_text_id
JOIN sys.query_store_plan AS p
    ON q.query_id = p.query_id
JOIN sys.query_store_runtime_stats AS rs
    ON p.plan_id = rs.plan_id
GROUP BY q.query_id, qt.query_text_id, qt.query_sql_text
ORDER BY total_execution_count DESC;

Wie viele Abfragen weisen die längste durchschnittliche Ausführungszeit innerhalb der letzten Stunde auf?The number of queries with the longest average execution time within last hour?

SELECT TOP 10 rs.avg_duration, qt.query_sql_text, q.query_id,
    qt.query_text_id, p.plan_id, GETUTCDATE() AS CurrentUTCTime,
    rs.last_execution_time
FROM sys.query_store_query_text AS qt
JOIN sys.query_store_query AS q
    ON qt.query_text_id = q.query_text_id
JOIN sys.query_store_plan AS p
    ON q.query_id = p.query_id
JOIN sys.query_store_runtime_stats AS rs
    ON p.plan_id = rs.plan_id
WHERE rs.last_execution_time > DATEADD(hour, -1, GETUTCDATE())
ORDER BY rs.avg_duration DESC;

Wie viele Abfragen weisen die umfangreichsten durchschnittlichen physischen E/A-Lesevorgänge in den letzten 24 Stunden auf (mit der entsprechenden durchschnittlichen Zeilen- und Ausführungsanzahl)?The number of queries that had the biggest average physical I/O reads in last 24 hours, with corresponding average row count and execution count?

SELECT TOP 10 rs.avg_physical_io_reads, qt.query_sql_text,
    q.query_id, qt.query_text_id, p.plan_id, rs.runtime_stats_id,
    rsi.start_time, rsi.end_time, rs.avg_rowcount, rs.count_executions
FROM sys.query_store_query_text AS qt
JOIN sys.query_store_query AS q
    ON qt.query_text_id = q.query_text_id
JOIN sys.query_store_plan AS p
    ON q.query_id = p.query_id
JOIN sys.query_store_runtime_stats AS rs
    ON p.plan_id = rs.plan_id
JOIN sys.query_store_runtime_stats_interval AS rsi
    ON rsi.runtime_stats_interval_id = rs.runtime_stats_interval_id
WHERE rsi.start_time >= DATEADD(hour, -24, GETUTCDATE())
ORDER BY rs.avg_physical_io_reads DESC;

Gab es Abfragen mit mehreren Plänen?Queries with multiple plans? Diese Abfragen sind besonders interessant, da sie bei Änderungen der Planauswahl zu einer Regression führen können.These queries are especially interesting because they are candidates for regressions due to plan choice change. Die folgende Abfrage erkennt diese Abfragen sowie alle Pläne:The following query identifies these queries along with all plans:

WITH Query_MultPlans
AS
(
SELECT COUNT(*) AS cnt, q.query_id
FROM sys.query_store_query_text AS qt
JOIN sys.query_store_query AS q
    ON qt.query_text_id = q.query_text_id
JOIN sys.query_store_plan AS p
    ON p.query_id = q.query_id
GROUP BY q.query_id
HAVING COUNT(distinct plan_id) > 1
)

SELECT q.query_id, object_name(object_id) AS ContainingObject,
    query_sql_text, plan_id, p.query_plan AS plan_xml,
    p.last_compile_start_time, p.last_execution_time
FROM Query_MultPlans AS qm
JOIN sys.query_store_query AS q
    ON qm.query_id = q.query_id
JOIN sys.query_store_plan AS p
    ON q.query_id = p.query_id
JOIN sys.query_store_query_text qt
    ON qt.query_text_id = q.query_text_id
ORDER BY query_id, plan_id;

Gab es Abfragen, bei denen kürzlich eine Leistungsregression stattgefunden hat (im Vergleich zu einem anderen Zeitpunkt)?Queries that recently regressed in performance (comparing different point in time)? Das folgende Abfragebeispiel gibt alle Abfragen zurück, für die sich die Ausführungszeit in den letzten 48 Stunden aufgrund einer Änderung der Planauswahl verdoppelt hat.The following query example returns all queries for which execution time doubled in last 48 hours due to a plan choice change. Die Abfrage vergleicht alle Intervalle der Laufzeitstatistiken miteinander.Query compares all runtime stat intervals side by side.

SELECT
    qt.query_sql_text,
    q.query_id,
    qt.query_text_id,
    rs1.runtime_stats_id AS runtime_stats_id_1,
    rsi1.start_time AS interval_1,
    p1.plan_id AS plan_1,
    rs1.avg_duration AS avg_duration_1,
    rs2.avg_duration AS avg_duration_2,
    p2.plan_id AS plan_2,
    rsi2.start_time AS interval_2,
    rs2.runtime_stats_id AS runtime_stats_id_2
FROM sys.query_store_query_text AS qt
JOIN sys.query_store_query AS q
    ON qt.query_text_id = q.query_text_id
JOIN sys.query_store_plan AS p1
    ON q.query_id = p1.query_id
JOIN sys.query_store_runtime_stats AS rs1
    ON p1.plan_id = rs1.plan_id
JOIN sys.query_store_runtime_stats_interval AS rsi1
    ON rsi1.runtime_stats_interval_id = rs1.runtime_stats_interval_id
JOIN sys.query_store_plan AS p2
    ON q.query_id = p2.query_id
JOIN sys.query_store_runtime_stats AS rs2
    ON p2.plan_id = rs2.plan_id
JOIN sys.query_store_runtime_stats_interval AS rsi2
    ON rsi2.runtime_stats_interval_id = rs2.runtime_stats_interval_id
WHERE rsi1.start_time > DATEADD(hour, -48, GETUTCDATE())
    AND rsi2.start_time > rsi1.start_time
    AND p1.plan_id <> p2.plan_id
    AND rs2.avg_duration > 2*rs1.avg_duration
ORDER BY q.query_id, rsi1.start_time, rsi2.start_time;

Wenn Sie alle Leistungsregressionen (nicht nur die im Zusammenhang mit einer Änderung der Planauswahl) anzeigen möchten, entfernen Sie einfach die Bedingung AND p1.plan_id <> p2.plan_id aus der vorherigen Abfrage.If you want to see performance all regressions (not only those related to plan choice change) than just remove condition AND p1.plan_id <> p2.plan_id from the previous query.

Abfragen mit der längsten Wartezeit?Queries that are waiting the most? Die Abfrage gibt die 10 Abfragen zurück, die am längsten warten.This query will return top 10 queries that wait the most.

SELECT TOP 10
    qt.query_text_id,
    q.query_id,
    p.plan_id,
    sum(total_query_wait_time_ms) AS sum_total_wait_ms
FROM sys.query_store_wait_stats ws
JOIN sys.query_store_plan p ON ws.plan_id = p.plan_id
JOIN sys.query_store_query q ON p.query_id = q.query_id
JOIN sys.query_store_query_text qt ON q.query_text_id = qt.query_text_id
GROUP BY qt.query_text_id, q.query_id, p.plan_id
ORDER BY sum_total_wait_ms DESC

Gab es Abfragen, bei denen kürzlich eine Leistungsregression stattgefunden hat (Vergleich jüngerer und älterer Ausführungen)?Queries that recently regressed in performance (comparing recent vs. history execution)? Die nächste Abfrage vergleicht die Abfrageausführung basierend auf den Zeiträumen der Ausführung.The next query compares query execution based periods of execution. In diesem speziellen Beispiel vergleicht die Abfrage die Ausführung in jüngster Zeit (1 Stunde) mit einem älteren Zeitraum (letzter Tag) und identifiziert Ausführungen, die zu additional_duration_workloadgeführt haben.In this particular example the query compares execution in recent period (1 hour) vs. history period (last day) and identifies those that introduced additional_duration_workload. Diese Metrik wird als Differenz zwischen aktueller durchschnittlicher Ausführung und älterer durchschnittlicher Ausführung multipliziert mit der Anzahl der letzten Ausführungen berechnet.This metrics is calculated as a difference between recent average execution and history average execution multiplied by the number of recent executions. Sie stellt damit tatsächlich dar, wie viel zusätzliche Zeit die letzten Ausführungen im Vergleich zu älteren benötigt haben:It actually represents how much of additional duration recent executions introduced compared to history:

--- "Recent" workload - last 1 hour
DECLARE @recent_start_time datetimeoffset;
DECLARE @recent_end_time datetimeoffset;
SET @recent_start_time = DATEADD(hour, -1, SYSUTCDATETIME());
SET @recent_end_time = SYSUTCDATETIME();

--- "History" workload
DECLARE @history_start_time datetimeoffset;
DECLARE @history_end_time datetimeoffset;
SET @history_start_time = DATEADD(hour, -24, SYSUTCDATETIME());
SET @history_end_time = SYSUTCDATETIME();

WITH
hist AS
(
    SELECT
        p.query_id query_id,
        ROUND(ROUND(CONVERT(FLOAT, SUM(rs.avg_duration * rs.count_executions)) * 0.001, 2), 2) AS total_duration,
        SUM(rs.count_executions) AS count_executions,
        COUNT(distinct p.plan_id) AS num_plans
     FROM sys.query_store_runtime_stats AS rs
        JOIN sys.query_store_plan AS p ON p.plan_id = rs.plan_id
    WHERE (rs.first_execution_time >= @history_start_time
               AND rs.last_execution_time < @history_end_time)
        OR (rs.first_execution_time <= @history_start_time
               AND rs.last_execution_time > @history_start_time)
        OR (rs.first_execution_time <= @history_end_time
               AND rs.last_execution_time > @history_end_time)
    GROUP BY p.query_id
),
recent AS
(
    SELECT
        p.query_id query_id,
        ROUND(ROUND(CONVERT(FLOAT, SUM(rs.avg_duration * rs.count_executions)) * 0.001, 2), 2) AS total_duration,
        SUM(rs.count_executions) AS count_executions,
        COUNT(distinct p.plan_id) AS num_plans
    FROM sys.query_store_runtime_stats AS rs
        JOIN sys.query_store_plan AS p ON p.plan_id = rs.plan_id
    WHERE  (rs.first_execution_time >= @recent_start_time
               AND rs.last_execution_time < @recent_end_time)
        OR (rs.first_execution_time <= @recent_start_time
               AND rs.last_execution_time > @recent_start_time)
        OR (rs.first_execution_time <= @recent_end_time
               AND rs.last_execution_time > @recent_end_time)
    GROUP BY p.query_id
)
SELECT
    results.query_id AS query_id,
    results.query_text AS query_text,
    results.additional_duration_workload AS additional_duration_workload,
    results.total_duration_recent AS total_duration_recent,
    results.total_duration_hist AS total_duration_hist,
    ISNULL(results.count_executions_recent, 0) AS count_executions_recent,
    ISNULL(results.count_executions_hist, 0) AS count_executions_hist
FROM
(
    SELECT
        hist.query_id AS query_id,
        qt.query_sql_text AS query_text,
        ROUND(CONVERT(float, recent.total_duration/
                   recent.count_executions-hist.total_duration/hist.count_executions)
               *(recent.count_executions), 2) AS additional_duration_workload,
        ROUND(recent.total_duration, 2) AS total_duration_recent,
        ROUND(hist.total_duration, 2) AS total_duration_hist,
        recent.count_executions AS count_executions_recent,
        hist.count_executions AS count_executions_hist
    FROM hist
        JOIN recent
            ON hist.query_id = recent.query_id
        JOIN sys.query_store_query AS q
            ON q.query_id = hist.query_id
        JOIN sys.query_store_query_text AS qt
            ON q.query_text_id = qt.query_text_id
) AS results
WHERE additional_duration_workload > 0
ORDER BY additional_duration_workload DESC
OPTION (MERGE JOIN);

Erhalten einer stabilen AbfrageleistungMaintaining query performance stability

Möglicherweise ist Ihnen bereits aufgefallen, dass SQL ServerSQL Server verschiedene Pläne für mehrmals ausgeführte Abfragen verwendet, was zu unterschiedlicher Ressourcenverwendung und Dauer führt.For queries executed multiple times you may notice that SQL ServerSQL Server uses different plans, resulting in different resource utilization and duration. Mit dem Abfragespeicher können Sie erkennen, wenn die Abfrageleistung abfällt, und den optimalen Plan innerhalb des gewünschten Zeitraums bestimmen.With Query Store you can detect when query performance regressed and determine the optimal plan within a period of interest. Anschließend können Sie diesen optimalen Plan für zukünftige Abfrageausführungen erzwingen.You can then force that optimal plan for future query execution.

Sie können auch abweichende Abfrageleistungen für eine Abfrage mit Parametern ermitteln (entweder automatisch oder manuell parametrisiert).You can also identify inconsistent query performance for a query with parameters (either auto-parameterized or manually parameterized). Sie können unter den verschiedenen Plänen den Plan identifizieren, der schnell und ausreichend geeignet für alle oder die meisten Parameterwerte ist, und diesen anschließend erzwingen. So erhalten Sie eine vorhersagbare Leistung für eine größere Anzahl von Benutzerszenarien.Among different plans you can identify the plan which is fast and optimal enough for all or most of the parameter values and force that plan, keeping predictable performance for the wider set of user scenarios.

Erzwingen eines Plans für eine Abfrage (Anwenden einer Durchsetzungsrichtlinie)Force a plan for a query (apply forcing policy)

Wenn ein Plan für eine bestimmte Abfrage erzwungen wird, versucht SQL ServerSQL Server, den Plan im Optimierer zu erzwingen.When a plan is forced for a certain query, SQL ServerSQL Server tries to force the plan in the optimizer. Wenn das Erzwingen des Plans fehlschlägt, wird ein XEvent ausgelöst, und der Optimierer wird angewiesen, die Optimierung auf die übliche Weise durchzuführen.If plan forcing fails, an XEvent is fired and the optimizer is instructed to optimize in the normal way.

EXEC sp_query_store_force_plan @query_id = 48, @plan_id = 49;

Durch die Verwendung von sp_query_store_force_plan können Sie ausschließlich solche Pläne erzwingen, die vom Abfragespeicher als Plan für diese Abfrage aufgezeichnet wurden.When using sp_query_store_force_plan you can only force plans that were recorded by Query Store as a plan for that query. Es stehen für eine Abfrage also nur Pläne zur Verfügung, die bereits zum Ausführen dieser Abfrage verwendet wurden, während der Abfragespeicher aktiv war.In other words, the only plans available for a query are those that were already used to execute that query while Query Store was active.

Erzwingen eines Plans für schnelle Vorwärts- und statische Cursor Plan forcing support for fast forward and static cursors

Ab SQL Server 2019 (15.x)SQL Server 2019 (15.x) und Azure SQL-Datenbank (alle Bereitstellungsmodelle) unterstützt der Abfragespeicher die Möglichkeit, Abfrageausführungspläne für schnelle Vorwärtscursor und statische Cursor (Transact-SQLTransact-SQL und API) zu erzwingen.Starting with SQL Server 2019 (15.x)SQL Server 2019 (15.x) and Azure SQL Database (all deployment models), Query Store supports the ability to force query execution plans for fast forward and static Transact-SQLTransact-SQL and API cursors. Das Erzwingen wird durch sp_query_store_force_plan oder SQL Server Management StudioSQL Server Management Studio-Abfragespeicherberichte unterstützt.Forcing is supported via sp_query_store_force_plan or through SQL Server Management StudioSQL Server Management Studio Query Store reports.

Aufheben der Erzwingung eines Plans für eine AbfrageRemove plan forcing for a query

Wenn Sie wieder den Abfrageoptimierer von SQL ServerSQL Server verwenden möchten, um den optimalen Abfrageplan zu berechnen, heben Sie mit sp_query_store_unforce_plan das Erzwingen des für die Abfrage ausgewählten Plans auf.To rely again on the SQL ServerSQL Server query optimizer to calculate the optimal query plan, use sp_query_store_unforce_plan to unforce the plan that was selected for the query.

EXEC sp_query_store_unforce_plan @query_id = 48, @plan_id = 49;

Weitere InformationenSee Also