0Pricing
PostgreSQL Performance & Query Optimization · Leçon

Corrections MCV et N-Distinct

Utilisez les statistiques ndistinct et de valeurs les plus fréquentes pour corriger les estimations des jointures et des regroupements.

Corrections MCV et N-Distinct est une leçon PostgreSQL Performance & Query Optimization gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PostgreSQL Performance & Query Optimization, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PostgreSQL Performance & Query Optimization comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Why Estimates Drift

The PostgreSQL planner chooses join orders, join methods, and grouping strategies from row-count estimates. When those estimates are wrong, you get nested loops over millions of rows or a hash table sized for the wrong cardinality.

Two column-level statistics drive most of these estimates:

  • n_distinct — how many distinct values the planner believes a column holds. It feeds grouping and join cardinality.
  • most_common_vals (MCV) — the list of frequent values and their frequencies, used for selectivity of equality predicates.

This lesson shows how to read, diagnose, and correct both when the default sampling gets them wrong.

Reading pg_stats

Everything the planner knows about a column lives in the pg_stats view, a human-readable wrapper over pg_statistic. Start every diagnosis here.

Key columns: n_distinct, most_common_vals, most_common_freqs, and null_frac.

SELECT attname,
       n_distinct,
       null_frac,
       most_common_vals,
       most_common_freqs
FROM pg_stats
WHERE schemaname = 'public'
  AND tablename = 'orders'
  AND attname IN ('customer_id', 'status');

How n_distinct Is Encoded

The n_distinct value is overloaded with two meanings:

  • A positive number is an absolute count of distinct values (e.g. 4200).
  • A negative number between -1 and 0 is a ratio of distinct values to total rows. -1 means every row is unique; -0.5 means distinct count is half the row count.

Negative form is chosen by ANALYZE when the distinct count appears to grow with the table, so it scales as the table grows. This distinction matters when you override it manually.

The Sampling Problem

ANALYZE estimates n_distinct from a random sample (default ~300 × default_statistics_target rows), not a full scan. Estimating the number of distinct values from a sample is notoriously hard.

The classic failure: a high-cardinality column where distinct values are spread thinly. The sample sees few repeats, so the estimator under-counts badly. A column with 5 million real distinct values might be recorded as 50,000.

The planner then thinks a GROUP BY produces 50,000 groups, picks a hash aggregate sized for that, and spills to disk when reality hits 5 million.

Spotting a Bad n_distinct

Compare what the planner believes against ground truth. Run an exact distinct count and hold it next to pg_stats:

If n_distinct is stored as a small positive number but the real count is orders of magnitude larger, you have an underestimate. Remember to convert the negative ratio form: real estimate = -n_distinct × reltuples.

-- ground truth
SELECT count(DISTINCT customer_id) AS real_distinct
FROM orders;

-- what the planner thinks
SELECT n_distinct
FROM pg_stats
WHERE tablename = 'orders' AND attname = 'customer_id';

Overriding n_distinct

When you know the true cardinality better than the sampler ever will, pin it with ALTER TABLE ... ALTER COLUMN ... SET (n_distinct = ...).

Use the negative ratio form for columns that scale with table size — it survives growth. Use a positive integer only for a stable, bounded domain.

The override is stored in pg_attribute and applied on the next ANALYZE, so always re-analyze afterward.

-- distinct count grows ~linearly with rows: use the ratio form
ALTER TABLE orders
  ALTER COLUMN customer_id SET (n_distinct = -0.8);

ANALYZE orders;

n_distinct_inherited for Partitions

Partitioned tables have a second knob: n_distinct_inherited. The plain n_distinct override applies to the table's own rows; n_distinct_inherited applies to statistics gathered across the whole inheritance/partition tree.

For a partitioned orders table, queries usually scan the parent, so the inherited form is what the planner reads. Set both to be safe when a column is badly estimated.

ALTER TABLE orders
  ALTER COLUMN customer_id SET (n_distinct_inherited = -0.8);

ANALYZE orders;

MCV: Selectivity of Equality

For an equality predicate like status = 'shipped', the planner looks for the value in most_common_vals. If found, it uses the paired frequency from most_common_freqs directly. If not found, it assumes the value is one of the non-MCV values and spreads the remaining selectivity evenly across them.

So MCV accuracy decides whether a skewed predicate gets a sensible row estimate or a flat average that's wildly wrong for a hot value.

SELECT unnest(most_common_vals::text::text[]) AS val,
       unnest(most_common_freqs)            AS freq
FROM pg_stats
WHERE tablename = 'orders' AND attname = 'status';

When the MCV List Is Too Short

The MCV list length is capped by the column's statistics target. If a skewed column has 200 meaningfully frequent values but the target only keeps 100, the planner mis-estimates the values that fell off the list.

The fix is to widen the histogram and MCV list by raising the per-column statistics target, then re-analyze. This is the most common, lowest-risk correction for skewed equality and grouping estimates.

-- keep up to 1000 MCV entries + histogram buckets for this column
ALTER TABLE orders
  ALTER COLUMN status SET STATISTICS 1000;

ANALYZE orders;

Verifying the Fix with EXPLAIN

Never trust an override blindly — confirm the estimate moved toward reality. Run EXPLAIN ANALYZE and compare the planner's estimated rows to the actual rows the executor saw.

For grouping, look at the row count emitted by the HashAggregate / GroupAggregate node. A healthy plan has estimated and actual within a small factor of each other.

EXPLAIN (ANALYZE, BUFFERS)
SELECT customer_id, count(*)
FROM orders
GROUP BY customer_id;

Correlated Columns Need Extended Stats

Per-column MCV and n_distinct assume columns are independent. When two columns are correlated (e.g. city and country), the product of single-column selectivities under-estimates the combined group count.

That is exactly what multivariate CREATE STATISTICS ... (ndistinct, mcv) repairs — it stores a joint n_distinct and a joint MCV list for the column group, fixing multi-column GROUP BY and AND-predicate estimates.

CREATE STATISTICS orders_geo (ndistinct, mcv)
  ON city, country
  FROM orders;

ANALYZE orders;

Quick Check

You have a high-cardinality column whose distinct count grows linearly as the table grows, and ANALYZE keeps under-estimating it, wrecking GROUP BY plans. Which correction is best?

Recap

You learned to repair the two statistics that drive most cardinality errors:

  • Diagnose in pg_stats: read n_distinct, most_common_vals, most_common_freqs; compare against an exact count(DISTINCT ...).
  • n_distinct is positive for absolute counts, negative for a row-ratio. Override with ALTER COLUMN ... SET (n_distinct = ...), using the ratio form for growing columns and n_distinct_inherited for partitioned parents.
  • MCV drives equality selectivity. Lengthen it with SET STATISTICS when skewed values fall off the list.
  • Always ANALYZE after any change and confirm with EXPLAIN ANALYZE that estimated rows now track actual rows.
  • For correlated columns, reach for multivariate CREATE STATISTICS (ndistinct, mcv).

Questions Fréquemment Posées

La leçon « Corrections MCV et N-Distinct » est-elle gratuite ?

Oui — le texte complet de « Corrections MCV et N-Distinct » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PostgreSQL Performance & Query Optimization, passe à CoddyKit PRO. Le cours PostgreSQL Performance & Query Optimization comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Corrections MCV et N-Distinct » ?

Utilisez les statistiques ndistinct et de valeurs les plus fréquentes pour corriger les estimations des jointures et des regroupements. Tu pratiques PostgreSQL Performance & Query Optimization avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PostgreSQL Performance & Query Optimization ?

Aucune expérience préalable n'est requise. PostgreSQL Performance & Query Optimization sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Corrections MCV et N-Distinct » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PostgreSQL Performance & Query Optimization ?

Oui. Chaque leçon PostgreSQL Performance & Query Optimization inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Comment le planificateur estime le nombre de lignes
  2. Statistiques multivariées pour les colonnes corrélées
  3. Corrections MCV et N-Distinct
  4. Valider les estimations par rapport aux lignes réelles
← Retour à PostgreSQL Performance & Query Optimization