# Statistiques échantillonnées : quand l'échantillon par défaut se trompe

> SQL Server calcule ses statistiques sur un échantillon de pages. Sur une colonne dont les valeurs sont groupées, ou sur une valeur rare, l'estimation peut se tromper d'un facteur vingt. Mesures, conséquences sur les plans, FULLSCAN ciblé, PERSIST_SAMPLE_PERCENT et statistiques filtrées.
>
> Source : https://www.pachadata.com/docs/articles/sqlserver/performances/statistiques-echantillonnees/
> Auteur : Rudi Bruchez · publié le 2026-10-11 · 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 :
>
> Par défaut, SQL Server lit un échantillon de pages entières pour calculer une statistique : moins de 3 % d'une table de 5 millions de lignes dans les essais. Quand les valeurs d'une colonne sont groupées physiquement (des lots écrits à la suite), l'échantillon voit chaque valeur bien plus souvent que la réalité et sous-estime le nombre de valeurs distinctes : 4 839 au lieu de 100 001, un agrégat sous-dimensionné en mémoire qui déborde dans tempdb. Les valeurs rares sont estimées au hasard du tirage, jusqu'à une seule ligne pour 148 réelles.
> 
> `UPDATE STATISTICS ... WITH FULLSCAN` corrige l'estimation, mais la mise à jour automatique suivante revient à l'échantillon par défaut, sauf avec `PERSIST_SAMPLE_PERCENT = ON`.


## L'échantillon par défaut

Une statistique se compose d'un histogramme de 200 pas au plus et d'un vecteur de densité, l'inverse du nombre de valeurs distinctes. La [page sur les statistiques](https://learn.microsoft.com/fr-fr/sql/relational-databases/statistics/statistics) décrit l'échantillonnage : quand la statistique n'est pas calculée sur toutes les lignes, le moteur lit un échantillon. L'échantillon se prend par pages, pas par lignes : toutes les lignes d'une page lue entrent dans le calcul, comme le précise la [page de `UPDATE STATISTICS`](https://learn.microsoft.com/fr-fr/sql/t-sql/statements/update-statistics-transact-sql) à l'option `SAMPLE`.

Sur les tables de test de 5 millions de lignes (environ 600 Mo chacune), `CREATE STATISTICS` sans option a lu 140 992 et 144 704 lignes, soit 2,8 et 2,9 %. Les durées et chiffres de cet article viennent de SQL Server 2025 CU7, dans une base jetable.

## Des valeurs groupées sur les pages

Dans une table de mouvements, les lignes d'un même lot sont souvent écrites à la suite et se retrouvent sur les mêmes pages. La table de test reproduit ce cas, avec une seconde colonne de même cardinalité dont les valeurs sont dispersées :

```sql
USE [PachaDataFormation];
CREATE TABLE dbo.DemoMouvement (
    Id int NOT NULL PRIMARY KEY,
    LotId int NOT NULL,          -- 50 lignes consécutives par lot
    LotAleatoire int NOT NULL,   -- même nombre de valeurs, dispersées
    Montant int NOT NULL,
    Remplissage char(100) NOT NULL DEFAULT ''
);
INSERT INTO dbo.DemoMouvement WITH (TABLOCK) (Id, LotId, LotAleatoire, Montant)
SELECT value, value / 50, ABS(CHECKSUM(NEWID())) % 100000, value % 997
FROM GENERATE_SERIES(1, 5000000);

CREATE STATISTICS st_lot ON dbo.DemoMouvement (LotId);
CREATE STATISTICS st_alea ON dbo.DemoMouvement (LotAleatoire);

-- Densité : 1 / nombre estimé de valeurs distinctes
DBCC SHOW_STATISTICS ('dbo.DemoMouvement', st_lot) WITH DENSITY_VECTOR;
DBCC SHOW_STATISTICS ('dbo.DemoMouvement', st_alea) WITH DENSITY_VECTOR;
```

| Colonne | Valeurs réelles | Densité, échantillon par défaut | Valeurs estimées |
|---|---|---|---|
| `LotAleatoire` (dispersée) | 100 000 | 1,01E-5 | 98 920 |
| `LotId` (groupée) | 100 001 | 2,07E-4 | 4 839 |

Sur la colonne dispersée, l'échantillon est juste. Sur la colonne groupée, chaque page lue contient une soixantaine de lignes, soit un lot complet ou presque et le début du suivant : l'échantillon voit jusqu'à 50 lignes par valeur là où un tirage de lignes au hasard en aurait vu une ou deux, et l'estimation du nombre de valeurs distinctes tombe vingt fois trop bas.

## Les conséquences sur le plan

Deux requêtes, l'une qui filtre sur une valeur inconnue à la compilation (une variable), l'autre qui regroupe par lot. Cache de plans et Query Store de la base vidés avant chaque essai (le Query Store garde le retour d'expérience sur la mémoire depuis SQL Server 2022 : sans le vider, le débordement ne se reproduit pas), `MAXDOP 1` :

```sql
USE [PachaDataFormation];
DECLARE @l int = 777;
SELECT COUNT(*) FROM dbo.DemoMouvement WHERE LotId = @l OPTION (MAXDOP 1);

SELECT LotId, SUM(Montant) AS Total
INTO #g
FROM dbo.DemoMouvement
GROUP BY LotId
OPTION (MAXDOP 1);
DROP TABLE #g;
```

| Statistique sur `LotId` | Filtre : estimé pour 50 réelles | Regroupement : groupes estimés pour 100 001 | Mémoire accordée | Durée du regroupement |
|---|---|---|---|---|
| échantillon par défaut, 1re exécution | 1 033 | 4 839 | 3,8 Mo, débordement dans tempdb | 1 124 ms |
| échantillon par défaut, 2e exécution | 1 033 | 4 839 | 29,8 Mo | 702 ms |
| `FULLSCAN` | 50 | 100 001 | 12,5 Mo | 729 ms |

Le regroupement sous-estimé reçoit une allocation de mémoire trop petite et déborde dans tempdb. À la deuxième exécution, le retour d'expérience sur l'allocation de mémoire (édition Enterprise ; l'agrégat s'exécutait ici en mode batch sur rowstore, qui demande le niveau 150) a corrigé l'allocation, en la surestimant : 29,8 Mo accordés pour 7,4 Mo utilisés, selon le relecteur. L'estimation, elle, est restée à 4 839. Au niveau 140, le relecteur a vu l'agrégat passer en mode ligne et déborder à chaque exécution ; dans l'édition Standard, sans mode batch sur rowstore ni retour d'expérience sur la mémoire, un plan qui déborde ne sera pas corrigé à l'exécution suivante (non mesuré dans cette édition). Le filtre, lui, a gardé le même parcours de table dans les trois cas, faute d'index sur `LotId` ; avec un index, une estimation vingt fois trop haute peut faire préférer un parcours à une recherche.

## Une valeur rare

Le second piège est la valeur rare. La table `dbo.Commande` de test contient 4 900 000 lignes avec le code pays `FR`, puis, sur les 100 000 dernières lignes, les 676 codes de deux lettres en alternance (147 ou 148 lignes chacun, `FR` compris). Cette table n'est pas reproduite ici, et les chiffres changent d'un tirage à l'autre : le tableau est un exemple. Estimations pour une égalité sur quelques codes (`OPTION (RECOMPILE)`, plan estimé, valeurs arrondies par le plan), avec un premier tirage :

| Code | Réel | Échantillon par défaut | `FULLSCAN` |
|---|---|---|---|
| `FR` | 4 900 148 | 4 878 210 | 4 900 148 |
| `AL` | 148 | 55 | 148 |
| `BL` | 148 | 55 | 148 |
| `ZZ` | 148 | 310 | 148 |
| `AB` | 148 | 1 | 148 |

La valeur dominante est bien estimée. Les rares le sont mal, dans les deux sens. `AB` est tombé dans une plage de l'histogramme où l'échantillon n'avait trouvé aucune ligne, et une telle plage donne une estimation d'une ligne ; une valeur absente de l'échantillon mais située dans une plage non vide prend la moyenne de la plage (`AVG_RANGE_ROWS`, 375 dans un essai du relecteur). Sur une table reconstruite à l'identique, un autre tirage a donné `AL` 405, `AB` 142, `BL` 326, `ZZ` 252 : l'erreur change d'une mise à jour à l'autre, ce qui rend le problème intermittent. Dans un troisième tirage, `AB` et `ZZ`, hors des bornes de l'histogramme, ont été estimés à 2 236 lignes chacun. Une estimation d'une ligne peut faire choisir une boucle imbriquée pour une jointure qui devrait traiter 148 lignes, ou bien davantage sur une vraie table (non mesuré ici).

Une statistique filtrée sur les valeurs rares (`WHERE Pays <> 'FR'`) porte sur les seules 99 852 lignes concernées, mais elle est elle aussi échantillonnée si on la crée sans option : 2 987 lignes lues, et `AB` toujours estimé à une ligne dans le premier tirage. Avec `SAMPLE 10 PERCENT`, le relecteur a obtenu 129 à 140 lignes estimées pour 147 ou 148 réelles, en lisant 9 576 lignes ; le coût de calcul n'a pas été mesuré.

## Le FULLSCAN, et ce qui l'efface

La correction est de calculer la statistique de la colonne en cause sur toutes les lignes :

```sql
USE [PachaDataFormation];
UPDATE STATISTICS dbo.DemoMouvement st_lot WITH FULLSCAN;
```

Elle ne dure que jusqu'à la prochaine mise à jour automatique. Celle-ci se déclenche au premier besoin de l'optimiseur après un nombre de modifications égal, pour une grande table et à partir du niveau de compatibilité 130, à la racine carrée de 1 000 fois le nombre de lignes, selon la page sur les statistiques : 70 711 pour 5 millions de lignes. Mesuré après un `FULLSCAN` : 70 000 modifications n'ont rien déclenché, 71 000 l'ont fait sur `dbo.Commande` et 70 711 sur `st_lot` (essai du relecteur), et la mise à jour automatique a relu 140 992 lignes de `dbo.DemoMouvement`, revenant à l'échantillon par défaut. Avant le niveau 130, ce seuil dynamique demandait le trace flag 2371.

[`PERSIST_SAMPLE_PERCENT`](https://learn.microsoft.com/fr-fr/sql/t-sql/statements/update-statistics-transact-sql#persist_sample_percent---on--off-), disponible depuis SQL Server 2016 SP1 CU4 et 2017 CU1, fait garder le pourcentage choisi aux mises à jour suivantes, automatiques comprises :

```sql
USE [PachaDataFormation];
UPDATE STATISTICS dbo.DemoMouvement st_lot WITH FULLSCAN, PERSIST_SAMPLE_PERCENT = ON;

SELECT s.name, sp.rows, sp.rows_sampled, sp.modification_counter,
       sp.last_updated, sp.persisted_sample_percent
FROM sys.stats AS s
CROSS APPLY sys.dm_db_stats_properties(s.object_id, s.stats_id) AS sp
WHERE s.object_id = OBJECT_ID('dbo.DemoMouvement');
```

Mesuré : après 120 000 modifications et une requête, la mise à jour automatique a eu lieu sur toutes les lignes (`rows_sampled` = 5 000 000), avec `persisted_sample_percent` à 100. La documentation précise qu'un `TRUNCATE TABLE` ramène la statistique à l'échantillon par défaut, et qu'une reconstruction d'index le faisait aussi avant SQL Server 2016 SP2 CU17, 2017 CU26 et 2019 CU10.

Un `FULLSCAN` sur une table de plusieurs centaines de millions de lignes coûte cher, et la mise à jour automatique qui le reprend s'exécute au moment où une requête en a besoin, sauf si les mises à jour asynchrones sont actives (voir l'article sur [REORGANIZE et les statistiques asynchrones](../reorganize-statistiques-asynchrones/)). On le réserve aux colonnes où l'échantillon se trompe. Entre l'échantillon par défaut et le `FULLSCAN`, `WITH SAMPLE n PERCENT` est une solution moins chère, qui se garde aussi avec `PERSIST_SAMPLE_PERCENT`. Sans ce réglage, un job de maintenance qui recalcule les statistiques avec l'échantillon par défaut défait le travail ; avec lui, le relecteur a vu `UPDATE STATISTICS` sans option et `sp_updatestats` garder le `FULLSCAN`, seul un `WITH SAMPLE` explicite l'emportant, le temps d'une mise à jour. Une reconstruction d'un index non partitionné (`ALTER INDEX ... REBUILD`) recalcule sa statistique sur toutes les lignes, alors qu'un index partitionné est échantillonné par défaut depuis SQL Server 2014 selon la page sur les statistiques ; les statistiques de colonne comme `st_lot` gardent leur date et leur échantillon (mesuré par le relecteur).

## Trouver les statistiques qui se trompent

Pour repérer une erreur sur le nombre de valeurs distinctes, comparez l'inverse de la densité au `COUNT(DISTINCT)` réel :

```sql
USE [PachaDataFormation];
SELECT COUNT(DISTINCT LotId) AS valeurs_reelles FROM dbo.DemoMouvement;
DBCC SHOW_STATISTICS ('dbo.DemoMouvement', st_lot) WITH DENSITY_VECTOR;  -- 1 / densité
```

La densité peut être juste alors que l'histogramme estime mal une valeur rare : pour celle-ci, comparez le nombre réel de lignes à l'estimation du plan, et regardez le pas de l'histogramme où elle tombe (`DBCC SHOW_STATISTICS ... WITH HISTOGRAM`). Dans un plan réel, un écart entre lignes estimées et lignes réelles sur un parcours ou une recherche, avec une statistique échantillonnée sur la colonne du prédicat, est le signe à chercher ; un regroupement qui déborde dans tempdb en est un autre. Les colonnes qui y sont sujettes : les identifiants de lot, de commande ou de session dans une table ordonnée par date ou par identité, et les colonnes très asymétriques interrogées sur leurs valeurs rares.

Pour finir, supprimez la table de démonstration :

```sql
USE [PachaDataFormation];
DROP TABLE IF EXISTS dbo.DemoMouvement;
```


---

## 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/).
