# Les statistiques de chaîne de SQL Server

> Le résumé de chaîne d'une statistique SQL Server, décodé : un échantillon de chaînes dans un trie, la façon dont il estime les LIKE, et ce qui le contourne.
>
> Source : https://www.pachadata.com/docs/articles/sqlserver/performances/statistiques-de-chaines/
> Auteur : Rudi Bruchez · publié le 2026-10-20 · mis à jour le 2026-11-21
> Version Markdown de la page, pour les outils et les LLM. La page HTML fait référence.


*Article coécrit avec Claude, qui a mené une grande partie des tests et des recherches.*

> TL;DR :
>
> Les statistiques de chaîne (*string statistics* en anglais) existent dans SQL Server depuis la version 2005. Elles servent à estimer la cardinalité des recherches avec `LIKE`, par exemple `Email LIKE '%.org'`. Quand la première colonne d'une statistique est de type caractère, la statistique contient, en plus de l'histogramme, un résumé de chaîne. Vous le voyez dans `DBCC SHOW_STATISTICS`, à la propriété `String Index`, qui vaut alors `YES`.
> 
> Ce résumé est un échantillon des valeurs de la colonne, pris sur 5 % des lignes lues par la statistique, jusqu'à 56 000 lignes lues environ. Ensuite la taille de l'échantillon reste vers 2 800 chaînes, quelle que soit la taille de la table. Il y en a un peu moins encore pour les `nvarchar` et les chaînes longues. Les chaînes sont rangées dans un [trie](https://fr.wikipedia.org/wiki/Trie_(informatique)) (arbre préfixe) : chaque nœud contient un morceau de chaîne, et les chaînes qui commencent de la même façon partagent les nœuds de ce début.
> 
> Pour estimer un `LIKE` avec des caractères joker, l'optimiseur applique le motif à chaque chaîne de l'échantillon, puis multiplie la proportion trouvée par le nombre de lignes de la table. Quand aucune chaîne de l'échantillon ne satisfait le motif, la proportion vaudrait zéro, et l'estimation aussi. L'optimiseur fait alors comme si un dixième de chaîne le satisfaisait : sur le million de lignes de la table `Contact.ProspectUS` de ma base de données d'exemple, dont l'échantillon compte 2 825 chaînes, un motif introuvable dans l'échantillon est estimé à 1 000 000 × 0,1 / 2 825, soit 35,4 lignes. C'est le plancher de l'estimation.
> 
> Les motifs fréquents sont correctement estimés, et les motifs rares sont estimés avec une valeur plancher, environ le nombre de lignes divisé par 28 000. Le résumé n'est pas utilisé pour estimer la cardinalité quand la colonne est passée dans une expression, comme un appel de fonction, que le motif utilise `ESCAPE`, vient d'une variable locale ou est de type `nvarchar` face à une colonne `varchar` (donc conversion implicite), ou que la colonne est un `varchar` en collation UTF-8. Dans ces cas, un motif qui commence par un joker est estimé à 9 % du nombre de lignes de la table, et un préfixe est estimé par l'histogramme (pour une colonne en UTF-8, seulement à partir de SQL Server 2025, au niveau de compatibilité 170). Au-delà de 80 caractères, seuls les 40 premiers et les 40 derniers sont conservés, mis bout à bout. Enfin, sur une colonne qui répète un caractère, comme des références complétées de zéros, un motif à plusieurs `%` peut coûter plusieurs secondes de compilation.


## Les statistiques de chaîne

Les statistiques permettent l'estimation de la cardinalité. Elles sont composées de trois éléments : l'entête, le vecteur de densité et un histogramme. Je les ai décrites dans le chapitre [Les statistiques et la cardinalité](https://www.pachadata.com/docs/optimiser-sql-server/chapitres/065.statistiques-et-cardinalite/) du livre *Optimiser SQL Server*, et dans la vidéo [Introduction aux statistiques dans SQL Server](https://youtu.be/a-0JJNXdVsw).

L'histogramme d'une statistique découpe les valeurs de la première colonne en 200 étapes au maximum. Il répond bien à `Nom = 'Dupont'` ou à `Nom >= 'Ma' AND Nom < 'Mb'`, mal à `Email LIKE '%.org'` : la fin d'une chaîne ne dit rien de sa place dans l'ordre de tri. Pour ces prédicats, SQL Server 2005 a ajouté un second objet, stocké avec la statistique, que la documentation appelle *string summary statistics*.

`DBCC SHOW_STATISTICS` est la commande historique de lecture d'une statistique. Elle renvoie trois jeux de résultats : l'en-tête, le vecteur de densité et l'histogramme ; les options `WITH STAT_HEADER`, `DENSITY_VECTOR` et `HISTOGRAM` limitent la sortie à l'une de ces parties. Depuis SQL Server 2012 SP1, la permission `SELECT` sur la table et sur toutes les colonnes de la statistique suffit ; avant, il fallait être propriétaire de la table ou membre de `sysadmin`, `db_owner` ou `db_ddladmin`. Deux fonctions de gestion dynamique la remplacent en partie, et se prêtent mieux aux requêtes sur toute une base : [`sys.dm_db_stats_properties`](https://learn.microsoft.com/fr-fr/sql/relational-databases/system-dynamic-management-views/sys-dm-db-stats-properties-transact-sql) (SQL Server 2008 R2 SP2 et 2012 SP1) pour l'en-tête, et [`sys.dm_db_stats_histogram`](https://learn.microsoft.com/fr-fr/sql/relational-databases/system-dynamic-management-views/sys-dm-db-stats-histogram-transact-sql) (SQL Server 2016 SP1 CU2) pour l'histogramme. Aucune ne donne le vecteur de densité, ni la propriété `String Index`, ni le contenu du résumé de chaîne : pour les statistiques de chaîne, `DBCC SHOW_STATISTICS` reste la seule commande documentée.

La page de documentation de [`DBCC SHOW_STATISTICS`](https://learn.microsoft.com/fr-fr/sql/t-sql/database-console-commands/dbcc-show-statistics-transact-sql) est pratiquement le seul endroit où Microsoft documente aujourd'hui les statistiques de chaînes.
Elle dit que ces statistiques sont stockées à part de l'histogramme, qu'elles servent aux prédicats `LIKE`, et qu'elles sont créées sur la première colonne clé de la statistique quand elle est de type `char`, `varchar`, `nchar`, `nvarchar`, `varchar(max)`, `nvarchar(max)`, `text` ou `ntext`. Elle exclut les colonnes `char` et `varchar` en collation UTF-8. Aucune commande documentée n'affiche le contenu du résumé.

Le reste vient de deux livres blancs, [Statistics Used by the Query Optimizer in Microsoft SQL Server 2005](https://learn.microsoft.com/en-us/previous-versions/sql/sql-server-2005/administrator/cc966419(v=technet.10)) et [sa version 2008](https://learn.microsoft.com/en-us/previous-versions/sql/sql-server-2008/dd535534(v=sql.100)). Ils parlent d'une « technologie brevetée » qui résume la distribution des fréquences des sous-chaînes pour les formes de motif comme `'abc%'`, `'%abc'`, `'%abc%'`, `'a_c'`, `'a[bc]d'`, indiquent qu'un `ESCAPE` explicite casse cette statistique et qu'une chaîne de plus de 80 caractères est réduite à ses 40 premiers et 40 derniers caractères.

Erland Sommarskog présente les statistiques de chaîne à partir d'un cas réel, où elles croisent les objectifs de lignes (*row goals*), dans [String Summary Statistics and Row Goals](https://www.sommarskog.se/Short%20Stories/stringstats.html).

Le brevet est [US 6 829 602](https://patents.google.com/patent/US6829602B2/en), « System and method for using a compressed trie to estimate like predicates », déposé par Microsoft en 2002. Ce brevet n'est cité par aucune source Microsoft dans la documentation SQL Server, mais quand on observe le résumé stocké dans une statistique, on y voit exactement la structure décrite dans le brevet.
De plus, le moteur appelle `CSelCalcTrieBased` le calculateur de sélectivité qui utilise ce résumé (sortie du trace flag 2363, voir « Lire le calculateur »). Comme dans le brevet, le résumé est un trie compressé de chaînes entières, avec un compteur par nœud. Le brevet construit le trie à partir d'un ensemble représentatif de chaînes, et ramène l'estimation à la table entière : si un quart des lignes y a été inséré, l'estimation est multipliée par quatre. SQL Server, de même, ne range dans ce trie qu'une partie des chaînes de la table. Pour estimer un `LIKE`, l'optimiseur compte les chaînes de cet échantillon qui satisfont le motif, et multiplie la proportion obtenue par le nombre de lignes de la table : sur la table `Contact.ProspectUS` de `PachaDataFormation`, la base d'exemple que j'utilise dans mes formations et mes articles, 241 des 2 825 chaînes de l'échantillon se terminent par `.org`, et l'estimation vaut 1 000 000 × 241 / 2 825, soit 85 310 lignes. La section « Lire le résumé » montre comment le vérifier.

Le trie (le mot vient de *retrieval*, la recherche d'information) est un arbre dont chaque chemin, de la racine à un nœud, épelle une chaîne. Les chaînes `Martin`, `Martinez` et `Marty` y partagent un nœud `Mart`, qui a deux enfants, `in` et `y` ; `in` a lui-même un enfant, `ez`. Un nœud compte combien de chaînes de l'échantillon se terminent sur lui : 1 pour `Martin`, 1 pour `Martinez`, 1 pour `Marty`, 0 pour `Mart`. Dans un trie ordinaire, chaque nœud contient un seul caractère : `Mart` y occuperait quatre nœuds à la file, `M`, `a`, `r` et `t`, qui n'ont chacun qu'un enfant. Un trie compressé (on parle aussi d'[arbre radix](https://fr.wikipedia.org/wiki/Arbre_radix), ou arbre PATRICIA) fusionne ces files de nœuds à enfant unique en un seul nœud, qui contient toute la suite de caractères : `Mart` tient alors dans un nœud au lieu de quatre. C'est la forme du résumé de SQL Server, où les morceaux de tous les nœuds sont stockés bout à bout dans une seule suite de caractères, et où chaque nœud donne la position et la longueur du sien dans cette suite. Les chaînes qui partagent leur début, comme les noms de famille ou des codes à préfixe commun, prennent ainsi peu de place.

```mermaid
flowchart TD
    R(("racine")) --> M["Mart<br/>0 chaîne"]
    M --> I["in<br/>1 chaîne : Martin"]
    M --> Y["y<br/>1 chaîne : Marty"]
    I --> E["ez<br/>1 chaîne : Martinez"]
```

Tout ce qui suit a été mesuré sur SQL Server 2025 CU7 (17.0.4065.4), niveau de compatibilité 170, sauf mention de l'estimateur hérité. Les mesures ajoutées le 21 novembre 2026 ont été faites sur SQL Server 2025 CU10 (17.0.5035.5), dans un laboratoire où le moteur tourne sous un débogueur, ce qui m'a permis de lire certaines constantes dans le code ; je le précise à chaque fois.

## Trouver la statistique de chaîne

Les exemples utilisent la table `Contact.ProspectUS` de `PachaDataFormation` : un million de prospects, `Nom` et `Email` en `varchar`, collation `French_CI_AS`. La table a des statistiques créées automatiquement sur ces deux colonnes (`_WA_Sys_...`). Le script de chargement de la base les a recalculées par `UPDATE STATISTICS ... WITH FULLSCAN` : elles ont lu le million de lignes (`rows_sampled` vaut `rows` dans `sys.dm_db_stats_properties`), et non sur l'échantillon qu'une création automatique aurait pris. Sur un million de lignes, l'échantillonnage par défaut lit assez de lignes pour remplir le résumé de chaîne : le `FULLSCAN` ne change pas sa taille, mais il change les chaînes retenues, donc les estimations. Ici, j'appelle `DBCC SHOW_STATISTICS` avec le nom de colonne à la place du nom de la statistique, c'est supporté et c'est pratique :

```sql
USE [PachaDataFormation];
GO
-- La colonne String Index vaut YES ou NO
DBCC SHOW_STATISTICS ('Contact.ProspectUS', Email) WITH STAT_HEADER;
DBCC SHOW_STATISTICS ('Contact.ProspectUS', Nom) WITH STAT_HEADER;
```

Aucune vue système ne montre cette information : ni [`sys.stats`](https://learn.microsoft.com/fr-fr/sql/relational-databases/system-catalog-views/sys-stats-transact-sql) ni [`sys.dm_db_stats_properties`](https://learn.microsoft.com/fr-fr/sql/relational-databases/system-dynamic-management-views/sys-dm-db-stats-properties-transact-sql), ni [`sys.dm_db_stats_histogram`](https://learn.microsoft.com/fr-fr/sql/relational-databases/system-dynamic-management-views/sys-dm-db-stats-histogram-transact-sql). Pour une revue de toutes les statistiques d'une base, il faut passer `DBCC SHOW_STATISTICS ... WITH STAT_HEADER` statistique par statistique, par exemple dans un curseur avec `INSERT ... EXEC`.

Si on regarde sur une colonne, par type et par collation, statistiques sur les mêmes 100 000 valeurs, calculées en `FULLSCAN` :

| Colonne | `String Index` |
|---|---|
| `char`, `varchar`, `nchar`, `nvarchar`, `varchar(max)`, `nvarchar(max)`, `text`, `ntext` | `YES` |
| collations `_CS_AS`, `_BIN2`, `Latin1_General_BIN`, `SQL_Latin1_General_CP1_CI_AS`, `French_CI_AS` | `YES` |
| `nvarchar` en `Latin1_General_100_CI_AS_SC_UTF8` | `YES` |
| `varchar` en `Latin1_General_100_CI_AS_SC_UTF8` | `NO` |
| `varbinary` | `NO` |

L'exclusion UTF-8 ne touche donc que `char` et `varchar`, comme le dit la documentation : un `nvarchar` déclaré dans la même collation conserve son résumé. Pour lui, le suffixe `_UTF8` ne change d'ailleurs rien : `nchar` et `nvarchar` restent en UTF-16, quelle que soit la collation ([Prise en charge d'Unicode](https://learn.microsoft.com/fr-fr/sql/relational-databases/collations/collation-and-unicode-support)), et seules s'appliquent les règles de comparaison du reste du nom (`Latin1_General_100_CI_AS_SC`). Le suffixe ne change l'encodage que des `char` et `varchar`, qui passent en UTF-8. Même chose pour une statistique créée automatiquement (`_WA_Sys_...`), avec l'échantillonnage par défaut.

Le stockage de la table ne change rien : un index columnstore cluster, une table à mémoire optimisée (In-Memory OLTP) et une table temporaire donnent la même estimation qu'une table en lignes sur les mêmes 200 000 chaînes : 781,5 lignes pour 899 réelles avec `'%A1B%'`, et `String Index` vaut `YES` pour le columnstore et la table à mémoire optimisée (2025 CU10). Une statistique construite en parallèle peut prendre un autre échantillon, et donner une autre estimation (voir « L'échantillon »). Une variable de table n'a pas de statistique de colonne, et reçoit l'estimation de 9 %.

## Les prédicats qui en profitent

L'estimateur de cardinalité confie chaque prédicat à un calculateur de sélectivité, un composant interne spécialisé. Ceux qui nous intéressent ici sont `CSelCalcColumnInInterval` pour un intervalle lu dans l'histogramme, `CSelCalcHistogramComparison` pour une comparaison, `CSelCalcTrieBased` pour le résumé de chaîne et `CSelCalcFixedFilter` pour une estimation fixe. Un trace flag non documenté affiche cette information, comme le montre la section « Lire le calculateur ». Si le résumé de chaîne a été utilisé, le calculateur est `CSelCalcTrieBased`.

Sur `Contact.ProspectUS`, estimations du plan, nombres réels et calculateur utilisé :

```sql
USE [PachaDataFormation];
GO
-- Trois écritures du même filtre sur le préfixe
SELECT Nom FROM Contact.ProspectUS WHERE Nom LIKE 'Mc%';
SELECT Nom FROM Contact.ProspectUS WHERE Nom >= 'Mc' AND Nom < 'Md';
SELECT Nom FROM Contact.ProspectUS WHERE LEFT(Nom, 2) = 'Mc';

-- Un suffixe
SELECT Nom FROM Contact.ProspectUS WHERE Email LIKE '%.org';
SELECT Nom FROM Contact.ProspectUS WHERE RIGHT(Email, 4) = '.org';
SELECT Nom FROM Contact.ProspectUS WHERE CHARINDEX('.org', Email) > 0;
```

| Prédicat | Estimation | Réel | Calculateur |
|---|---|---|---|
| `Nom LIKE 'Mc%'` | 17 699 | 17 620 | `CSelCalcTrieBased` |
| `Nom >= 'Mc' AND Nom < 'Md'` | 16 079 | 17 620 | `CSelCalcColumnInInterval` |
| `LEFT(Nom, 2) = 'Mc'` | 12 008 | 17 620 | `CSelCalcHistogramComparison(INTERVAL)` |
| `Email LIKE '%.org'` | 85 310 | 85 060 | `CSelCalcTrieBased` |
| `RIGHT(Email, 4) = '.org'` | 1 | 85 060 | `CSelCalcFixedFilter (0.1)`, puis `CSelCalcPointPredsFreqBased` |
| `CHARINDEX('.org', Email) > 0` | 300 000 | 85 076 | `CSelCalcFixedFilter (0.3)` |

Étonnamment, la recherche par préfixe (`Nom LIKE 'Mc%'`) passe par le résumé de chaîne plutôt que par l'histogramme, et cela donne un meilleur résultat : pour l'intervalle équivalent, l'histogramme doit répartir les lignes des étapes où tombent les bornes, alors que le résumé a compté les chaînes de son échantillon. `LEFT` est estimé comme un intervalle, par un autre calcul sur l'histogramme. Sur une autre table de test, l'écart devient énorme. Elle compte un million de lignes, et les 1 000 valeurs qui commencent par `QA1` sont les plus grandes de la colonne : elles tombent toutes dans la dernière étape de l'histogramme. L'intervalle `s >= 'QA1' AND s < 'QA2'` y est estimé à 2 lignes. `LIKE 'QA1%'`, qui passe par le résumé, est estimé à 710 ou à 1 065 lignes, selon la reconstruction de la statistique (voir « L'échantillon »).

Pour `RIGHT`, la sortie du trace flag 2363 montre deux calculs : une estimation fixe de 10 %, puis une estimation d'égalité tirée de la densité de la colonne `Email`, presque unique, qui donne une ligne pour 85 060 réelles. `CHARINDEX` produit une estimation fixe de 30 % : aucune statistique ne décrit son résultat, et l'optimiseur applique 30 % à toute comparaison `>`, `>=`, `<` ou `<=` qu'il ne sait pas estimer, comme `LEN(Email) > 10` ou `Email > @v` avec une variable locale. `Email <> @v` reçoit 90 % ; `Email = @v` est estimé par la densité. Sur une fonction de la colonne, `=` passe par 10 % puis par la densité, comme `RIGHT` (`LEN(Email) = 10` : une ligne), et `<>` est estimé comme un `<` ou un `>` (`LEN(Email) <> 10` : 510 000).

Sur le jeu de test, avec des chaînes de trois caractères placées en tête, au milieu ou en fin de chaîne, les motifs `'abc%'`, `'%abc'`, `'%abc%'`, `'a_c%'`, `'%a[bc]_%'` et `NOT LIKE` passent tous par le résumé. Il suit la collation : `'%Vill%'` et `'%vïll%'` donnent la même estimation sur une colonne `French_CI_AI` ; en `_CS_AS` ou `_BIN2`, `'%zqw'` et `'%ZQW'` sont estimés séparément, chacun assez près de la réalité.

Le parcours du résumé applique la collation caractère par caractère, quand il voit des caractères, et cela laisse trois trous, mesurés sur des tables de test de 20 000 lignes (2025 CU10) :

- une équivalence entre un caractère et deux n'est pas appliquée. En `Latin1_General_100_CI_AI`, `ß` est égal à `ss`. Sur une colonne dont la moitié des lignes contient `straße` et l'autre moitié `strasse`, `'%ß%'` ramène bien les 20 000 lignes, mais l'estimation ne compte que les chaînes de l'échantillon écrites avec `ß` : 10 317. Même chose pour `Æ` et `ae` : 9 941 et 10 059 pour 20 000 ;
- dans une colonne `varchar` en `Japanese_CI_AS`, le parcours compare des octets et non des caractères. `ア` s'écrit 0x83 0x41, et 0x41 est le code de `A`. Sur une colonne dont un quart des lignes contient `ア` et aucune un `A`, `'%A%'` est estimé à 4 990 lignes pour 0 ;
- en collation `_SC`, `LIKE` compte `_` pour un caractère, même hors du plan multilingue de base, alors que le parcours le compte pour une unité UTF-16. Avec des lettres gothiques, qui occupent deux unités chacune, `N'%𐌰_𐌱%'`, qui ramène 5 000 lignes, est estimé au plancher, et `N'%𐌰__𐌱%'`, qui n'en ramène aucune, à 4 990.

Un motif à plusieurs jokers est estimé d'un bloc, sans hypothèse d'indépendance entre ses morceaux. Sur 100 000 lignes, `AAA` et `BBB` présents chacun dans la moitié des chaînes : quand ils ne sont jamais dans la même chaîne, `'%AAA%BBB%'` est estimé à 3,6 lignes pour 0 ; quand ils sont toujours ensemble, à 49 982 pour 50 000.

L'estimateur hérité (`USE HINT ('FORCE_LEGACY_CARDINALITY_ESTIMATION')`) lit le même résumé : mêmes estimations à la décimale pour tous les `LIKE` de littéraux mesurés qu'il estime par le résumé. Ses estimations sans résumé, elles, diffèrent (plus bas). `NOT LIKE` fait exception : sur 100 000 lignes dont une sur dix est `NULL`, `s NOT LIKE '%A1%'` ramène 83 409 lignes. L'estimateur actuel en estime 83 634, en retirant les `NULL` de l'échantillon ; l'estimateur hérité en estime 93 637, soit 100 000 moins l'estimation du `LIKE`, comme si les `NULL` satisfaisaient `NOT LIKE` (2025 CU10).

## Lire le calculateur

Les noms de calculateur viennent du trace flag 2363, qui n'est pas documenté. Il écrit dans l'onglet des messages le détail du calcul de sélectivité de l'estimateur actuel, avec le trace flag 3604 :

```sql
USE [PachaDataFormation];
GO
SELECT Nom
FROM Contact.ProspectUS
WHERE Email LIKE '%.org'
OPTION (RECOMPILE, QUERYTRACEON 3604, QUERYTRACEON 2363);
```

```text
Plan for computation:
  CSelCalcTrieBased
      Column: QCOL: [PachaDataFormation].[Contact].[ProspectUS].Email
Selectivity: 0.0853097
```

> Note :
>
> [`QUERYTRACEON`](https://learn.microsoft.com/fr-fr/sql/t-sql/queries/hints-transact-sql-query) active un trace flag pour une requête, comme [`DBCC TRACEON`](https://learn.microsoft.com/fr-fr/sql/t-sql/database-console-commands/dbcc-traceon-transact-sql). Cela nécessite, comme `DBCC TRACEON`, le privilège sysadmin sur l'instance. Avec l'ancien estimateur de cardinalité, le moteur refuse ce trace flag (erreur 10781). L'évènement étendu `query_optimizer_estimate_cardinality` donne la même information, dans son champ `calculator` (`CalculatorName="CSelCalcTrieBased"`). La propriété `OptimizerStatsUsage` du plan cite la statistique utilisée sans dire si son résumé de chaîne a servi.


## Les limites du résumé

Le résumé de chaîne ne peut pas être utilisé dans les cas suivants :

- La colonne est utilisée dans une expression ou passée dans une fonction ;
- Le motif est dans une variable locale, seul ou concaténé à des jokers, sauf avec `OPTION (RECOMPILE)` ;
- Le motif est de type `nvarchar` alors que la colonne est en `varchar`, qu'il s'agisse d'un littéral `N'...'` ou d'un paramètre ;
- Le `LIKE` a une clause `ESCAPE`, même inutile ;
- La colonne est un `char` ou un `varchar` en collation UTF-8 : ses statistiques n'ont pas de résumé ;
- La colonne n'est la première colonne d'aucune statistique ;
- Le motif ne contient aucun joker : c'est alors une égalité, estimée par l'histogramme ;
- Un morceau du motif, avant, entre ou après les `%`, dépasse 40 caractères, `_` compris : le calculateur du résumé échoue, et la sortie du trace flag 2363 l'écrit (`Calculator failed. Replanning.`). Un préfixe retombe alors sur l'histogramme, un motif à joker initial sur l'estimation de 9 %. Sur un million de chaînes, `'%' + REPLICATE('A', 40) + '%'` est estimé au plancher, 35,4, et le même motif avec 41 `A` à 90 000 (mesuré en `varchar`, 2025 CU10) ;
- Le `LIKE` compare deux colonnes, comme dans une jointure `ON a.s LIKE b.motif` : l'estimateur actuel applique 9 % au produit des deux tables, sans dépasser la plus grande, et l'estimateur hérité rend le nombre de lignes de la plus grande. Un motif tiré d'une sous-requête reçoit 9 %, et la formule de la variable locale avec l'estimateur hérité (plus bas) (2025 CU10) ;
- La recherche passe par `REGEXP_LIKE`, nouveau dans SQL Server 2025 et disponible au niveau de compatibilité 170 : 9 % dans mes essais, et 30 % avec l'estimateur hérité (2025 CU10). La [documentation](https://learn.microsoft.com/fr-fr/sql/t-sql/functions/regexp-like-transact-sql) décrit deux indicateurs qui changent cette sélectivité par défaut, `ASSUME_FIXED_MIN_SELECTIVITY_FOR_REGEXP` et `ASSUME_FIXED_MAX_SELECTIVITY_FOR_REGEXP`, que le *CE feedback* peut appliquer de lui-même.

Le tableau suivant montre l'estimation de différents prédicats sur une table de test d'un million de chaînes hexadécimales aléatoires, où 1 000 chaînes commencent par `QA1`, 10 000 contiennent `QB2` et 100 000 se terminent par `QC3`. Toutes les écritures cherchent les 10 000 chaînes qui contiennent `QB2`, et toutes ont été mesurées avec la même statistique. Dans le tableau, CE 170 est l'estimateur actuel et CE 70 l'estimateur hérité.

| Écriture | Estimation, CE 170 | Estimation, CE 70 | Réel |
|---|---|---|---|
| `s LIKE '%QB2%'` | 9 936 | 9 936 | 10 000 |
| `s LIKE '%QB2%' ESCAPE '\'` (échappement inutile) | 90 000 | 204 072 | 10 000 |
| `LOWER(s) LIKE '%qb2%'` | 90 000 | 179 744 | 10 000 |
| `s LIKE @m`, variable locale | 90 000 | 51 018 | 10 000 |
| `s LIKE '%' + @m + '%'` | 90 000 | non mesuré | 10 000 |
| `s LIKE '%' + 'QB2' + '%'`, concaténation de littéraux | 9 936 | non mesuré | 10 000 |
| `s LIKE @m OPTION (RECOMPILE)` | estimation du résumé | non mesuré | 10 000 |
| `s LIKE @m` dans `sp_executesql` ou une procédure | estimation du résumé, pour la valeur de compilation | non mesuré | 10 000 |
| colonne `varchar` en collation UTF-8 | 90 000 | 204 072 | 10 000 |
| `s LIKE N'%QB2%'`, littéral ou paramètre `nvarchar` sur une colonne `varchar` | 90 000 | non mesuré | 10 000 |

Les conséquences pratiques :

- Pour chercher un caractère joker, l'échapper par crochets plutôt que par `ESCAPE` : `'%K[_]9%'` est estimé par le résumé (`CSelCalcTrieBased`), `'%K\_9%' ESCAPE '\'` est estimé à 9 % ; même un `ESCAPE` inutile, `'%QB2%' ESCAPE '\'`, passe de 9 936 à 90 000. Le livre blanc de 2005 indiquait déjà qu'un `ESCAPE` fait estimer la sélectivité sans le résumé, et c'est encore vrai sur SQL Server 2025, avec un motif littéral.
- Une fonction autour de la colonne (`LOWER`, `UPPER`, `RTRIM`) fait perdre le résumé. Sur une collation insensible à la casse, `LOWER` n'apporte rien au résultat et coûte l'estimation : 90 000 pour `'%qb2%'`, et 3 lignes pour `LOWER(s) LIKE 'qa1%'`, estimé par l'histogramme, contre 1 065 pour `s LIKE 'QA1%'` (1 000 réelles). Sur `Contact.ProspectUS`, `LOWER(Email) LIKE '%.org'` reçoit aussi l'estimation de 90 000.
- Une variable locale n'est pas lue à la compilation : l'estimation de 9 % s'applique, sauf avec `OPTION (RECOMPILE)`. Un paramètre l'est, pour sa première valeur seulement : une procédure compilée pour `'%QA1%'` (estimé 1 065) a gardé ce plan pour `'%QC3%'`, qui en ramène 100 000.
- Un motif `nvarchar` comparé à une colonne `varchar` fait aussi perdre le résumé : sur `Contact.ProspectUS`, `Email LIKE N'%.org'` reçoit l'estimation de 9 % (`CSelCalcFixedFilter (0.09)`), comme un paramètre `@m nvarchar(20)` passé par `sp_executesql`, alors qu'un paramètre `varchar(20)` donne l'estimation du résumé. Un préfixe `nvarchar` passe par l'histogramme, et s'en sort mal : `Email LIKE N'ab%'` est estimé à 430 lignes, contre 2 478 pour `'ab%'`, pour 2 669 réelles. SqlClient déduit `NVarChar` d'une `String` .NET quand le type du paramètre n'est pas précisé ([Configuring parameters](https://learn.microsoft.com/fr-fr/sql/connect/ado-net/configure-parameters)), et le pilote JDBC envoie les chaînes en Unicode tant que `sendStringParametersAsUnicode` vaut `true`, sa valeur par défaut ([propriétés de connexion](https://learn.microsoft.com/fr-fr/sql/connect/jdbc/setting-the-connection-properties)). Il faut donc, mais ce n'est pas nouveau, déclarer le paramètre dans le type de la colonne.
- Passer une colonne de `varchar` à une collation UTF-8 retire le résumé à ses statistiques. Les `LIKE` qui commencent par un joker sont estimés à 9 %, les préfixes passent par l'histogramme (`'QA1%'` : 2 lignes estimées pour 1 000), mais seulement en SQL Server 2025 au niveau de compatibilité 170. Erik Darling a relevé qu'il s'agit d'un correctif de l'optimiseur (dans un message à Erland Sommarskog, en novembre 2026) : au niveau 160, le préfixe est estimé à 9 %, sauf avec l'indicateur `ENABLE_QUERY_OPTIMIZER_HOTFIXES`, et SQL Server 2022 reste à 9 % même avec cet indicateur. Je l'ai vérifié sur 2025 CU11 et 2022 CU26 : sur un million de chaînes, `'AB%'` (3 934 lignes réelles) est estimé à 3 656 au niveau 170 ou avec l'indicateur, et à 90 000 sinon. Sur une copie du jeu de test en UTF-8, `'%QC3'` passait de 100 852 (pour 100 000) à 90 000, et `'%QB2%'` de 9 233 (pour 10 000, sur une autre construction de la statistique) à 90 000. Le correctif n'estime par l'histogramme seul que les préfixes purs : sur 100 000 chaînes en UTF-8, `'AB%'` est estimé à 489,5 lignes pour 408, alors que `'AB_%'`, `'AB%C%'` et même `'[A]B%'`, qui équivaut à `'AB%'`, reçoivent cet intervalle multiplié par 9 %, soit 44,1 (`CSelCalcFilterWithResidualGuess`, 2025 CU10).
- Une statistique sur plusieurs colonnes n'a de résumé que pour la première, comme son histogramme.
- Les espaces de fin sont stockés dans le résumé. Sur 100 000 lignes `char(20)` dont une sur 40 se termine par `qrs`, `'%qrs'` ramène bien ces 2 500 lignes, complétées d'espaces, mais le résumé n'en trouve aucune : estimation au plancher, 3,55. Un `varchar` qui contient une espace finale se comporte de la même façon. En `nchar`, le même motif ne ramène aucune ligne et reçoit le plancher, 4,17 lignes : `LIKE` et le résumé tiennent alors compte tous les deux des espaces de fin (2025 CU10). C'est la règle de [`LIKE`](https://learn.microsoft.com/fr-fr/sql/t-sql/language-elements/like-transact-sql) : les espaces de fin de l'expression comparée sont ignorés pour les données non Unicode, et significatifs pour `nchar` et `nvarchar`.

Ces estimations sans résumé diffèrent selon l'estimateur. L'estimateur actuel applique 9 % à tout `LIKE` à joker initial qu'il ne sait pas estimer (`CSelCalcFixedFilter (0.09)`), quelle que soit la longueur du motif. Un préfixe avec `ESCAPE` est estimé par l'histogramme (`'QA1%' ESCAPE '\'` : 2 lignes pour 1 000) ; sur une colonne en UTF-8, un préfixe sans `ESCAPE` ne l'est qu'aux conditions de version données plus haut.

L'estimateur hérité dépend de la longueur du motif : sur ce jeu d'un million de lignes, sans résumé, `'%Q%'` donne 612 216, `'%QB%'` 306 108, `'%QB2%'` 204 072, un motif de onze caractères 55 656. Erik Darling en a trouvé la formule (dans le même message), que j'ai vérifiée à la décimale sur SQL Server 2025 CU11 et 2022 CU26 : la sélectivité vaut 0,18 × ln(L) / n, où n est la longueur du motif sans les jokers et L une longueur de chaîne. Pour la colonne seule, L est la longueur moyenne donnée par la statistique, en octets, arrondie à l'entier inférieur : sur un million de chaînes de 20 caractères, `'%QZQZQZQZ%' ESCAPE '\'` est estimé à 67 404, soit 0,18 × ln(20) / 8, et à 92 122,8 sur des chaînes de 60 caractères, quelle que soit la longueur déclarée de la colonne. Les 61,2 % de `'%Q%'` correspondent ainsi à une longueur moyenne de 30 caractères, et les 41 % à 74 % mesurés sur d'autres jeux à des longueurs de 10 à 60. Un suffixe `'%QC3'` reçoit la moitié de l'estimation, 102 036.

Le facteur 0,18 vaut deux fois 0,09, parce que le motif contient deux `%`. La fonction qui fait ce calcul s'appelle `CCardUtilSQL7::ProbLikeGuess`. Au débogueur, elle reçoit le nombre de caractères comptés du motif, le nombre de `%` et la longueur moyenne de la colonne en octets (2025 CU10), et, quand le motif compte au moins un caractère et ne dépasse pas la longueur maximale de la colonne, la sélectivité vaut 0,09 × k × ln(L) / n, ramenée à 1 au plus, où k est le nombre de `%` (au moins 1) et où ln(L) est remplacé par 1 quand il est plus petit. Un motif plus long que la colonne reçoit 0, un motif sans caractère compté 1 ou 9 % selon qu'il contient un `%` ou non. Un suffixe n'a qu'un `%`, d'où la moitié. `'%Q%Z%'` en a trois : sur 100 000 chaînes de 20 caractères, il est estimé à 40 442, soit 0,27 × ln(20) / 2. n compte tous les caractères du motif sauf `%`, `_` et `[`, si bien que `'%Q[AB]Z%'` compte cinq caractères (`Q`, `A`, `B`, `]` et `Z`). En `nvarchar`, L se compte aussi en octets : 40 pour des chaînes de 20 caractères. Pour un motif dans une variable locale, que l'optimiseur ne connaît pas, la fonction reçoit n = 6 et k = 0, ce qui donne 0,09 × ln(L) / 6 : c'est la formule que [Paul White a donnée sur DBA Stack Exchange](https://dba.stackexchange.com/a/153618), et elle donne les 51 018 du tableau pour des chaînes de 30 caractères en moyenne.

Quand la colonne est dans une expression (`COLLATE`, `LEFT`, `LOWER`), L dépend aussi du niveau d'optimisation, comme Erik Darling l'a remarqué et comme le rapporte Erland Sommarskog ([String Summary Statistics and the Legacy Cardinality Estimator](https://www.sommarskog.se/Short%20Stories/stringstats.html#legacyestimator)). En optimisation complète, L est la moitié de la longueur déclarée de la colonne ; dans un plan trivial, c'est la longueur moyenne de la statistique. Sur ces chaînes de 20 caractères en `varchar(80)`, `s COLLATE Latin1_General_CI_AS LIKE '%QZQZQZQZ%'` est estimé à 82 999,8 en optimisation complète (0,18 × ln(40) / 8), et à 67 404 dans un plan trivial. En `varchar(160)`, l'optimisation complète donne 98 595,6 (0,18 × ln(80) / 8). Le niveau d'optimisation se lit dans la propriété `StatementOptmLevel` du plan. Avec `cost threshold for parallelism` à 5, toutes ces requêtes étaient optimisées complètement ; à 50, elles recevaient un plan trivial.

Les valeurs de la colonne CE 70 du tableau sont donc propres à ce jeu, alors que les 90 000 de l'estimateur actuel se retrouvent partout.

## Lire le résumé

Le résumé est stocké dans le blob de la statistique, avec l'histogramme. `DBCC SHOW_STATISTICS ... WITH STATS_STREAM` rend ce blob en entier, précédé d'un en-tête de 64 octets, et on le récupère en T-SQL par `INSERT ... EXEC` dans une colonne `varbinary(max)`. L'exemple de la petite table, plus bas, le fait.

Le format n'est pas documenté. J'ai utilisé Claude pour le déduire, et il l'a fait en construisant des tables de quelques lignes dont il connaissait chaque octet, en ne changeant qu'une chose d'une table à l'autre, puis en comparant les blobs.

Le résumé suit l'histogramme, après un marqueur fixe. Son en-tête donne :

- le nombre de NULL rencontrés par l'échantillonnage ;
- le nombre de valeurs échantillonnées, NULL compris ;
- le nombre de valeurs distinctes de l'échantillon, où NULL compte pour une ;
- deux fois 40, les longueurs de la troncature ;
- huit octets nuls ;
- le nombre de caractères qui suivent.

Viennent ensuite les caractères de l'échantillon, mis bout à bout, puis les nœuds du trie.

Le plus simple est de le voir sur une petite table. Celle-ci compte huit noms, dont `Martin` deux fois ; sous onze lignes, l'échantillon les garde toutes :

Détail de la mesure :

```sql
USE [PachaDataFormation];
GO
CREATE TABLE dbo.DemoTrie (Nom varchar(50) COLLATE French_CI_AS);
INSERT dbo.DemoTrie (Nom)
VALUES ('Martin'), ('Martinez'), ('Marty'), ('Martin'),
       ('Dupont'), ('Durand'), ('Dubois'), ('Dupuis');
CREATE STATISTICS st_Nom ON dbo.DemoTrie (Nom) WITH FULLSCAN;
GO
-- Le blob de la statistique, en hexadécimal
DECLARE @flux TABLE (stats_stream varbinary(max), [rows] bigint, data_pages bigint);
INSERT @flux EXEC ('DBCC SHOW_STATISTICS (''dbo.DemoTrie'', st_Nom) WITH STATS_STREAM');
SELECT CONVERT(varchar(max), stats_stream, 2) AS blob FROM @flux;
GO
DROP TABLE dbo.DemoTrie;
```


L'en-tête du résumé annonce 0 NULL, 8 valeurs échantillonnées, 7 distinctes, puis 26 caractères, qui sont les morceaux de tous les nœuds mis bout à bout : `DuboispontuisrandMartinezy`. Suivent onze nœuds de cinq octets, en ordre préfixe :

| Nœud | Octets | Drapeaux | Morceau | Position | Compteur | Chaîne |
|---|---|---|---|---|---|---|
| 0 | `40 00 00 00 00` | a des enfants | (vide) | 0 | 0 | racine |
| 1 | `c0 02 00 00 00` | frère suivant, a des enfants | `Du` | 0 | 0 | `Du` |
| 2 | `81 04 02 00 00` | frère suivant | `bois` | 2 | 1 | `Dubois` |
| 3 | `c0 01 06 00 00` | frère suivant, a des enfants | `p` | 6 | 0 | `Dup` |
| 4 | `81 03 07 00 00` | frère suivant | `ont` | 7 | 1 | `Dupont` |
| 5 | `01 03 0a 00 00` | dernier enfant | `uis` | 10 | 1 | `Dupuis` |
| 6 | `01 04 0d 00 00` | dernier enfant | `rand` | 13 | 1 | `Durand` |
| 7 | `40 04 11 00 00` | a des enfants | `Mart` | 17 | 0 | `Mart` |
| 8 | `c2 02 15 00 00` | frère suivant, a des enfants | `in` | 21 | 2 | `Martin` |
| 9 | `01 02 17 00 00` | dernier enfant | `ez` | 23 | 1 | `Martinez` |
| 10 | `01 01 19 00 00` | dernier enfant | `y` | 25 | 1 | `Marty` |

Le premier octet contient les drapeaux : `0x80` quand le nœud a un frère après lui, `0x40` quand le nœud suivant est son premier enfant. Ses quatre bits bas stockent le compteur quand il ne dépasse pas 15 : 2 pour `Martin`, 1 pour les autres chaînes, 0 pour les nœuds où aucune chaîne ne se termine, comme `Du` ou `Mart`. Un compteur plus grand ajoute après le nœud un octet, signalé par le drapeau `0x10`, ou quatre, signalés par `0x20` (249 est le plus grand compteur sur un octet que j'aie vu, 295 le plus petit sur quatre). Le deuxième octet donne la longueur du morceau, les trois suivants sa position dans la suite de caractères. La chaîne d'un nœud est la suite des morceaux de ses ancêtres, puis le sien : on lit `Du`, puis `p`, puis `ont`, et on obtient `Dupont`.

```mermaid
flowchart TD
    R(("racine")) --> DU["Du · 0"]
    R --> MART["Mart · 0"]
    DU --> BOIS["bois · 1 : Dubois"]
    DU --> P["p · 0"]
    DU --> RAND["rand · 1 : Durand"]
    P --> ONT["ont · 1 : Dupont"]
    P --> UIS["uis · 1 : Dupuis"]
    MART --> IN["in · 2 : Martin"]
    MART --> Y["y · 1 : Marty"]
    IN --> EZ["ez · 1 : Martinez"]
```

Le résumé ne stocke aucune sous-chaîne : ce sont les chaînes entières, en `varchar` dans le code page de la colonne, en `nvarchar` en UTF-16. En collation insensible à la casse, `MiXeD`, `mixed` et `Mixed` font une seule entrée, de compteur 3.

Il n'y a donc qu'un trie par statistique, et il reste petit : au plus 2 800 chaînes environ, de 80 caractères au plus, soit quelque 224 Ko avant le partage des débuts communs, et le résumé pèse autour de 200 Ko (194 Ko en `varchar`, 212 Ko en `nvarchar` dans mes essais) quand SQL Server coupe l'échantillon en deux, à cause d'une limite de place en mémoire pendant la construction (voir « L'échantillon »). Le trie ne sert pas non plus de moteur de recherche. Pour `LIKE '%.org'`, l'estimation vaut exactement le nombre de chaînes de l'échantillon qui satisfont le motif. D'après les fonctions que montrent les piles d'appels, l'optimiseur parcourt l'arbre en appliquant le motif, morceau par morceau, à chaque chemin de la racine vers les feuilles ; la section « Le temps de compilation » montre le coût de ce parcours. Un trie n'accélère d'ailleurs que la recherche par le début d'une chaîne, ce qui ne sert à rien pour un motif qui commence par `%`. Il sert surtout à stocker l'échantillon de façon compacte et à compter les doublons.

Le script [`string-summary.sql`](https://github.com/rudi-bruchez/tsql-scripts/blob/main/database-information/statistics/string-summary.sql) décode le résumé d'une statistique, liste les chaînes échantillonnées et calcule l'estimation que le résumé donne pour un motif, à condition que le prédicat l'utilise (motif du même type que la colonne, sans fonction autour de la colonne). Lancé tel quel, sur la statistique de `Contact.ProspectUS.Email`, il trouve 2 825 valeurs échantillonnées, dont 29 NULL, et 241 chaînes qui satisfont `'%.org'` : 1 000 000 × 241 / 2 825 = 85 309,7, l'estimation du plan.

## L'échantillon

Une table de 10 000 lignes de valeurs `0000001` à `0010000` donne un résumé de 510 chaînes, espacées de 19 ou 20 valeurs dans l'ordre de tri. Les mêmes valeurs insérées dans l'ordre inverse, ou dans un ordre aléatoire, donnent les mêmes 510 chaînes : l'échantillon est pris à pas fixe dans le flux trié de la construction, quel que soit l'ordre physique des lignes. Une valeur présente dans 30 % des lignes occupe 153 places sur 510, soit 30 %.

Sa taille vaut 5 % des lignes lues par la statistique plus 10, sans dépasser le nombre de lignes (une table de quatre lignes les garde toutes) : 510 chaînes pour 10 000 lignes, 1 010 pour 20 000, 2 510 pour 50 000. Avec un échantillonnage, ce sont 5 % des lignes échantillonnées : sur une table de 40 000 lignes larges, `SAMPLE 2 PERCENT` lit 984 lignes, et le résumé garde 59 chaînes, contre 2 018 en `FULLSCAN`. Une statistique filtrée applique le taux d'échantillonnage de la table entière aux lignes qui passent son filtre, dans mon essai : sur 100 000 lignes, une statistique `WHERE id <= 20000` en `FULLSCAN` garde 565 chaînes, soit 2 824 × 20 %, et non les 1 010 que donneraient 5 % des 20 000 lignes plus 10 (2025 CU10).

La taille plafonne ensuite vers 2 820 : le plafond est atteint vers 56 000 lignes, et il tient jusqu'à 3 000 000, la plus grande table mesurée (2 814 à 2 830 selon les données et le parallélisme).

Le plafond est aussi une limite de place, et pas seulement un nombre de chaînes : quand l'échantillon ne tient pas dans le résumé, SQL Server en garde une chaîne sur deux. Sur 200 000 chaînes distinctes et dissemblables, avec `MAXDOP = 1`, l'échantillon garde 2 824 chaînes de 65 caractères, et tombe d'un coup à 1 412 chaînes de 66 caractères ; juste avant la coupe, à 65 caractères, la statistique stockée pesait 211 Ko et son résumé 193 Ko. C'est la place occupée dans le trie qui compte, et non la longueur : des chaînes de 200 caractères qui partagent leur début gardent les 2 824.

La limite se lit dans le code de construction (2025 CU10) : un nouveau nœud est refusé quand un compteur, qui cumule les caractères stockés et 48 octets par nœud, atteint 327 680 octets (320 Kio), et la construction repart avec un taux d'échantillonnage divisé par deux.

Détail de la mesure :

Une coupure crée aussi un nœud : quand une chaîne partage le début d'un nœud existant, ce nœud est coupé en deux. Avec des chaînes de 66 caractères, le compteur valait 327 663 octets au refus : 179 983 caractères (les chaînes sont stockées sans le début qu'elles partagent), 2 806 nœuds de chaînes et la racine, et 271 nœuds créés par des coupures, à 48 octets chacun, moins 64 octets. Les quelque 194 Ko du résumé sont la forme compacte du même trie : cinq octets par nœud tant que son compteur ne dépasse pas 15, au lieu de 48 en mémoire.


En `nvarchar`, le plafond de départ est plus bas, 2 409 chaînes, et il passe à 1 205 entre 43 et 44 caractères (86 et 88 octets), pour un résumé d'environ 212 Ko contre 194 Ko en `varchar` au même moment. Ce plafond de départ ne dépend que de la largeur des caractères : 2 824 en `char`, `varchar` et `varchar(max)`, 2 409 en `nchar`, `nvarchar` et `nvarchar(max)`, quelle que soit la longueur déclarée de la colonne, sa collation (`BIN2`, collation SQL, japonaise ou UTF-8) ou la longueur des chaînes sous le seuil. Ces deux plafonds sont des constantes du code de SQL Server 2025 : 2 409 pour les caractères sur deux octets, et 2 409 + 415 = 2 824 pour les caractères sur un octet.

La taille visée est la plus petite de trois valeurs : le plafond, 5 % des lignes lues plus 10, et le nombre de lignes lues. Elle sert à calculer un taux d'acceptation, et le compte final peut la dépasser de quelques chaînes : 2 825 sur `Contact.ProspectUS`, jusqu'à 2 830 en parallèle. J'y vois un effet d'arrondi du tirage, sans l'avoir vérifié dans le code. L'échantillon des e-mails de la base de démonstration en compte 2 410 en `nvarchar`, contre 2 825 en `varchar`.

L'estimation d'un `LIKE` à joker se calcule alors exactement : le nombre de lignes de la table, multiplié par le nombre de chaînes de l'échantillon qui satisfont le motif, divisé par la taille de l'échantillon. Sans aucune chaîne qui le satisfait, le compte vaut 0,1. Sur dix motifs (`'%x%'`, `'x%'`, `'%x'`, `_`, `[bc]`, deux `%` internes), le calcul fait sur l'échantillon décodé a donné l'estimation du plan à la décimale. Une égalité sans joker passe par l'histogramme.

Les estimations avancent donc par paliers d'une chaîne échantillonnée, 354 lignes sur le million de prospects (1 000 000 / 2 825), avec un plancher de 35,4 :

```sql
USE [PachaDataFormation];
GO
-- Estimation contre nombre réel, pour des noms de fréquences différentes
SELECT Nom FROM Contact.ProspectUS WHERE Nom LIKE '%Aguila';
SELECT Nom FROM Contact.ProspectUS WHERE Nom LIKE '%Baldwin';
SELECT Nom FROM Contact.ProspectUS WHERE Nom LIKE '%Wilson';
```

| Motif | Réel | Estimation | Chaînes échantillonnées |
|---|---|---|---|
| `'%Abajian'` | 1 | 35,4 | 0 (plancher) |
| `'%Aguila'` | 38 | 35,4 | 0 (plancher) |
| `'%Baldwin'` | 150 | 354 | 1 |
| `'%Castro'` | 391 | 708 | 2 |
| `'%Campbell'` | 421 | 708 | 2 |
| `'%Wilson'` | 712 | 708 | 2 |
| `'%Johnson'` | 1 105 | 1 062 | 3 |

Le même plancher se lit sur des tables de tailles différentes :

| Lignes de la table | Plus petite estimation | Lignes / plus petite estimation |
|---|---|---|
| 10 000 | 1,96 | 5 100 |
| 30 000 | 1,99 | 15 100 |
| 100 000 | 3,55 | 28 140 |
| 1 000 000 | 35,51 | 28 160 |
| 3 000 000 | 106,50 | 28 170 |

Le rapport vaut dix fois la taille de l'échantillon : 5 100 pour 510 chaînes, 15 100 pour 1 510, 28 140 pour 2 814. Sur la table de trois millions de lignes, une sous-chaîne présente 1, 10 ou 100 fois est estimée à 106,5, comme une sous-chaîne absente ; à 999 occurrences, elle est estimée à 1 065, une chaîne de l'échantillon ; à 10 000, à 11 719, onze chaînes d'un échantillon de 2 816, construit une autre fois. Pour des chaînes de 200 caractères toutes différentes, l'échantillon tombe à environ 1 410 chaînes en `varchar` (1 200 en `nvarchar`), et le plancher à environ le nombre de lignes divisé par 14 000.

Un échantillon aussi petit estime pourtant bien les motifs fréquents, parce que sa précision dépend du nombre de chaînes qui satisfont le motif, et non de la fraction de la table qu'il représente. C'est le principe du sondage : un millier de personnes interrogées donne la même marge d'erreur sur une petite ville que sur un grand pays. Pour une proportion p mesurée sur n chaînes, l'erreur relative typique vaut environ √((1 − p) / (n × p)). Avec `'%.org'`, 241 chaînes de l'échantillon satisfont le motif, et l'erreur attendue est d'environ 6 % : l'estimation de 85 310 pour 85 060 lignes réelles est donc en partie de la chance, un écart de 10 % aurait été aussi normal.

Le pas fixe dans l'ordre de tri favorise en plus les préfixes. Les lignes qui satisfont `'Mc%'` forment un bloc contigu dans cet ordre, et un pas de 354 lignes y tombe toujours 49 ou 50 fois : l'erreur ne dépasse pas une chaîne échantillonnée, soit 354 lignes, et on obtient 17 699 lignes estimées pour 17 620. Un suffixe ou une sous-chaîne, dispersés dans l'ordre de tri, n'ont pas cet avantage, et l'échantillon se comporte pour eux à peu près comme un tirage au hasard.

Pour un motif rare, la précision est celle d'un échantillon de quelques dizaines de chaînes. Une sous-chaîne présente dans 1 % d'un million de lignes, soit 28 chaînes attendues dans l'échantillon, y en avait 27, 32, 28 puis 27 sur quatre `UPDATE STATISTICS ... WITH FULLSCAN` successifs, sans changement de données : estimations de 9 585, 11 356, 9 947 et 9 581 pour 10 000. En parallèle, la taille de l'échantillon variait aussi, de 2 815 à 2 818 chaînes. Avec `MAXDOP = 1`, les reconstructions donnent toutes le même échantillon, de 2 824 chaînes, qui contenait ici 22 fois la sous-chaîne : 7 790 lignes estimées. Le parallélisme change l'échantillon : d'après le débogueur, chaque thread de la construction prélève son propre échantillon, au taux calculé pour la table entière, et construit son propre trie, puis un cinquième trie, qui ne reçoit que le taux, réunit vraisemblablement ceux des threads. Sur un million de lignes en `MAXDOP 4`, le débogueur montre ces quatre threads et ce cinquième trie, et le résumé compte 2 822 chaînes au lieu de 2 824. Chaque thread arrondit son propre pas, et la répartition des lignes entre les threads change d'une construction à l'autre, d'où des échantillons différents (c'est mon interprétation des comptes : le débogueur ne m'a pas montré la répartition). Sur trois reconstructions d'une autre table, le même effet avait donné 5 329, 10 653 et 6 392 pour 10 000.

La documentation de SQL Server 2005 ([Index Statistics](https://learn.microsoft.com/en-us/previous-versions/sql/sql-server-2005/ms190397(v=sql.90))) prévenait que le résumé n'est pas conservé quand il dépasse ce que le moteur peut maintenir, avec l'exemple de 85 000 valeurs `varchar(80)` uniques et dissemblables, en `FULLSCAN`. L'exemple ne se reproduit plus : avec 85 000 valeurs uniques de 80 caractères, `String Index` vaut `YES`, et l'échantillon est réduit à 1 413 chaînes.

## Au-delà de 80 caractères

La règle des livres blancs tient toujours. Table de 100 000 chaînes de 200 caractères, une sous-chaîne de trois caractères placée en position 5, 60, 100 ou 190, un quart des lignes chacun :

| Position de la sous-chaîne | `varchar` | `nvarchar` | Réel |
|---|---|---|---|
| 5 | 24 645 | 24 083 | 25 000 |
| 60 | 7 | 8 | 25 000 |
| 100 | 7 | 8 | 25 000 |
| 190 | 24 503 | 26 000 | 25 000 |

Les positions 60 et 100 tombent hors des 40 premiers et des 40 derniers caractères : l'échantillon ne les contient pas, et elles reçoivent le plancher. Avec des chaînes de 79 à 82 caractères et une sous-chaîne à cheval sur le 40e et le 41e caractère, l'estimation est juste à 79 et 80 caractères (25 710 et 25 994), et tombe à 1 634 puis 1 136 à 81 et 82, en `varchar` Latin1 comme en `nvarchar` ; ces deux valeurs viennent d'occurrences fortuites ailleurs dans mes chaînes hexadécimales, et une sous-chaîne qui n'apparaît nulle part ailleurs tombe au plancher.

Le résumé stocke les 40 premiers et les 40 derniers caractères mis bout à bout, et un motif peut donc correspondre à la jonction. Sur 100 000 chaînes de 200 caractères avec un `Q` en position 40 et un `W` en position 161, `'%QW%'`, qui ne figure dans aucune ligne, est estimé à 100 000 ; `'%Qm%'` et `'%mW%'`, présents dans toutes les lignes, sont estimés à 3,5.

En `varchar`, le seuil se compte en octets. Sur une colonne `varchar` en `Japanese_CI_AS` dont les dix premiers caractères occupent deux octets chacun, une sous-chaîne placée aux caractères 39 à 41 reste visible dans une chaîne de 76 caractères (86 octets), et disparaît dans une chaîne de 79 caractères (89 octets) : 3,6 lignes estimées pour 25 000. La même valeur en `nvarchar` reste estimée à 24 230.

En `nvarchar`, le seuil se compte en unités UTF-16 de deux octets. Un caractère hors du plan multilingue de base, stocké comme une paire de substitution, compte pour deux. Sur 500 000 chaînes en `Czech_100_CI_AS_SC` faites de lettres gothiques, d'un GUID puis de lettres gothiques, `'%123%'` est estimé à 2 502 pour 2 464 lignes quand le préfixe gothique fait 30 unités (15 caractères), et tombe au plancher, 20,6 pour 2 448, à 40 unités, soit 20 caractères seulement. Pour des lettres du plan de base, comme l'alphabet latin, le grec ou le japonais, une unité vaut un caractère.

Sur des colonnes `varchar(max)` de 100 à 20 000 caractères, un préfixe et un suffixe sont bien estimés, avec l'imprécision d'un échantillon d'environ 1 400 chaînes ; tout ce qui se trouve entre les deux est invisible. Pour une colonne de commentaires ou de descriptions, un `LIKE '%mot%'` dont les occurrences ne se trouvent qu'au milieu des textes peut donc recevoir l'estimation d'un motif absent, comme dans ces essais. Pour chercher des mots dans un long texte, la recherche en texte intégral (`CONTAINS`) est l'outil prévu ; elle trouve des mots et des préfixes de mots, et un fragment pris au milieu d'un mot lui échappe.

## Le temps de compilation

Le parcours du résumé a un coût, en général invisible : sur un million de chaînes hexadécimales, un motif de un à dix morceaux séparés par `%` se compile en quelques millisecondes. Ce coût change d'échelle quand la colonne répète un caractère et que le motif contient plusieurs `%` suivis de ce caractère. Des références de commande complétées de zéros suffisent :

Détail de la mesure :

```sql
USE PachaDataFormation;
GO
SET NOCOUNT ON;
CREATE TABLE dbo.DemoCommande (
    CommandeId int NOT NULL PRIMARY KEY,
    Reference varchar(30) NOT NULL
);
-- 200 000 références complétées de zéros : CMD00000000000000000001, ...
INSERT dbo.DemoCommande (CommandeId, Reference)
SELECT n, 'CMD' + RIGHT(REPLICATE('0', 20) + CAST(n AS varchar(20)), 20)
FROM (SELECT TOP (200000) ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS n
      FROM sys.all_columns AS a CROSS JOIN sys.all_columns AS b) AS t;
CREATE STATISTICS st_Reference ON dbo.DemoCommande (Reference) WITH FULLSCAN;
GO
-- Le temps de compilation s'affiche dans l'onglet des messages
SET STATISTICS TIME ON;
GO
SELECT COUNT(*) FROM dbo.DemoCommande WHERE Reference LIKE '%0%0%9%' OPTION (RECOMPILE);
GO
SELECT COUNT(*) FROM dbo.DemoCommande WHERE Reference LIKE '%0%0%0%0%0%9%' OPTION (RECOMPILE);
GO
SELECT COUNT(*) FROM dbo.DemoCommande WHERE Reference LIKE '%0%0%0%0%0%0%0%0%9%' OPTION (RECOMPILE);
GO
SET STATISTICS TIME OFF;
GO
DROP TABLE dbo.DemoCommande;
```


Les trois requêtes ramènent les mêmes 81 902 lignes. Sur SQL Server 2025 CU10, base au niveau de compatibilité 160 en collation `French_CI_AS`, trois exécutions du script (dans une base en `SQL_Latin1_General_CP1_CI_AS` au niveau 170, la compilation prend 1,3 à 1,6 s et 5,8 à 6,8 s pour les deux derniers motifs, et l'exécution 30 à 50 ms) :

| Motif | Compilation (CPU) | Exécution (CPU) |
|---|---|---|
| `'%0%0%9%'` | 60 à 63 ms | 210 à 224 ms |
| `'%0%0%0%0%0%9%'` | 2,35 à 2,53 s | 221 à 243 ms |
| `'%0%0%0%0%0%0%0%0%9%'` | 10,9 à 11,1 s | 239 à 260 ms |

Tout ce temps est passé dans l'estimation de la cardinalité, avant de lire la moindre ligne. Les piles d'appels prises pendant la compilation montrent, sous `CTrieInMemCore::FFilterLike`, deux fonctions du parcours du résumé qui s'appellent l'une l'autre, `ConsumeChildren` et `ConsumeNodeString`. Je l'interprète comme un retour arrière : chaque `%` peut absorber un nombre quelconque de caractères, et quand la suite du motif échoue, le parcours revient au `%` précédent pour essayer une autre position. Dans une référence qui compte jusqu'à dix-neuf zéros, il y a beaucoup de façons de placer cinq `0`, et le parcours les essaie avant de conclure qu'aucun `9` ne suit. Sur une table de test de 50 000 chaînes faites de 30 à 79 `A` suivis d'un numéro, `'%A%A%B%'` se compile en 0,7 s, `'%A%A%A%B%'` en 14 s, et avec un `%A` de plus la compilation dépasse deux minutes.

Le comportement est ancien : la même table, créée dans une base neuve au niveau de compatibilité par défaut de chaque version, compile `'%0%0%0%0%0%9%'` en 1,7 à 2,3 s sur SQL Server 2017 CU31, 2019 CU32, 2022 CU27 et 2025 CU10 (1,9 s au niveau 170 pour ce dernier).

SQL Server 2025 contient une borne, active par défaut, mais que l'optimiseur n'applique qu'au niveau de compatibilité 170 ou avec l'indicateur `ENABLE_QUERY_OPTIMIZER_HOTFIXES`. Elle arrête le parcours après 11 milliards d'appels, ce qui laisse passer des compilations de plusieurs secondes : mes mesures au niveau 170 ont été faites avec la borne active.

Le parcours vérifie en revanche régulièrement si la requête doit s'arrêter : un `KILL` l'a interrompu aussitôt dans mes essais. Je n'ai pas contrôlé séparément l'arrêt du travail sur le serveur après un délai d'expiration du client.

Un paramètre de procédure est estimé par le résumé pour sa valeur de compilation, et paie donc ce coût à chaque compilation : 6,5 s pour huit `%0` sur un jeu de même forme, au niveau 170. Une variable locale sans `OPTION (RECOMPILE)`, ou `OPTION (OPTIMIZE FOR UNKNOWN)`, l'évitent, au prix de l'estimation de 9 %. Le cas réaliste est une application qui construit un motif à plusieurs `%` à partir d'une saisie, sur une colonne de codes.

Le problème est connu hors de SQL Server. Russ Cox l'a mesuré en 2017 sur les jokers des shells, dans [Glob Matching Can Be Simple And Fast Too](https://research.swtch.com/glob) : avec un retour arrière, le motif `a*a*a*b` appliqué à une suite de `a` prend un temps exponentiel en nombre de `*`. En ne reprenant la recherche qu'au dernier `*` rencontré, il n'y a plus de retour arrière sur les `*` précédents, et le coût, d'après le code qu'il publie, est au plus proportionnel à la longueur du motif multipliée par celle de la chaîne. Le cas des chaînes de `A` a la même forme.

## Ce qu'il faut retenir

- Un `LIKE` qui compare la colonne, sans fonction autour, à un littéral est souvent mieux estimé qu'on ne le croit, y compris `'%abc%'`. L'écrire tel quel plutôt qu'avec `LEFT`, `RIGHT`, `CHARINDEX` ou `LOWER`.
- Échapper un joker par crochets, pas par `ESCAPE`.
- Un motif dans une variable locale reçoit une estimation fixe ; `OPTION (RECOMPILE)` rend l'estimation au résumé, un paramètre du type de la colonne la donne pour sa valeur de compilation.
- Un `varchar` en collation UTF-8 n'a pas de résumé de chaîne ; un `nvarchar` dans la même collation en a un.
- Passer le motif dans le type de la colonne : un littéral ou un paramètre `nvarchar` face à une colonne `varchar` perd le résumé (9 % pour un motif qui commence par un joker, l'histogramme pour un préfixe).
- Le résumé est un échantillon de 5 % des lignes lues plus 10, plafonné vers 2 800 chaînes dès 56 000 lignes environ (2 400 en `nvarchar`, moitié moins pour des chaînes longues et dissemblables). Un motif présent dans moins d'une ligne sur 2 800 environ peut être estimé comme absent, et un motif rare l'est avec l'imprécision d'un petit échantillon.
- D'une longue chaîne, le résumé ne garde que les 40 premiers et les 40 derniers caractères (octets en `varchar`, unités UTF-16 en `nvarchar`), mis bout à bout.
- Le résumé applique la casse et les accents de la collation, mais pas les équivalences d'un caractère à deux (`ß` et `ss`), et il compare des octets dans une colonne `varchar` en `Japanese_CI_AS`, la seule page de code à caractères doubles que j'aie mesurée.
- Sur une colonne qui répète un caractère, comme des codes complétés de zéros, un motif à plusieurs `%` peut coûter des secondes de compilation, avant toute exécution.

## Améliorations possibles

Maintenant que le format est lisible, on peut se demander comment il pourrait évoluer. Les pistes suivantes sont un avis de lecteur, sans mesure du coût de chaque changement : Microsoft a des contraintes que l'on ne voit pas d'ici, comme le temps de compilation, la taille du blob ou la compatibilité du format entre versions.

Quatre cas perdent le résumé ou le trompent, alors que la correction semble à portée de main. Sur une table de 100 000 lignes dont 2 000 se terminent par `.org`, le motif `varchar` est estimé à 1 954 lignes, et chacun des trois premiers cas à 9 000 :

- un motif `nvarchar` face à une colonne `varchar`, littéral `N'...'` ou paramètre, perd le résumé, et un motif qui commence par un joker reçoit l'estimation de 9 %. Le convertir dans le type de la colonne, quand la conversion ne perd rien, suffirait. Les pilotes .NET envoient les chaînes en `nvarchar` par défaut, ce qui rend ce cas courant ;
- `ESCAPE` fait aussi perdre le résumé, alors que l'estimation consiste déjà à appliquer un `LIKE` aux chaînes de l'échantillon ;
- `LOWER(colonne)` ne change rien au résultat sur une collation insensible à la casse, et pourrait être ignoré pour l'estimation ;
- la troncature à 40 + 40 caractères met bout à bout le début et la fin de la chaîne. Sur des chaînes de 100 caractères où un `Q` finit les 40 premiers et un `W` commence les 40 derniers, `'%QW%'`, qui ne correspond à aucune ligne, est estimé à 100 000. Un marqueur de jonction, que le motif ne pourrait pas traverser, éviterait ces fausses correspondances. L'effet inverse, une sous-chaîne prise dans la partie supprimée et estimée au plancher, est le prix de la troncature elle-même.

D'autres pistes touchent le fond du mécanisme, et leur intérêt dépend des données :

- le trie compte déjà les doublons, mais seulement dans l'échantillon. Pour une colonne de quelques valeurs distinctes sur un million de lignes, les valeurs et leur nombre exact de lignes tiendraient en quelques octets, et l'estimation deviendrait exacte ;
- tous les motifs absents de l'échantillon reçoivent le même plancher, un dixième de chaîne, alors qu'un motif de deux caractères absent est bien plus probable qu'un motif de douze. La littérature sur l'estimation des sous-chaînes, comme les arbres des suffixes élagués ([Krishnan, Vitter et Iyer, 1996](https://doi.org/10.1145/233269.233341)) ou les travaux de [Chaudhuri, Ganti et Gravano (2004)](https://doi.org/10.1109/ICDE.2004.1319999) sur la sous-estimation, propose de décomposer le motif absent en morceaux présents ;
- la taille de l'échantillon ne suit pas celle de la table : sur cent millions de lignes, si le plafond tient, le calcul donne un plancher de 3 500 lignes. Un échantillon qui grandirait un peu avec la table, dans la limite de place, réduirait ce saut ;
- le parcours du résumé revient en arrière sur chaque `%`, et son coût explose sur des données répétitives (voir « Le temps de compilation »). La méthode que Russ Cox décrit pour les jokers des shells, ne reprendre qu'au dernier `*` rencontré, est une piste pour éviter les reprises sur les `%` précédents. Il resterait à l'adapter au parcours d'un trie, au comptage des correspondances et aux règles de collation, ce qui vaudrait mieux que la borne de 11 milliards d'appels de SQL Server 2025 ;
- comparer des caractères plutôt que des octets dans les pages de code à caractères doubles, et appliquer les équivalences de la collation, supprimerait les fausses estimations de `'%A%'` en japonais ou de `'%ß%'` ;
- en parallèle, deux `UPDATE STATISTICS ... WITH FULLSCAN` successifs, sans changement des données, donnent des échantillons différents, donc des estimations différentes. Un prélèvement au même pas, quel que soit le découpage entre threads, rendrait les plans reproductibles.

Reste l'absence de résumé pour les `varchar` en collation UTF-8. [Erland Sommarskog](https://www.sommarskog.se/Short%20Stories/stringstats.html) avance une explication : la troncature se compte en octets, et en UTF-8 une lettre grecque ou cyrillique occupe deux octets, un idéogramme chinois ou japonais trois. Les 40 octets de début ne garderaient alors que 20 lettres grecques ou 13 idéogrammes. C'est une hypothèse, que je n'ai pas mesurée : la même réduction existe déjà pour un `varchar` en collation japonaise, qui garde pourtant son résumé.

Le compromis actuel se défend malgré tout : un échantillon de 2 800 chaînes dans un trie compressé tient dans 200 Ko environ, s'applique vite à la compilation, sauf sur des données répétitives (voir « Le temps de compilation »), estime bien les motifs fréquents, et ses erreurs sur les motifs rares changent rarement le plan.


---

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