Glossary Archive - The Sev-1 Database

Access path (Path)

One candidate way to produce a relation's result (seq scan, index scan, a join method), annotated with cost; the optimizer compares many Paths and…

ACID

ACID is four promises a database makes about transactions: Atomicity (all or nothing), Consistency (rules stay satisfied), Isolation (transactions do no...

AllocSet allocator

The default memory-context allocator (aset.c): geometric blocks carved into chunks, with 11 power-of-two freelists from 8 B to 8 KB and dedicated blocks for…

ANALYZE (statistics)

ANALYZE samples your tables and stores statistics — how many rows, common values, value spread — so the query planner can estimate well. Out-of-date…

Apply lag

The gap between WAL a standby has received and WAL it has applied; tiny on a healthy replica, deliberately large on a delayed standby,…

Asynchronous replication

Replication where the primary commits without waiting for a standby to confirm receipt; low commit latency at the cost of a small, bounded potential…

attcacheoff (cached attribute offset)

A cached byte offset for a column, usable when all preceding columns are fixed-width and NOT NULL, giving O(1) access; broken by the first…

Autovacuum

Autovacuum is a set of background workers that run VACUUM and ANALYZE for you automatically, based on how much each table has changed. You…

Autovacuum launcher

The background process that schedules vacuuming: it wakes on autovacuum_naptime and dispatches per-database workers that run VACUUM/ANALYZE where dead tuples accumulate.

Backend process

A backend is the PostgreSQL server process dedicated to one client connection. Everything you run goes through your backend. The postmaster is the paren...

Background writer (bgwriter)

The background process that trickles dirty shared buffers to disk ahead of demand, so backends usually find a clean buffer instead of stalling to…

Bloat

Bloat is wasted space inside a table or index — pages full of dead row versions and gaps that no longer hold useful data.…

Block incremental backup

A backup that stores only the changed blocks within a changed file (pgBackRest 2.46+), comparing block checksums — dramatically smaller for large, mostly-static tables.

Cascaded standby

A replica that streams WAL from another standby rather than the primary; read-only and never eligible to be a synchronous standby.

Cascading replication

When a standby relays WAL onward to other standbys via its own walsender, forming a replication tree that offloads the primary and reduces WAN…

catalog_xmin

The oldest transaction id whose system catalog row versions must be retained; logical slots hold it back so logical decoding can still interpret WAL…

Checkpoint

A checkpoint is the moment PostgreSQL flushes all the changes that are still only in memory (and in the WAL) down to the real…

Checkpointer

The background process that performs checkpoints — flushing dirty buffers and writing a checkpoint WAL record — and spreads its writes to smooth I/O.

Column alignment (padding)

Each type's alignment requirement (attalign) forces a column's start to round up to a boundary, inserting padding bytes; column order changes how much padding…

Commit log (clog / pg_xact)

A small on-disk ledger (pg_xact) storing two bits of commit status per transaction id; MVCC visibility checks consult it to decide whether a row's…

Connection pooling

Connection pooling means keeping a small set of database connections open and sharing them among many application requests, instead of opening a new con...

Connection vs Session

A connection is the open line between your client and one PostgreSQL backend process. A session is the conversation that happens over that connection…

Constraint

A constraint is a rule the database enforces on your data: NOT NULL (must have a value), UNIQUE (no duplicates), CHECK (must satisfy a…

Correlation (statistics)

How closely the on-disk row order matches a column's sorted order (-1 to 1); decides whether an index scan reads sequentially or randomly.

Dead tuple

A dead tuple is an old version of a row that no transaction can see anymore — left behind after an UPDATE or DELETE.…

Deadlock

A deadlock is when two transactions each hold something the other needs, so neither can move — A waits for B while B waits…

Deduplication (B-tree posting list)

Merging duplicate-key entries on a B-tree leaf into one posting-list tuple (key + array of TIDs); shrinks low-cardinality indexes and delays page splits (PG13+).

Delayed standby

A replica deliberately held a fixed interval behind the primary: it receives WAL in real time but delays applying it, acting as an undo…

Demand-pull execution (Volcano model)

The execution model where rows are pulled from the top of the plan one at a time, each node asking its children; it needs…

Differential backup

A backup that copies only files changed since the last full backup; restore needs just the full plus one differential.

DR drill

A deliberate rehearsal of disaster recovery (often a planned switchover) run while healthy, to prove the plan works and measure the real RPO and…

Equi-depth histogram

A set of buckets that each hold about the same number of rows, used by the PostgreSQL planner to estimate range queries.

etcd (distributed consensus store)

A strongly-consistent key-value store using Raft to agree across a quorum of nodes; in a Patroni cluster it is the DCS holding the leader…

Executor node (PlanState)

The runtime form of a plan node (a PlanState) holding its execution state; the executor is a tree of these pulled one tuple at…

Extended statistics

Statistics across several columns (CREATE STATISTICS) that teach the PostgreSQL planner correlated columns are not independent.

Failover slot

A logical replication slot marked failover=true so it is mirrored onto a standby and survives promotion, letting logical subscribers continue without a re-seed.

Fast-path locking

Recording weak, non-conflicting relation locks in a backend's own 16 PGPROC slots instead of the shared lock table; overflow or a strong lock pushes…

fillfactor

A storage parameter setting how full PostgreSQL packs each page on insert; leaving space (e.g. 80) reserves room for same-page HOT updates and reduces…

Foreign key

A foreign key is a rule that says "a value in this column must exist in another table". It links a child row to…

Full-page write (FPI)

A copy of a whole 8KB page written to WAL on its first change after a checkpoint, protecting against torn pages; the main cause…

Heap

The heap is where PostgreSQL physically stores the actual rows of a table, in no particular order, inside data pages. Indexes point into the…

Heap pruning

Lightweight single-page cleanup PostgreSQL performs during ordinary reads: it reclaims dead row versions and collapses HOT chains without touching indexes, obeying the xmin horizon.

Heap-Only Tuple (HOT)

An updated row version that creates no new index entry because no indexed column changed and it fits on the same page; lets pruning…

Heavyweight lock (lock manager)

The manager (lock.c) that locks database objects (mostly relations) in eight modes via a shared, 16-partition table; the layer that serialises DML against DDL.

High key (B-tree)

An upper-bound value stored as the first item on a B-tree page guaranteeing every key on the page is

Hint bits

Flags PostgreSQL writes onto a row to cache whether its creating/deleting transaction committed, so later visibility checks skip the commit-log lookup; the first reader…

Incremental backup

A backup that copies only files changed since the last backup of any type; smallest to take, but restore needs the full plus the…

Index

An index is a separate, sorted structure that lets PostgreSQL find rows without scanning the whole table — like the index at the back…

Isolation level

The isolation level controls how much one transaction can see of others that are running at the same time. PostgreSQL offers Read Committed (default),…

Leader key (TTL lease)

A single key in the consensus store marking the current primary, carrying a TTL the primary renews each loop; if it expires, survivors race…

Line pointer (ItemId)

A slot in a PostgreSQL page header that locates a row and records its state (NORMAL, REDIRECT, DEAD, UNUSED); pruning and VACUUM work by…

LOCALLOCK

A backend's private record of locks it already holds (and acquisition counts); re-acquiring a held lock is satisfied locally with no shared-memory access.

Lock

A lock is a reservation that stops two sessions from changing the same thing at once. PostgreSQL takes many locks automatically — light ones…

Lock partition

One of the 16 slices of the shared lock table, each guarded by its own lightweight lock and chosen by hashing the lock tag,…

Logical Sequence Number (LSN)

An LSN is an address into the WAL — a steadily increasing number that marks an exact position in the write-ahead log. PostgreSQL uses…

Materialized view

A materialized view stores the results of a query physically, like a snapshot, so reading it is fast. Unlike a normal view (which re-runs…

Memory context (MemoryContext)

A named allocation arena that owns a group of palloc'd objects; resetting or deleting it frees them all at once. Contexts form a tree…

Most Common Values (MCV list)

The short list of a column's most frequent values, with their frequencies, that ANALYZE stores so the planner can estimate equality filters.

MultiXact (pg_multixact)

An id representing a set of transactions sharing a row lock (with their lock modes), stored in the pg_multixact SLRUs; has its own id…

MVCC (Multi-Version Concurrency Control)

Instead of locking a row while someone reads it, PostgreSQL keeps several versions of that row. Readers see the version that existed when their…

n_distinct

PostgreSQL's estimate of how many different values a column holds; positive is a count, negative is a fraction of the table.

NULL bitmap

A run of bits in the tuple header (t_bits), one per column, marking which columns are NULL; present only when a row has a…

Page (data block)

PostgreSQL reads and writes data in fixed-size chunks called pages (8 kB by default). Every table and index is a sequence of pages, and…

Page split (B-tree)

What happens when an insert hits a full B-tree page: a new page is allocated, entries move, sibling links rewire, and a downlink is…

palloc / pfree

PostgreSQL's internal allocator: palloc allocates from CurrentMemoryContext (no context argument), and pfree is rarely needed because contexts are reset wholesale.

Partitioning

Partitioning splits one big logical table into many smaller physical pieces (partitions), usually by a range like date or by a key. Queries that…

Pathkeys

How the planner records the sort order a path produces rows in. A path delivering already-sorted rows can skip a downstream sort, letting it…

Patroni

An open-source agent running beside each PostgreSQL node that automates HA: it elects one primary via a consensus store, promotes standbys on failure, and…

Per-tuple memory context

A tiny executor arena (ecxt_per_tuple_memory) for evaluating expressions on one row, reset between rows — why row-by-row evaluation doesn't accumulate memory.

pg_backend_memory_contexts

A PostgreSQL 14+ system view listing every memory context in the current backend (name, parent, level, total/used/free bytes) — the primary tool for diagnosing…

pg_locks

A system view exposing every held or awaited lock — object, relation, mode, granted, and a fastpath flag — the primary tool for diagnosing…

pg_promote (promotion)

The PostgreSQL function that tells a standby to exit recovery, open for writes, and advance its timeline — the actual verb behind every failover…

pg_stat_slru

A system view (PG13+) reporting per-cache SLRU activity — hits, disk reads, writes, zeroed pages — the main instrument for diagnosing SLRU contention.

pg_statistic and pg_stats

The catalog (pg_statistic) and readable view (pg_stats) where PostgreSQL stores the per-column statistics the planner uses.

pg_walinspect

A contrib extension (PG15+) to decode WAL from SQL: pg_get_wal_records_info() and pg_get_wal_stats() show per-resource-manager record and full-page-image bytes.

pgBackRest

A widely used open-source backup/restore tool for PostgreSQL that manages a repository of full/differential/incremental backups plus archived WAL and supports point-in-time recovery.

Pipelined vs blocking node

A pipelined node emits a row as soon as it has one; a blocking node (Sort, Hash, unsorted aggregate) must read all input first.…

Plan tree

The planner's output: a tree of operations (scans, joins, sorts) that, executed bottom-up, produces the result. It is the strategy the executor follows and…

Planner enable flags

The enable_* settings that discourage a scan or join type by adding a large cost penalty rather than truly forbidding it; diagnostic tools, not…

Portal

The container holding a running query's state — its plan, position in the result, and memory. A SQL cursor is a portal, and the…

Postmaster

The supervisor process that starts a PostgreSQL server: it creates shared memory, forks a backend per connection, launches the background workers, and manages crash…

Primary key

A primary key is the column (or set of columns) that uniquely identifies each row in a table, and can never be null. Every…

Projection (ExecProject)

The per-tuple step where a node computes its output columns and expressions (the SELECT list) from the input tuple; heavy expressions cost on every…

Query planner

The query planner is the part of PostgreSQL that decides HOW to run your SQL — which indexes to use, which join method, what…

Query rewriter

The stage between analysis and planning that applies rules and expands views, rewriting a query into an equivalent one over base tables before the…

Query tree

The tree PostgreSQL produces by parse analysis: names resolved against the catalog, types checked, SELECT * expanded. It is where semantic errors appear and…

random_page_cost

The planner's cost of a random disk read relative to a sequential read (default 4.0). Lowering it toward 1.1 on SSD/cached data makes index…

Raw parse tree

The first tree PostgreSQL builds from SQL text using grammar alone; it captures syntax without catalog lookups, so it is the only stage where…

recovery_min_apply_delay

The standby setting that delays applying each commit until its timestamp plus the configured interval has passed, creating a time-delayed standby.

Replication

Replication copies data from one PostgreSQL server (the primary) to one or more others (replicas/standbys). Physical replication copies everything byte-...

Replication lag

Replication lag is how far behind a replica is compared to the primary — measured in bytes of WAL or in seconds. A little…

Reservoir sampling

A one-pass method for taking a fixed-size random sample from a stream of unknown length, used inside PostgreSQL's ANALYZE.

Resource manager (rmgr)

A subsystem (heap, btree, xact, etc.) that knows how to write and replay its own WAL records via redo/desc callbacks; xl_rmid in each record…

Right-link (B-tree)

A B-tree page's pointer to its right sibling (btpo_next); the Lehman-Yao mechanism that lets a reader reach a freshly split page without restarting from…

Role (user / group)

In PostgreSQL a role is both a user and a group — there is no separate "user" object. A role can log in (then…

RPO (Recovery Point Objective)

The maximum data loss tolerable in a disaster; in asynchronous replication it equals the replication lag at the moment of failure, readable as a…

RTO (Recovery Time Objective)

The maximum tolerable downtime after a disaster, broken into detection, decision, promotion, and client reconnection; mostly spent outside the database itself.

Savepoint

A savepoint is a bookmark inside a transaction. If something goes wrong after it, you can roll back to the savepoint without throwing away…

Schema

A schema is a folder-like namespace inside a database that groups tables, views, and functions. Two schemas can both have a table called "orders"…

Selectivity

The fraction of rows a condition is expected to keep (0 to 1); the foundation of every PostgreSQL plan decision.

Sequence

A sequence is a special counter object that hands out increasing numbers, most often used to generate unique IDs for a table primary key…

Shared buffers

Shared buffers is PostgreSQL own in-memory cache of data pages, shared by all connections. When a query needs a page, PostgreSQL looks here first…

Slot synchronization

The PostgreSQL 17 mechanism where a slot sync worker copies failover-enabled slots from the primary onto a standby, advancing them only to safe positions.

SLRU (Simple LRU cache)

A small fixed-size LRU cache of 8KB pages (slru.c) reused for internal logs like pg_xact, pg_subtrans and pg_multixact; can become a concurrency hot spot…

Stanza

pgBackRest's configuration unit for a single PostgreSQL cluster, tying its data directory, repository, and settings under one name referenced via --stanza.

Startup cost vs total cost

The two cost numbers on every plan node: startup cost (work before the first row) and total cost (work for all rows). Under LIMIT,…

Statistics target

The knob (default 100) that sets how many MCVs and histogram buckets ANALYZE keeps and how many rows it samples.

Subtransaction overflow (pg_subtrans)

When a backend exceeds its 64-entry cache of active subtransaction ids, visibility checks fall back to the pg_subtrans SLRU, causing the subtransaction performance cliff.

Suffix truncation (pivot tuple)

Keeping only the leading columns needed to separate two pages in a B-tree split boundary key (pivot tuple); shrinks internal pages, raises fan-out, lowers…

Switchover

A planned, controlled role reversal where the primary steps down and a standby is promoted with no data loss; the safe way to do…

sync_replication_slots

The PostgreSQL 17 standby setting that starts the slot sync worker to keep failover-enabled slots synchronized, given a physical slot, hot_standby_feedback, and a dbname.

synchronized_standby_slots

A PostgreSQL 17 primary setting that makes logical walsenders wait for named failover-target standbys before sending changes, so subscribers can't overtake the future primary.

TID (ctid)

The physical address of a row version as (block, slot); exposed as the ctid system column. Indexes store TIDs and updates chain versions through…

TOAST

TOAST is how PostgreSQL stores big column values (long text, large JSON, bytea) that do not fit in a normal page. It compresses them…

Transaction

A transaction is a group of changes that must all succeed or all fail together — never half-done. You start one, do several statements,…

Transaction ID wraparound

Every change gets a transaction ID, and that counter is only about 4 billion wide before it loops back to the start. PostgreSQL must…

Tuple

A tuple is just one row of data — one record in a table, with all its column values. PostgreSQL uses the word "tuple"…

Tuple deforming

Turning a packed on-disk row back into column values by walking it left to right (heap_deform_tuple), filling values[] and isnull[]; the executor does it…

Tuple header (HeapTupleHeader)

The fixed ~23-byte header on every heap row (HeapTupleHeaderData) holding xmin/xmax, ctid, infomask flags, and t_hoff marking where column data begins.

TupleTableSlot

The lightweight holder that carries the current row between executor nodes; it can point at an on-page tuple without copying, and defers splitting a…

Utility statement

A non-planned command (CREATE, ALTER, VACUUM, SET, GRANT) that runs through ProcessUtility instead of the optimizer and executor, so it has no query plan.

VACUUM

VACUUM is the cleanup job that removes dead row versions and frees their space for reuse. Plain VACUUM does not shrink the file; it…

Visibility map

The visibility map is a tiny side-structure that marks which pages of a table contain only rows visible to everyone (and which are fully…

WAL (Write-Ahead Log)

Before PostgreSQL changes your actual data files, it first writes a short note describing the change to the write-ahead log. If the server crashes,…

WAL record (XLogRecord)

One entry in the write-ahead log describing a single change: a fixed XLogRecord header (length, xid, prev-LSN, rmgr id, CRC) plus block references and…

WAL writer (walwriter)

The background process that flushes the write-ahead log to disk on a regular cadence, so busy backends and async commits don't each have to…

WAL-before-data rule

The rule that a modified page cannot be flushed until its WAL is durable, enforced via the page's pd_lsn; the foundation that makes crash…

Watchdog (fencing)

A timer (e.g. /dev/watchdog) that reboots a node unless a healthy process pets it; on a Patroni primary it forcibly removes a wedged old…

xmin horizon (OldestXmin)

The oldest snapshot still alive in the system; PostgreSQL can only remove dead row versions older than this boundary, so a long transaction pinning…