Le query_id du Query Store : ce qui fait d'une requête deux requêtes

Les règles qui donnent un nouveau query_id à une même requête dans le Query Store, mesurées sur SQL Server 2025 : texte, paramètres, options de session, objet, lot.

Une requête qui apparaît deux fois dans le Query Store, avec deux query_id, deux historiques et deux séries de plans, est une requête que le magasin a vue comme deux, selon ses règles. Ces règles ne sont écrites nulle part en un seul endroit. Cet article les reprend une par une, mesurées, puis donne de quoi retrouver les doublons et les réduire.

Les mesures

Les mesures viennent d’une instance de test SQL Server 2025 CU9 avec sa mise à jour de sécurité (17.0.5015.4), Enterprise Developer sous Linux, sur la base PachaDataFormation en compatibilité 170, Query Store en capture ALL. Chaque variante a été exécutée trois fois dans sa connexion. La requête de référence est une jointure, que le paramétrage simple ne touche pas :

USE [PachaDataFormation];
SELECT COUNT(*) AS nb
FROM Contact.Contact AS c
JOIN Contact.Societe AS s ON s.SocieteId = c.SocieteId;

La base restaurée depuis la sauvegarde de démonstration était en AUTO_CLOSE ON. Les premiers essais ont donné des requêtes manquantes et des compteurs incomplets, qui venaient de là : la dernière section y revient, parce que c’est aussi le réglage par défaut de l’édition Express.

La clé d’une requête

La vue sys.query_store_query et la page Comment le Query Store collecte les données donnent les éléments qui distinguent deux requêtes :

ColonneCe qu’elle représente
query_text_idle texte de l’instruction, une entrée par instruction du lot
context_settings_idles options de session qui influencent le plan, la langue, le format de date, le schéma par défaut
object_idla procédure, la fonction ou le déclencheur qui contient l’instruction, 0 pour une requête ad hoc
batch_sql_handlele lot, renseigné seulement quand l’instruction utilise une table temporaire ou une variable de table
query_parameterization_typeaucun, par l’utilisateur, simple ou forcé

Une différence sur l’un de ces éléments suffit. Le query_hash, lui, est calculé sur la forme logique de la requête : les doublons d’une même requête le partagent en général, ce qui sert à les retrouver.

Ce qui donne, ou non, un nouveau query_id dans le Query Store : texte, paramètres, options de session, objet, lot.

Le texte de l’instruction

La page de Microsoft dit que les commentaires et les espaces avant et après l’instruction sont ignorés, et que ceux de l’intérieur comptent. Mesuré :

DifférenceNouveau query_id
espaces, saut de ligne et commentaire avant ou après l’instructionnon
point-virgule finalnon
un espace de plus à l’intérieuroui
un commentaire /* x */ à l’intérieuroui
mots-clés en minusculesoui
saut de ligne LF contre CRLFoui
une valeur littérale différente, requête non paramétrableoui
un indicateur ajouté (OPTION (MAXDOP 1), OPTION (RECOMPILE))oui

Le texte de l’instruction est comparé caractère par caractère (la déclaration des paramètres a ses propres règles, plus bas), sauf quand le moteur paramètre lui-même la requête (paramétrage simple ou forcé) : le texte enregistré est alors normalisé, et un espace, un commentaire intérieur ou la casse ne créent plus de nouveau query_id. La règle vise donc les requêtes que le moteur ne paramètre pas, jointures comprises, et celles que l’application envoie déjà paramétrées. Le cas du saut de ligne surprend en pratique : le même fichier SQL extrait d’un dépôt Git sur un poste Windows et sur un serveur Linux ne produit pas la même requête quand Git convertit les fins de ligne (core.autocrlf). Les outils qui reformatent le code (un ORM qui change sa génération après une montée de version, un formateur appliqué au dépôt) créent de nouveaux query_id pour les requêtes touchées dont le moteur ne normalise pas le texte.

Le query_hash a été le même pour toutes les variantes de texte qui ne changent pas la logique (espaces, commentaires, casse, saut de ligne, alias de colonne). Il a changé avec les indicateurs : OPTION (MAXDOP 1), OPTION (MAXDOP 2), OPTION (RECOMPILE) et USE HINT ('DISABLE_PARAMETER_SNIFFING') ont donné quatre hachages différents de celui de la requête sans indicateur, alors que la page de sys.query_store_query dit que les indicateurs n’entrent pas dans le calcul : c’est vrai pour un indicateur posé par le Query Store (sp_query_store_set_hints), qui laisse le query_hash et le query_id inchangés, pas pour la clause OPTION. Les mêmes hachages ont été obtenus sur SQL Server 2019, 2022 et 2025. SET FORCEPLAN ON change aussi le hachage. Ces doublons-là échappent donc à un regroupement par query_hash.

Les paramètres

Une requête paramétrée par sp_executesql, ou par le pilote de l’application, est enregistrée avec sa déclaration de paramètres en tête de texte : (@n nvarchar(6))SELECT .... Cette déclaration fait partie du texte, avec ses propres règles :

Différence dans la déclarationNouveau query_id
valeur du paramètrenon
type (nvarchar contre varchar)oui
longueur (nvarchar(6) contre nvarchar(7))oui
casse du type, espacesnon
ordre des paramètres déclarésnon
paramètre déclaré mais inutilisénon

La longueur est le cas fréquent. Un pilote qui déclare la longueur de la chaîne qu’il envoie, plutôt que celle de la colonne, produit une requête par longueur de valeur : Martin et Durand partagent un query_id, Lefèvre en a un autre. La correction est dans l’application, en déclarant la taille du paramètre (la propriété Size d’un SqlParameter, par exemple) à celle de la colonne.

sp_executesql sans paramètre donne la même requête que le texte exécuté directement, ou par EXEC() : le même query_id.

Le paramétrage par le moteur change aussi l’identité :

  • une requête simple (SELECT Nom FROM Contact.Contact WHERE ContactId = 12) est paramétrée automatiquement, avec le type Simple : les valeurs 12 et 13 partagent un query_id, sous le texte (@1 tinyint)SELECT [Nom] FROM [Contact].[Contact] WHERE [ContactId]=@1. Le type du paramètre suit la valeur : 1000 donne (@1 smallint), 100000 (@1 int), soit trois query_id pour la même requête ;
  • la jointure de référence, avec un littéral, n’est pas paramétrée : chaque valeur est une requête ;
  • en PARAMETERIZATION FORCED, la même jointure devient une requête de type Forced, avec un texte normalisé (select COUNT ( * ) as ...) et un autre context_settings_id : toutes les valeurs partagent un nouveau query_id, distinct de celui de la requête avant le changement.

Les options de session

Les options de session qui font partie de la clé du cache des plans entrent dans context_settings_id, même quand elles ne changent pas le résultat : ARITHABORT n’a pas d’effet quand ANSI_WARNINGS est à ON, et il sépare quand même deux requêtes. Chaque option a été changée seule, avant la même requête :

OptionNouveau contexte
ARITHABORT ON (OFF par défaut pour sqlcmd et les pilotes)oui
ANSI_NULLS OFF, ANSI_PADDING OFF, ANSI_WARNINGS OFFoui
QUOTED_IDENTIFIER OFF, CONCAT_NULL_YIELDS_NULL OFF, NUMERIC_ROUNDABORT ONoui
FORCEPLAN ON, ROWCOUNT 5oui
LANGUAGE French, DATEFORMAT dmy, DATEFIRST 1oui
NOCOUNT ON, XACT_ABORT ON, LOCK_TIMEOUT, DEADLOCK_PRIORITY, niveau d’isolationnon

ARITHABORT est le doublon le plus courant, et le moins visible. SSMS ouvre ses sessions en ARITHABORT ON, les applications en OFF (SET ARITHABORT) : la requête copiée depuis l’application et rejouée dans SSMS est, pour le Query Store comme pour le cache des plans, une autre requête, compilée pour son compte, avec un autre plan possible. Pour travailler sur la requête de l’application, il faut exécuter SET ARITHABORT OFF dans SSMS avant de la rejouer.

La langue de la connexion compte aussi : SET LANGUAGE French change à la fois la langue, le format de date et le premier jour de la semaine. Deux applications qui se connectent avec des comptes de langue différente produisent deux requêtes.

Le schéma par défaut de l’utilisateur entre dans le contexte quand l’instruction contient un nom non qualifié. FROM Contact.Contact a donné la même requête pour des utilisateurs de schéma par défaut dbo et Contact. FROM Employe, une table du schéma dbo, exécuté par un utilisateur de schéma par défaut dbo puis par un utilisateur de schéma Contact (qui retombe sur dbo), a donné deux requêtes, de même texte, sur la même table, de contextes différents (default_schema_id). Qualifier les noms par leur schéma supprime ce cas.

L’objet qui contient l’instruction

La même instruction, exécutée en ad hoc et dans une procédure, donne deux requêtes, par object_id. Ce qui arrive ensuite dépend de la façon dont la procédure est modifiée :

Opération sur la procédureNouveau query_id pour l’instruction inchangée
ALTER PROCEDURE, y compris en ajoutant d’autres instructionsnon
CREATE OR ALTER PROCEDUREnon
sp_renamenon
DROP PROCEDURE puis CREATE PROCEDUREoui

La suppression et la recréation donnent un nouvel object_id, donc de nouvelles requêtes pour toutes les instructions de la procédure, sans historique ni plan forcé. Les outils de déploiement qui génèrent des scripts DROP puis CREATE font perdre le suivi à chaque livraison ; la page des bonnes pratiques recommande ALTER. CREATE OR ALTER conserve l’objet.

Les tables temporaires et les variables de table

Une instruction qui utilise une table temporaire ou une variable de table est identifiée aussi par son lot (batch_sql_handle). La même instruction SELECT ... JOIN #t, dans deux lots qui ne diffèrent que par une valeur insérée dans #t, donne deux requêtes. Le même lot réexécuté à l’identique retrouve sa requête. Une application qui construit ses lots avec des valeurs littérales autour d’une table temporaire produit donc une requête par lot, même si l’instruction qui compte ne change jamais. Une procédure stockée règle le cas : son texte ne change pas d’un appel à l’autre.

Les changements sans effet sur le query_id

  • le niveau de compatibilité de la base, passé de 170 à 160 puis revenu ;
  • une colonne ajoutée à une table de la requête ;
  • les plans eux-mêmes : une requête garde son query_id quand son plan change, c’est ce qui permet de comparer les plans successifs.

Les variantes du plan

Deux mécanismes de SQL Server 2022 et 2025 créent eux-mêmes plusieurs query_id pour une seule instruction : l’optimisation des plans sensibles aux paramètres (PSP) et l’optimisation des prédicats de paramètres optionnels (OPPO). Chaque variante a son propre query_id, rattaché à la requête parente et à son plan répartiteur dans sys.query_store_query_variant, et partage son query_hash (optimisation PSP). L’article sur les nouveautés du moteur de SQL Server 2025 montre la conséquence pour ABORT_QUERY_EXECUTION : posé sur une variante, il ne bloque que les appels qui y tombent.

Les requêtes de maintenance

Une maintenance par IndexOptimize d’Ola Hallengren exécute ses commandes par le sys.sp_executesql de la base traitée : ce qu’elle exécute est dans le contexte de cette base, et son magasin l’enregistre. Sur une passe complète (14 reconstructions, 35 réorganisations, 93 mises à jour de statistiques), en capture ALL :

CommandeDans le magasin
ALTER INDEX ... REBUILDune requête interne (is_internal_query = 1) par index, avec le texte de la commande
ALTER INDEX ... REORGANIZErien
UPDATE STATISTICSdes requêtes internes, 82 pour 93 commandes, avec leur durée (jusqu’à 405 ms)
requêtes de métadonnées d’IndexOptimize (sys.indexes, sys.stats…)des requêtes ordinaires, la plupart paramétrées, exécutées jusqu’à 93 fois chacune

Une autre passe, en capture AUTO (5 reconstructions, 44 réorganisations, 102 mises à jour de statistiques), n’a laissé que 12 mises à jour de statistiques, aucune reconstruction, et deux requêtes de métadonnées exécutées plus de 30 fois. Chaque statistique et chaque index ont leur propre texte : une passe ajoute une requête par objet traité, et une commande dont le texte ne change pas retrouve son query_id au passage suivant. Filtrer is_internal_query = 0 écarte les reconstructions et les statistiques des analyses ; les requêtes de métadonnées restent.

Les requêtes des rapports de SSMS

Les rapports de SSMS sur le Query Store interrogent les vues sys.query_store_*. Une requête de ce genre, simulée ici par sp_executesql paramétré, n’est pas exclue du magasin : en capture ALL, elle est enregistrée dès sa première exécution. En capture AUTO, elle suit les seuils ordinaires, 30 exécutions, une seconde de compilation ou 100 ms de processeur sur une journée : exécutée trois fois, elle n’était pas dans le magasin ; exécutée quarante fois, elle y était, comme une requête sur une table. Les rapports, ouverts quelques fois par jour, n’apparaissent donc en général pas dans un magasin en AUTO, sauf une requête de rapport assez coûteuse pour dépasser le seuil de processeur. La mesure vient d’une requête qui imite un rapport, pas d’un rapport de SSMS capturé.

AUTO_CLOSE et l’édition Express

Une base en AUTO_CLOSE ON se ferme quand sa dernière connexion se termine, et se rouvre à la suivante. Le Query Store garde ses statistiques d’exécution en mémoire jusqu’à l’écriture suivante sur disque (DATA_FLUSH_INTERVAL_SECONDS, 900 secondes par défaut), et la documentation dit qu’il les écrit avant l’arrêt de l’instance. Elle ne dit rien de la fermeture d’une base. Mesuré sur une base neuve d’une instance Express, trois connexions successives exécutant chacune 50 fois la même requête, en capture ALL :

AUTO_CLOSEExécutions enregistrées après 1, 2 puis 3 connexionsCompilations
OFF50, 100, 1501
ON13, 25, 603

Le chiffre varie d’une série à l’autre : sur une base neuve de l’instance Developer, 77 exécutions sur 150 en ON et 150 en OFF, et quatre autres séries en ON ont gardé entre 40 et 65 % des exécutions. La perte ne tient pas à l’édition ni à la version : mesurée aussi sur SQL Server 2019 et 2022. Les exécutions manquantes ne reviennent pas plus tard, et un sys.sp_query_store_flush_db exécuté avant chaque déconnexion ne l’empêche pas : elle ne tient donc pas seulement aux statistiques en attente d’écriture. La cause reste inconnue.

À chaque fermeture, la documentation dit que le cache des plans de toute l’instance est vidé ; à la réouverture, la requête est recompilée, et une partie des exécutions ne parvient jamais au magasin. Sur une instance Express (mesuré en 2019, 2022 et 2025, et décrit par un billet archivé de l’équipe SQL Express, pas par la page de référence), une base créée par CREATE DATABASE est en AUTO_CLOSE ON, alors que model est à OFF, et le Query Store y est actif : le magasin y montre une fraction de l’activité. La vérification et la correction :

SELECT name, is_auto_close_on, is_query_store_on
FROM sys.databases;

ALTER DATABASE [PachaDataFormation] SET AUTO_CLOSE OFF;

Retrouver et réduire les doublons

La requête suivante regroupe les requêtes par query_hash et compte, pour chaque groupe, les textes, contextes, objets, lots et types de paramétrage distincts : la colonne qui dépasse 1 oriente vers la cause. Les variantes PSP et OPPO partagent le hachage de leur requête parente avec un autre texte (et un object_id à 0 dans une procédure) : la requête les écarte. Un passage en PARAMETERIZATION FORCED fait dépasser 1 à plusieurs colonnes à la fois. Les doublons qui ne diffèrent que par un indicateur OPTION ou par SET FORCEPLAN ON ont des hachages différents et n’apparaissent pas. Le query_hash ignore les alias de colonnes ; deux requêtes qui ne diffèrent que par leurs alias se retrouvent dans le même groupe.

USE [PachaDataFormation];

SELECT q.query_hash,
       COUNT(*) AS nb_query_id,
       COUNT(DISTINCT q.query_text_id) AS textes,
       COUNT(DISTINCT q.context_settings_id) AS contextes,
       COUNT(DISTINCT q.object_id) AS objets,
       COUNT(DISTINCT ISNULL(q.batch_sql_handle, 0x)) AS lots,
       COUNT(DISTINCT q.query_parameterization_type) AS parametrages,
       MIN(qt.query_sql_text) AS exemple
FROM sys.query_store_query AS q
JOIN sys.query_store_query_text AS qt ON qt.query_text_id = q.query_text_id
WHERE q.is_internal_query = 0
  AND NOT EXISTS (SELECT 1 FROM sys.query_store_query_variant AS v
                  WHERE v.query_variant_query_id = q.query_id)
GROUP BY q.query_hash
HAVING COUNT(*) > 1
ORDER BY nb_query_id DESC;

Pour les contextes, sys.query_context_settings donne le détail : set_options (un masque des options), language_id, date_format, date_first, default_schema_id.

CauseCe qui la réduit
textes, littérauxparamétrer dans l’application ; à défaut, PARAMETERIZATION FORCED sur la base, ou un repère de plan de type TEMPLATE pour une classe de requêtes, seulement si chacune est envoyée seule dans son lot
textes, longueurs de paramètresdéclarer la taille des paramètres à celle de la colonne
textes, reformatageun format de code stable, des fins de ligne fixées dans le dépôt (.gitattributes)
contextesdes options de session identiques ; SET ARITHABORT OFF dans SSMS pour rejouer une requête d’application ; des noms qualifiés par leur schéma
objetsALTER ou CREATE OR ALTER plutôt que DROP puis CREATE
lotsdes procédures stockées plutôt que des lots construits autour de tables temporaires

Le forçage de plan et les indicateurs du Query Store s’attachent à un query_id. Quand une requête a plusieurs query_id indépendants, il faut forcer ou poser l’indicateur sur chacun, et recommencer après chaque changement qui en crée un nouveau : une livraison qui reformate le code ou recrée une procédure efface sans bruit les corrections posées dans le magasin. Microsoft publie une procédure d’exemple, sp_query_store_modify_hints_by_query_hash, qui pose un indicateur sur tous les query_id d’un même query_hash ; elle ne couvre pas les query_id créés après son exécution. Les variantes PSP suivent d’autres règles : une variante sans indicateur propre hérite de l’indicateur posé sur la requête parente, et l’indicateur d’une variante l’emporte sur celui du parent (comportement des indicateurs avec PSP).