# 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.
>
> Source : https://www.pachadata.com/docs/articles/sqlserver/performances/query-store-query-id/
> Auteur : Rudi Bruchez · publié le 2026-10-17 · mis à jour le 2026-11-15
> Version Markdown de la page, pour les outils et les LLM. La page HTML fait référence.


> TL;DR :
>
> Le Query Store identifie une requête par le texte exact de l'instruction, les options de session qui influencent le plan, l'objet qui la contient, le lot quand elle utilise une table temporaire, et le type de paramétrage. Pour une requête que le moteur ne paramètre pas, un espace ou un commentaire dans l'instruction, une majuscule ; dans tous les cas, la longueur d'un paramètre utilisé, `ARITHABORT` différent entre SSMS et l'application, une procédure supprimée puis recréée donnent chacun un nouveau `query_id`, et le plan forcé ou l'indicateur posé sur l'ancien ne le suit pas. Le `query_hash` regroupe ces doublons, sauf ceux qui diffèrent par un indicateur `OPTION` ou par `SET FORCEPLAN` ; la requête de détection en fin d'article oriente vers ce qui les sépare.


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 :

```sql
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`](https://learn.microsoft.com/fr-fr/sql/relational-databases/system-catalog-views/sys-query-store-query-transact-sql) et la page [Comment le Query Store collecte les données](https://learn.microsoft.com/fr-fr/sql/relational-databases/performance/how-query-store-collects-data) donnent les éléments qui distinguent deux requêtes :

| Colonne | Ce qu'elle représente |
|---|---|
| `query_text_id` | le texte de l'instruction, une entrée par instruction du lot |
| `context_settings_id` | les options de session qui influencent le plan, la langue, le format de date, le schéma par défaut |
| `object_id` | la procédure, la fonction ou le déclencheur qui contient l'instruction, 0 pour une requête ad hoc |
| `batch_sql_handle` | le lot, renseigné seulement quand l'instruction utilise une table temporaire ou une variable de table |
| `query_parameterization_type` | aucun, 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.](query-id-facteurs.puml.svg)

## 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érence | Nouveau `query_id` |
|---|---|
| espaces, saut de ligne et commentaire avant ou après l'instruction | non |
| point-virgule final | non |
| un espace de plus à l'intérieur | oui |
| un commentaire `/* x */` à l'intérieur | oui |
| mots-clés en minuscules | oui |
| saut de ligne `LF` contre `CRLF` | oui |
| une valeur littérale différente, requête non paramétrable | oui |
| 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éclaration | Nouveau `query_id` |
|---|---|
| valeur du paramètre | non |
| type (`nvarchar` contre `varchar`) | oui |
| longueur (`nvarchar(6)` contre `nvarchar(7)`) | oui |
| casse du type, espaces | non |
| ordre des paramètres déclarés | non |
| 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 :

| Option | Nouveau contexte |
|---|---|
| `ARITHABORT ON` (`OFF` par défaut pour `sqlcmd` et les pilotes) | oui |
| `ANSI_NULLS OFF`, `ANSI_PADDING OFF`, `ANSI_WARNINGS OFF` | oui |
| `QUOTED_IDENTIFIER OFF`, `CONCAT_NULL_YIELDS_NULL OFF`, `NUMERIC_ROUNDABORT ON` | oui |
| `FORCEPLAN ON`, `ROWCOUNT 5` | oui |
| `LANGUAGE French`, `DATEFORMAT dmy`, `DATEFIRST 1` | oui |
| `NOCOUNT ON`, `XACT_ABORT ON`, `LOCK_TIMEOUT`, `DEADLOCK_PRIORITY`, niveau d'isolation | non |

`ARITHABORT` est le doublon le plus courant, et le moins visible. SSMS ouvre ses sessions en `ARITHABORT ON`, les applications en `OFF` ([SET ARITHABORT](https://learn.microsoft.com/fr-fr/sql/t-sql/statements/set-arithabort-transact-sql)) : 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édure | Nouveau `query_id` pour l'instruction inchangée |
|---|---|
| `ALTER PROCEDURE`, y compris en ajoutant d'autres instructions | non |
| `CREATE OR ALTER PROCEDURE` | non |
| `sp_rename` | non |
| `DROP PROCEDURE` puis `CREATE PROCEDURE` | oui |

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](https://learn.microsoft.com/fr-fr/sql/relational-databases/performance/best-practice-with-the-query-store) 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`](https://learn.microsoft.com/fr-fr/sql/relational-databases/system-catalog-views/sys-query-store-query-variant), et partage son `query_hash` ([optimisation PSP](https://learn.microsoft.com/fr-fr/sql/relational-databases/performance/parameter-sensitive-plan-optimization)). L'article sur les [nouveautés du moteur de SQL Server 2025](https://www.pachadata.com/docs/articles/sqlserver/administration/sql-server-2025-nouveautes-moteur/) 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`](https://ola.hallengren.com/sql-server-index-and-statistics-maintenance.html) 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` :

| Commande | Dans le magasin |
|---|---|
| `ALTER INDEX ... REBUILD` | une requête interne (`is_internal_query = 1`) par index, avec le texte de la commande |
| `ALTER INDEX ... REORGANIZE` | rien |
| `UPDATE STATISTICS` | des 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_CLOSE` | Exécutions enregistrées après 1, 2 puis 3 connexions | Compilations |
|---|---|---|
| `OFF` | 50, 100, 150 | 1 |
| `ON` | 13, 25, 60 | 3 |

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](https://learn.microsoft.com/fr-fr/archive/blogs/sqlexpress/understanding-sql-express-behavior-idle-time-resource-usage-auto_close-and-user-instances), 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 :

```sql
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.

```sql
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`.

| Cause | Ce qui la réduit |
|---|---|
| textes, littéraux | paramé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ètres | déclarer la taille des paramètres à celle de la colonne |
| textes, reformatage | un format de code stable, des fins de ligne fixées dans le dépôt (`.gitattributes`) |
| contextes | des options de session identiques ; `SET ARITHABORT OFF` dans SSMS pour rejouer une requête d'application ; des noms qualifiés par leur schéma |
| objets | `ALTER` ou `CREATE OR ALTER` plutôt que `DROP` puis `CREATE` |
| lots | des 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`](https://github.com/microsoft/sql-server-samples/blob/master/samples/features/query-store/sp_query_store_modify_hints_by_query_hash.sql), 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](https://learn.microsoft.com/fr-fr/sql/relational-databases/performance/parameter-sensitive-plan-optimization#query-store-query-hint-behavior)).


---

## L'auteur

Rudi Bruchez, consultant SQL Server indépendant depuis 2006 : audit de performance, optimisation, migrations, haute disponibilité et formation. Pour un audit ou une intervention sur votre serveur : https://www.pachadata.com/contact/ (audit à distance : https://www.pachadata.com/services/audit-sql-server-a-distance/).
