Glossaire

->> et ->: -> renvoie un champ en jsonb, ->> le renvoie en texte. Un index GIN simple sur la colonne n’aide pas un filtre sur doc->>'key'.; Documents et JSONB
2NF: Deuxième forme normale : avec une clé composée, aucune colonne n’est un fait sur une partie seulement de la clé.; La normalisation
3NF: Troisième forme normale : aucune colonne hors de la clé n’est un fait sur une autre colonne hors de la clé.; La normalisation
Accès concurrent: Plusieurs lecteurs et écrivains utilisent les mêmes données en même temps, sans les corrompre ni perdre d’écriture en silence.; Pourquoi une base de données plutôt qu’un fichier
ACCESS EXCLUSIVE: Le mode de verrou le plus fort. Il entre en conflit avec tous les autres, y compris les simples lectures. La plupart des formes d’ALTER TABLE le prennent, sauf mention contraire dans la doc.; Les migrations qui verrouillent la table
Agrégat: Une fonction qui transforme beaucoup de lignes en une valeur : count, sum, min, max, avg. Sauf count, elles renvoient NULL quand aucune ligne n’arrive.; Compter avec GROUP BY
ANALYZE: Lit un échantillon aléatoire de la table et range des statistiques par colonne dans pg_statistic. L’autovacuum le lance en arrière-plan. L’échantillon fait 300 lignes par point de cible de statistiques : 30 000 lignes par défaut.; Statistiques du planificateur : comment PostgreSQL estime les lignes
Anomalie: Un changement que la forme de la table rend difficile ou faux : un fait à mettre à jour dans plein de lignes (mise à jour), impossible à ranger pour l’instant (insertion), ou qui disparaît avec une autre ligne (suppression).; La normalisation
Anti-jointure: Les lignes de A sans correspondance dans B : NOT EXISTS (...), ou une jointure gauche suivie de WHERE b.id IS NULL.; Les jointures
AOF: L’append-only file : chaque commande d’écriture est journalisée puis rejouée au démarrage pour reconstruire les données. Redis le livre désactivé.; Les bases clé-valeur
Archive WAL: Chaque segment de WAL terminé, copié en lieu sûr par archive_command. Avec une base backup, elle contient chaque changement depuis cette sauvegarde.; Des sauvegardes qu’on sait restaurer
Autocommit: Sans BEGIN, PostgreSQL enveloppe chaque instruction dans sa propre transaction et la committe si elle réussit. Django tourne dans ce mode par défaut.; Transactions et savepoints
Autovacuum: Un processus lanceur et des processus workers qui vérifient chaque table et lancent VACUUM et ANALYZE quand assez de lignes ont changé.; Lignes mortes et VACUUM
B-tree: Un arbre de pages équilibré. Tous les chemins de la racine à une feuille ont la même longueur, donc chaque recherche coûte le même nombre de lectures de pages.; Les index B-tree
Base backup: Une copie de tout le répertoire de données, prise pendant que le serveur tourne (pg_basebackup, ou un outil comme pgBackRest). Le point de départ pour rejouer le WAL.; Des sauvegardes qu’on sait restaurer
BRIN: Block Range Index. Garde un résumé, par exemple le min et le max, pour chaque groupe de 128 pages de la table par défaut. Il peut renvoyer des lignes qui ne correspondent pas (index lossy), donc l’exécuteur revérifie chaque ligne d’une plage retenue.; Types d’index : GIN, GiST, BRIN et Hash
Buffers: Les pages de 8 kB touchées par le nœud : hit dans le cache de PostgreSQL, read depuis l’OS ou le disque. Inclus par défaut avec ANALYZE depuis PostgreSQL 18.; Lire EXPLAIN
Chargement par jointure: Une seule requête avec un LEFT OUTER JOIN qui ramène les colonnes liées. eager_load en Rails, select_related en Django.; Le N+1 et l’ORM
Chargement paresseux: L’ORM ne charge une association que quand le code la lit pour la première fois. Rails et Django font ça par défaut. Dans une boucle sur N lignes, ça lance N requêtes.; Le N+1 et l’ORM
CHECK: Une expression booléenne sur une ligne, testée à chaque insert et update : price > 0, ends_at > starts_at.; Les contraintes : UNIQUE, CHECK et exclusion
Checkpoint: Un point où toutes les pages modifiées en mémoire ont été écrites dans les fichiers de données. La reprise part du dernier, et le WAL plus ancien peut être recyclé. Toutes les 5 minutes ou tous les 1 GB de WAL par défaut.; Le journal d’écriture anticipée
Cible du conflit: Les colonnes (et le WHERE optionnel) dans ON CONFLICT (...) qui disent à PostgreSQL quel index unique décide de ce qu’est un doublon.; Upserts et nouvelles tentatives sans risque
Classe d’opérateurs: L’ensemble des opérateurs qu’un index sait servir pour un type de colonne. Un index n’aide une clause WHERE que si elle applique l’un de ces opérateurs à la colonne indexée.; Types d’index : GIN, GiST, BRIN et Hash
Clé d’idempotence: Une valeur unique que le client envoie avec une requête (souvent un UUID) pour que le serveur reconnaisse une nouvelle tentative de la même requête.; Upserts et nouvelles tentatives sans risque
Clé d’idempotence: Une valeur que le client envoie avec sa requête pour qu’un nouvel essai soit reconnu. Une contrainte unique dessus transforme le deuxième essai en no-op (jour 23).; Capstone : les données d’une boutique
Clé de partitionnement: La colonne (ou les colonnes) qui décide dans quelle partition va une ligne. Souvent un timestamp pour range, une région ou un tenant pour list.; Partitionner les grosses tables
Clé de sharding: La colonne qui décide du shard d’une ligne. Citus l’appelle la distribution column. En général, c’est un id de tenant ou de client.; Le sharding
Clé de substitution: Une clé sans signification, fabriquée par la base : 1, 2, 3 tirés d’une séquence, ou un UUID aléatoire. Elle n’a jamais besoin de changer.; Tables, lignes et clés
Clé étrangère: Une colonne dont la valeur doit correspondre à une clé d’une autre table. La base refuse une commande qui pointe vers un client qui n’existe pas.; Tables, lignes et clés
Clé leader: Une clé dans le DCS qui nomme le primaire, rattachée à un bail (lease) avec un TTL. Qui la tient peut tourner en primaire ; si personne ne la renouvelle, elle disparaît.; Basculer sans split brain
Clé naturelle: Une clé tirée du monde réel : un email, un ISBN, « le ticket 42 de ce dépôt ». Les gens peuvent la changer, comme un client qui change d’email.; Tables, lignes et clés
Clé primaire: La ou les colonnes qui identifient une ligne. PostgreSQL exige qu’elles soient uniques et non nulles, et construit dessus un index B-tree unique.; Tables, lignes et clés
Co-location: Des tables shardées sur la même clé et les mêmes plages gardent les lignes qui vont ensemble sur le même nœud, donc les jointures et les transactions sur une clé restent locales.; Le sharding
Colonne de version: Un entier stocké sur la ligne (Rails l’appelle lock_version). Chaque mise à jour réussie lui ajoute un.; Le verrouillage optimiste
Commit: Une entrée du journal est validée (committed) dès qu’un quorum l’a stockée. Alors seulement elle est appliquée, et elle n’est plus jamais perdue ensuite.; Comment les réplicas se mettent d’accord
Commit atomique: Un groupe de changements arrive en entier ou pas du tout. Un crash au milieu laisse l’ancien état, jamais un mélange des deux.; Pourquoi une base de données plutôt qu’un fichier
Compare-and-set: Un UPDATE dont la clause WHERE contient la valeur attendue. Il n’écrit que si la ligne a toujours cette valeur, en une seule instruction atomique.; Le verrouillage optimiste
Containment (@>): a @> b est vrai quand chaque clé et chaque valeur de b se trouve dans a, au même endroit. C’est l’opérateur principal qu’un index GIN sur jsonb sait servir.; Documents et JSONB
Contournement: Les superutilisateurs et les rôles avec BYPASSRLS ignorent toutes les policies. Le propriétaire de la table aussi, sauf si la table a FORCE ROW LEVEL SECURITY.; Rôles, droits et sécurité au niveau des lignes
Contrainte d’exclusion: Un UNIQUE généralisé : deux lignes ne peuvent pas correspondre sur tous les opérateurs listés. Avec && sur un intervalle, ça veut dire « deux réservations ne se chevauchent jamais ».; Les contraintes : UNIQUE, CHECK et exclusion
Counter cache: Un compte rangé sur la ligne parente, comme tags.public_topic_count, mis à jour à chaque ajout ou retrait d’une ligne enfant.; La dénormalisation : copier des données exprès
Course vérifier-puis-agir: Le code lit pour décider (« cet email est-il libre ? »), puis écrit. Un autre écrivain peut changer la réponse entre la lecture et l’écriture.; Les contraintes : UNIQUE, CHECK et exclusion
CREATE INDEX CONCURRENTLY: Construit un index sans bloquer les écritures. Ça coûte deux parcours de la table, plus de temps, et ça ne peut pas tourner dans un bloc de transaction.; Les migrations qui verrouillent la table
DCS: Distributed configuration store : etcd, Consul, ZooKeeper ou l’API Kubernetes. Un petit cluster qui se met d’accord sur quelques clés, même quand certains de ses propres nœuds tombent.; Basculer sans split brain
Deadlock: Deux transactions ou plus tiennent chacune un verrou qu’une autre veut. Aucune ne peut avancer tant qu’on n’en annule pas une.; Verrous et deadlocks
deadlock_timeout: Le temps pendant lequel une transaction qui attend dort avant de chercher un deadlock. Une seconde par défaut.; Verrous et deadlocks
Démultiplication: Une ligne de A qui correspond à 5 lignes de B donne 5 lignes dans le résultat. Joins deux tables de ce genre, et les comptes se multiplient.; Les jointures
Dénormalisation: Ranger un fait une deuxième fois, exprès, pour que les lectures coûtent moins cher. L’original reste la source de vérité.; La dénormalisation : copier des données exprès
Dépendance fonctionnelle: La colonne B dépend de la colonne A quand une valeur de A va toujours avec une seule valeur de B. Un entrepôt a une seule adresse : warehouse détermine address.; La normalisation
Dérive: La copie ne correspond plus à sa source, parce qu’une écriture a changé l’une et pas l’autre.; La dénormalisation : copier des données exprès
Dump logique: Ce que produit pg_dump : du SQL ou une archive qui reconstruit les tables. Un instantané cohérent d’un moment, portable d’une version à l’autre, mais impossible de rejouer du WAL par-dessus.; Des sauvegardes qu’on sait restaurer
Durabilité: Dès que la base répond « committed », le changement survit à un crash ou à une coupure de courant. Il est sur le disque, pas seulement dans un cache.; Pourquoi une base de données plutôt qu’un fichier
Échec de sérialisation: L’erreur que PostgreSQL lève pour empêcher une anomalie, toujours avec le SQLSTATE 40001. La solution : annuler et relancer toute la transaction.; Niveaux d’isolation
Élagage de partitions: Le planificateur prouve, à partir du WHERE, que certaines partitions ne peuvent pas contenir de lignes qui correspondent, et les retire du plan. En anglais, on dit partition pruning.; Partitionner les grosses tables
État de session: Tout ce qui vit sur une connexion entre deux transactions : les valeurs de SET, LISTEN, les verrous consultatifs de session, les PREPARE SQL, les tables temporaires.; Connexions et pooling
EXPLAIN ANALYZE: Exécute vraiment la requête et affiche, à côté de chaque estimation, le temps réel en millisecondes, les lignes réelles et les boucles. Ça exécute pour de vrai : un UPDATE met vraiment à jour.; Lire EXPLAIN
Fan-out: Le nombre d’enfants vers lesquels pointe une page interne. Avec des clés petites, il se compte en centaines, ce qui garde l’arbre à quelques niveaux.; Les index B-tree
Fan-out: Une requête qu’on ne peut pas router par la clé : elle tourne sur chaque shard et les résultats sont fusionnés.; Le sharding
File d’attente des verrous: Les demandes que PostgreSQL ne peut pas accorder attendent leur tour. Une nouvelle demande attend si elle entre en conflit avec un verrou déjà tenu, ou avec un verrou encore en attente.; Les migrations qui verrouillent la table
Fonction de fenêtrage: Un calcul proche d’un agrégat, avec OVER (...), qui ne replie pas les lignes : chaque ligne garde son identité et reçoit une valeur calculée à partir des lignes liées.; Compter avec GROUP BY
Full-page write: Le premier changement d’une page après un checkpoint journalise une copie de la page entière de 8 kB, pour pouvoir reconstruire une page déchirée par un crash en pleine écriture.; Le journal d’écriture anticipée
GIN: Generalized Inverted Index. Une entrée par élément (case d’un tableau, clé JSONB, mot), qui pointe vers les lignes qui le contiennent. Fait pour « cette valeur contient-elle celle-là ? ».; Types d’index : GIN, GiST, BRIN et Hash
GiST: Generalized Search Tree. Un arbre équilibré de boîtes englobantes ou d’intervalles. Répond au chevauchement, à l’inclusion et au plus proche voisin pour la géométrie, les intervalles et les réseaux IP.; Types d’index : GIN, GiST, BRIN et Hash
GROUP BY: Découpe les lignes en groupes qui partagent les mêmes valeurs, puis rend une ligne par groupe. Toute autre colonne de la liste SELECT doit être dans un agrégat, sauf si elle dépend d’une clé primaire regroupée.; Compter avec GROUP BY
HAVING: Un filtre sur les groupes, après le calcul des agrégats. WHERE filtre les lignes avant le regroupement et ne peut pas utiliser d’agrégat.; Compter avec GROUP BY
Idempotent: Lancer l’opération deux fois laisse le système dans le même état que la lancer une fois.; Upserts et nouvelles tentatives sans risque
Identifiant de transaction (XID): Un nombre sur 32 bits que reçoit chaque transaction qui écrit. Chaque version de ligne garde le XID qui l’a créée, et la visibilité compare des XID.; Lignes mortes et VACUUM
Index composite: Un index sur plusieurs colonnes, trié par la première, puis par la deuxième quand la première est égale, et ainsi de suite. Comme un annuaire trié par nom, puis par prénom.; Index composites, partiels et couvrants
Index couvrant: Un index qui contient toutes les colonnes dont une requête a besoin. Avec INCLUDE, des colonnes en plus sont rangées dans les feuilles comme charge utile, pas comme clés de recherche.; Index composites, partiels et couvrants
Index partiel: Un index avec une clause WHERE : il ne contient que les lignes qui la vérifient. Plus petit, moins cher à mettre à jour, et utilisable seulement par les requêtes dont la condition implique cette clause.; Index composites, partiels et couvrants
IS DISTINCT FROM: Une comparaison qui traite NULL comme une valeur ordinaire. Elle renvoie toujours vrai ou faux, jamais NULL.; NULL en SQL : comparaisons, NOT IN et clés uniques
Jointure gauche: A LEFT JOIN B ON ... garde chaque ligne de A. Quand B n’a pas de correspondance, les colonnes de B valent NULL.; Les jointures
Jointure interne: A JOIN B ON ... ne garde que les paires où la condition est vraie. Une ligne de A sans correspondance dans B disparaît.; Les jointures
jsonb: Stocke une forme binaire déjà analysée. Perd les espaces et les clés en double, ne garde pas l’ordre des clés, et peut être indexé. Le type json, lui, garde le texte exact reçu.; Documents et JSONB
jsonb_path_ops: Une classe d’opérateurs GIN plus compacte. Une entrée hachée par chemin vers une valeur. Supporte @>, @? et @@, mais pas ?. La classe par défaut, jsonb_ops, supporte aussi ?.; Documents et JSONB
Leader, follower, candidat: Les trois rôles possibles d’un nœud. Seul le leader accepte les écritures, et les followers copient son journal. Un follower qui n’entend plus le leader passe candidat et demande des votes.; Comment les réplicas se mettent d’accord
Lexème: Un mot après normalisation : en minuscules, réduit à sa racine, sans les mots vides. Avec la configuration english, « restored » et « restore » donnent tous deux restor.; La recherche plein texte
Ligne morte: Une ancienne version de ligne laissée par un UPDATE ou un DELETE. Elle prend encore de la place dans sa page (jour 9) jusqu’à ce que VACUUM la retire.; Lignes mortes et VACUUM
Line pointer: Un emplacement de 4 octets en haut de la page, qui contient la position et la longueur d’un tuple. L’adresse d’une ligne désigne cet emplacement, et la position en octets peut changer.; Pages et lignes sur le disque
Lire ses propres écritures: Une promesse faite à un utilisateur : après qu’il a écrit, sa lecture suivante le voit. Les réplicas seuls ne la tiennent pas ; l’appli doit router pour ça.; La réplication et son retard
Liste MCV: Most common values : jusqu’à 100 valeurs de la colonne (la cible de statistiques par défaut), avec la part des lignes de chacune. Pour un = sur l’une d’elles, le planificateur connaît directement sa part.; Statistiques du planificateur : comment PostgreSQL estime les lignes
Liste SELECT: Les expressions après SELECT : les colonnes et les valeurs calculées de chaque ligne de sortie. AS donne un nom à l’une d’elles, un alias.; Interroger avec SELECT
lock_timeout: Annule une instruction qui attend un verrou plus longtemps que ça. Désactivé (zéro) par défaut, donc une attente peut durer pour toujours.; Verrous et deadlocks
lock_timeout: Un paramètre qui annule une instruction dès qu’elle attend un verrou plus longtemps que la limite. La valeur par défaut est 0, et avec 0 l’instruction attend sans limite.; Les migrations qui verrouillent la table
log_min_duration_statement: Écrit dans le log chaque instruction qui a duré au moins ce temps, avec sa durée et son texte. -1, la valeur par défaut, n’écrit rien.; Trouver les requêtes lentes
Logique à trois valeurs: Une condition SQL renvoie vrai, faux ou NULL (inconnu). NULL AND false vaut faux, NULL OR true vaut vrai, presque tout le reste avec un NULL vaut NULL.; NULL en SQL : comparaisons, NOT IN et clés uniques
loops: Le nombre de fois où le nœud a tourné. Le temps et les lignes réels sont des moyennes par boucle : multiplie par loops pour avoir le total.; Lire EXPLAIN
LSN: Log sequence number : une position dans le WAL. Chaque page de données retient le LSN du dernier enregistrement WAL qui l’a modifiée.; Le journal d’écriture anticipée
Mise à jour perdue: Deux transactions lisent une valeur, en calculent une nouvelle dans l’appli, et la réécrivent. La deuxième écriture efface la première sans rien dire.; Niveaux d’isolation
Mise à jour perdue: Deux écrivains lisent la même ligne, la modifient tous les deux, et l’écriture la plus tardive écrase la première comme si elle n’avait jamais eu lieu.; Le verrouillage optimiste
Mise en file transactionnelle: Insérer le job dans la même transaction que les données qu’il concerne. Si la transaction est annulée, le job n’a jamais existé.; Une file de jobs dans la base
MVCC: Multiversion concurrency control, ou contrôle de concurrence multiversion. La base garde plusieurs versions d’une ligne, et chaque transaction lit celle qui correspond à son snapshot.; MVCC : versions de lignes et snapshots
Nœud de plan: Une étape du plan : un parcours, une jointure, un tri, un agrégat. Les nœuds forment un arbre. Les plus internes tournent d’abord et remontent leurs lignes à leur parent.; Lire EXPLAIN
Normalisation: Les constantes d’une requête sont remplacées par $1, $2 : id = 42 et id = 43 partagent une ligne, repérée par un hash queryid.; Trouver les requêtes lentes
NULL: Un marqueur pour une valeur absente ou inconnue. NULL n’est ni 0, ni la chaîne vide, ni false.; NULL en SQL : comparaisons, NOT IN et clés uniques
NULLS NOT DISTINCT: Une clause d’index ou de contrainte unique (PostgreSQL 15 et plus) qui fait compter deux NULL comme égaux : un seul est alors permis.; NULL en SQL : comparaisons, NOT IN et clés uniques
Objet périmé: Une copie d’une ligne en mémoire dont la version ne correspond plus à la base. L’enregistrer doit échouer plutôt qu’écraser.; Le verrouillage optimiste
ORDER BY: La clause qui trie le résultat. Sans elle, PostgreSQL rend les lignes « in whatever order the system finds fastest to produce » (dans l’ordre qui lui coûte le moins).; Interroger avec SELECT
Ordre logique: L’ordre dans lequel les clauses agissent, que la doc de SELECT décrit étape par étape. Il décide de ce que chaque clause peut voir.; Interroger avec SELECT
Page: Un bloc fixe de 8 Ko (par défaut) dans un fichier de table ou d’index. PostgreSQL lit, met en cache et écrit des pages entières.; Pages et lignes sur le disque
Page split: Quand un insert ne tient pas dans une feuille, une partie de ses entrées part dans une nouvelle page et le parent reçoit une nouvelle clé de séparation. Les splits peuvent remonter jusqu’à la racine.; Les index B-tree
Pagination par clé: Demander « les lignes suivantes après la dernière que j’ai vue » avec un WHERE sur la clé de tri, au lieu de sauter des lignes avec OFFSET.; Interroger avec SELECT
Partition par défaut: Un fourre-tout pour les lignes qui ne vont dans aucune autre partition. Sans elle, PostgreSQL refuse un tel insert avec une erreur.; Partitionner les grosses tables
pg_stat_statements: Un module livré avec PostgreSQL qui compte les appels, le temps, les lignes et les blocs de chaque instruction exécutée par le serveur, et montre les totaux dans une vue.; Trouver les requêtes lentes
Poids: Une étiquette A, B, C ou D sur chaque position, posée avec setweight. Elle sert à classer un résultat dans le titre devant un résultat dans le corps.; La recherche plein texte
Politique d’éviction: Ce que fait Redis quand il atteint maxmemory : jeter des clés par LRU, LFU, TTL ou au hasard, ou refuser les écritures avec noeviction, le défaut.; Les bases clé-valeur
Pooling de session: PgBouncer donne à un client une connexion serveur jusqu’à ce que le client se déconnecte. Tout marche, mais un client inactif garde quand même une connexion.; Connexions et pooling
Pooling de transaction: PgBouncer donne à un client une connexion serveur seulement le temps d’une transaction, puis la passe à quelqu’un d’autre.; Connexions et pooling
Préfixe de gauche: Les premières colonnes d’un index composite. Un B-tree sur (a, b, c) marche le mieux quand la requête contraint a, ou a et b. Il sert aussi (a) seul, donc un index séparé sur a est redondant.; Index composites, partiels et couvrants
Preload (requête séparée): Une deuxième requête, WHERE id IN (...) avec les ids de la première, puis l’association se fait en mémoire. preload en Rails, prefetch_related en Django.; Le N+1 et l’ORM
Prise en charge: Faire passer un job de available à executing et noter qui l’a pris, dans une transaction courte, pour qu’aucun autre worker ne le prenne.; Une file de jobs dans la base
Processus backend: Le processus serveur que PostgreSQL démarre pour une connexion. Il vit aussi longtemps que la connexion et garde l’état de cette session.; Connexions et pooling
Quorum: Une majorité des membres votants : (n/2)+1, avec la division arrondie vers le bas. 2 sur 3, 3 sur 4, 3 sur 5.; Comment les réplicas se mettent d’accord
Racine, interne, feuille: La racine est la page du haut. Les pages internes contiennent des clés de séparation et des liens vers le niveau du dessous. Les feuilles contiennent chaque clé avec le ctid de sa ligne.; Les index B-tree
Récupération à un instant donné: PITR en anglais : tu restaures une base backup, tu rejoues le WAL, et tu t’arrêtes à un moment choisi, la cible de récupération, comme recovery_target_time.; Des sauvegardes qu’on sait restaurer
Réplication asynchrone: Le réglage par défaut de PostgreSQL : un commit revient dès que le primaire a flushé son propre WAL. Les réplicas rattrapent un peu plus tard.; La réplication et son retard
Réplication synchrone: Un commit attend aussi des standbys désignés. synchronous_commit choisit jusqu’où : écrit (remote_write), flushé (on), ou rejoué et visible (remote_apply).; La réplication et son retard
Requêtes N+1: Une requête charge N lignes parentes, puis le code lance une requête de plus par ligne pour charger un objet lié. N+1 requêtes là où 1 ou 2 suffiraient.; Le N+1 et l’ORM
Retard de réplication: De combien un réplica est en retard, en octets de WAL ou en secondes. Affiché par réplica dans pg_stat_replication sur le primaire.; La réplication et son retard
Rétention: La règle qui supprime ou détache les partitions dès que toutes leurs données dépassent un âge limite. pg_partman la fait tourner pour toi.; Partitionner les grosses tables
Rôle: Une identité dans la base. Il peut se connecter (un utilisateur), ou porter des droits pour d’autres (un groupe). Un rôle peut être membre d’autres rôles.; Rôles, droits et sécurité au niveau des lignes
Rollback journal: Un fichier à part où SQLite recopie les pages d’origine avant de modifier la base. Supprimer ce fichier valide le changement.; Pourquoi une base de données plutôt qu’un fichier
Row group: Une tranche horizontale d’une table, stockée colonne par colonne. Dans DuckDB, 122 880 lignes par défaut. La compression et le parallélisme travaillent par row group.; Des colonnes pour l’analytique
Row-level security (RLS): Des policies par table qui filtrent les lignes qu’une requête peut lire ou écrire. S’active avec ALTER TABLE ... ENABLE ROW LEVEL SECURITY.; Rôles, droits et sécurité au niveau des lignes
Sauvetage: Remettre un job en available quand son worker est mort pendant qu’il était executing. On le trouve à son âge : il tourne depuis bien trop longtemps.; Une file de jobs dans la base
Savepoint: Un repère dans une transaction. ROLLBACK TO annule ce qui vient après et garde ce qui vient avant, sans terminer la transaction.; Transactions et savepoints
Sélectivité: La part des lignes qu’une condition garde, de 0 à 1. Lignes estimées = lignes de la table × sélectivité.; Statistiques du planificateur : comment PostgreSQL estime les lignes
Shard: Un morceau d’une table shardée, une table normale sur un serveur. Citus en crée 32 par table par défaut et les répartit sur les nœuds workers.; Le sharding
SKIP LOCKED: Une option de verrouillage pour SELECT : les lignes qu’une autre transaction a verrouillées sont laissées hors du résultat au lieu d’être attendues.; Une file de jobs dans la base
Snapshot: Trois choses : xmin (toute transaction plus ancienne est terminée), xmax (toute transaction à partir de là est invisible), et la liste des transactions encore en cours entre les deux.; MVCC : versions de lignes et snapshots
Snapshot RDB: Une copie à un instant donné de tout le jeu de données dans un seul fichier compact, écrite par un processus enfant forké aux points de sauvegarde configurés.; Les bases clé-valeur
Source de vérité: Les données à partir desquelles une copie est calculée. Si les deux ne sont pas d’accord, la source gagne et la copie est reconstruite.; La dénormalisation : copier des données exprès
Split brain: Deux serveurs acceptent tous les deux des écritures comme primaire. Leurs historiques divergent, et les commits du côté perdant sont perdus ou fusionnés à la main.; Basculer sans split brain
Statistiques étendues: Des statistiques sur plusieurs colonnes, créées avec CREATE STATISTICS et remplies par ANALYZE : dépendances fonctionnelles, nombres de valeurs distinctes et listes MCV sur des groupes de colonnes.; Statistiques du planificateur : comment PostgreSQL estime les lignes
Stockage en colonnes: Chaque colonne est stockée à part. Une requête ne lit que les colonnes qu’elle nomme. DuckDB et ClickHouse fonctionnent ainsi.; Des colonnes pour l’analytique
Stockage en lignes: Toutes les colonnes d’une ligne sont côte à côte sur le disque. Rapide pour lire ou modifier une ligne entière. Le heap de PostgreSQL range les lignes ainsi.; Des colonnes pour l’analytique
Tâche outbox: Une ligne dans une table de tâches, écrite dans la même transaction que la commande. Un worker la prend plus tard, donc aucun e-mail ne part pour une commande annulée (jour 24).; Capstone : les données d’une boutique
Terme: Un nombre qui augmente à chaque élection. Chaque terme a au plus un leader. Un nœud qui voit un terme plus grand repasse follower.; Comment les réplicas se mettent d’accord
TOAST: Le stockage des grosses valeurs. Une ligne de plus de 2 ko environ voit ses gros champs compressés et, si besoin, déplacés par morceaux dans une table annexe.; Pages et lignes sur le disque
total_exec_time: La somme du temps d’exécution sur tous les appels. Trie dessus pour voir où le serveur passe son temps ; mean_exec_time seul cache les requêtes rapides lancées souvent.; Trouver les requêtes lentes
Transaction: Un groupe d’instructions que la base traite comme une seule unité. Elle finit par COMMIT (tout garder) ou ROLLBACK (ne rien garder).; Transactions et savepoints
Transaction de checkout: Une seule transaction qui crée la commande, ses lignes, la baisse du stock et la tâche de confirmation. Tout est validé, ou rien (jour 17).; Capstone : les données d’une boutique
Transaction en échec: Après une erreur dans une transaction, PostgreSQL refuse toutes les instructions suivantes jusqu’à un ROLLBACK, ou un ROLLBACK TO vers un savepoint.; Transactions et savepoints
tsquery: Des lexèmes reliés par &, |, ! et <->. @@ teste si un tsvector y correspond. :* demande une correspondance par préfixe.; La recherche plein texte
tsvector: Une liste triée de lexèmes, chacun avec ses positions dans le document et un poids optionnel. C’est ce que tu stockes et indexes.; La recherche plein texte
TTL: Un délai d’expiration sur une clé, posé avec EXPIRE ou SET ... EX. Redis appelle une telle clé « volatile ». Quand le temps est écoulé, la clé est supprimée.; Les bases clé-valeur
Tuple: Une version stockée d’une ligne, avec son en-tête. Un UPDATE écrit un nouveau tuple, donc une ligne peut en avoir plusieurs.; Pages et lignes sur le disque
UNIQUE: Deux lignes ne partagent jamais la même valeur dans ces colonnes. PostgreSQL l’impose avec un index B-tree unique.; Les contraintes : UNIQUE, CHECK et exclusion
Update gardé: Un UPDATE dont le WHERE vérifie aussi la règle, comme stock >= 1. S’il ne touche aucune ligne, la règle a échoué et la transaction est annulée.; Capstone : les données d’une boutique
Upsert: Insérer une ligne, ou la mettre à jour si une ligne avec la même clé existe. En PostgreSQL : INSERT ... ON CONFLICT ... DO UPDATE.; Upserts et nouvelles tentatives sans risque
USING / WITH CHECK: USING filtre les lignes existantes qu’une commande voit. WITH CHECK teste les nouvelles lignes qu’elle essaie d’écrire. Un check raté annule la commande.; Rôles, droits et sécurité au niveau des lignes
VACUUM: Retire les versions mortes qu’aucune transaction ne peut voir et marque la place comme libre pour de nouvelles lignes de la même table. Il ne bloque ni les lectures ni les écritures.; Lignes mortes et VACUUM
Verrou de ligne: Pris par UPDATE, DELETE et SELECT FOR UPDATE sur chaque ligne qu’ils touchent. Il bloque les autres écrivains et verrouilleurs de cette ligne, jamais les simples lecteurs. Relâché à la fin de la transaction.; Verrous et deadlocks
WAL: Write-ahead log : un enregistrement en ajout seul de chaque changement des tables et des index, dans les fichiers de pg_wal. Un changement est journalisé avant que la page qu’il décrit puisse arriver sur le disque.; Le journal d’écriture anticipée
Watchdog: Un minuteur, noyau ou matériel, qui redémarre la machine s’il ne reçoit pas de signal de vie à temps. Patroni compte sur lui quand le nœud ne peut pas se rétrograder.; Basculer sans split brain
Write skew: Deux transactions lisent les mêmes lignes, vérifient une règle, et chacune écrit une ligne différente. Chaque écriture est correcte seule. Ensemble, elles cassent la règle.; Niveaux d’isolation
xmax: L’identifiant de la transaction qui a supprimé ou remplacé cette version, ou zéro. Un xmax non nul sur une ligne visible veut en général dire que cette transaction n’a pas committé, ou a été annulée.; MVCC : versions de lignes et snapshots
xmin: Une colonne cachée sur chaque version de ligne : l’identifiant de la transaction qui l’a insérée. Tu peux la sélectionner : SELECT xmin, xmax, * FROM orders.; MVCC : versions de lignes et snapshots
Zonemap: Le min et le max d’une colonne dans un bloc. Un filtre qui tombe hors de l’intervalle saute le bloc sans le lire. On dit aussi index min-max.; Des colonnes pour l’analytique