PostgreSQL parameters

Memory each autovacuum worker may use (defaults to maintenance_work_mem).

Gives hash-based operations more memory than plain work_mem.

Whether to back shared memory with OS huge pages (reduces TLB pressure).

Memory for maintenance operations: VACUUM, CREATE INDEX, ALTER TABLE … ADD FOREIGN KEY.

PostgreSQL's own cache of table and index pages in shared memory.

Per-session cache for temporary tables.

Size of the shared-buffer ring VACUUM and ANALYZE use, limiting cache eviction.

Memory each sort, hash, and similar operation may use before spilling to disk.

How often the background writer wakes to flush dirty pages.

How many dirty pages the background writer may flush per round.

How much of the interval to spread checkpoint writes over, smoothing I/O.

Maximum time between automatic checkpoints.

A tiny pause before flushing WAL so concurrent commits can share one flush (group commit).

Soft ceiling on WAL between automatic checkpoints — bigger means fewer checkpoints.

How much WAL PostgreSQL recycles and keeps ready instead of deleting.

Shared memory buffering WAL records before they're written to disk.

Compress full-page images written to WAL, shrinking WAL volume.

Minimum WAL kept around so lagging standbys can still catch up.

How much information is written to WAL — gates replication and PITR.

How often the WAL writer flushes WAL in the background.

The planner's assumed CPU cost of processing one row.

How much detail ANALYZE collects for column statistics.

The planner's estimate of total cache available (shared_buffers + OS cache).

How many concurrent disk I/Os PostgreSQL will issue for prefetching.

Debug toggle that strongly discourages hash joins (default on).

Debug toggle that strongly discourages index scans (default on).

Debug toggle that strongly discourages nested-loop joins (default on).

Lets the planner aggregate each partition separately, then combine.

Lets the planner join matching partitions pair-by-pair instead of as whole tables.

A debug toggle that strongly discourages — not forbids — sequential scans.

How aggressively the planner merges sub-queries into the parent for join planning.

Just-in-time compilation of expressions for big analytical queries.

Minimum estimated query cost at which JIT compilation kicks in.

How many tables the planner will reorder freely when searching for a join order.

Concurrent I/O for maintenance work like VACUUM prefetch.

The planner's assumed cost of a random disk page read vs a sequential one.

The planner's baseline cost for reading one page sequentially.

Parallel workers a single maintenance op (e.g. CREATE INDEX) may use.

The cluster-wide pool of parallel workers all queries draw from.

Maximum parallel workers a single query operation may request.

The hard ceiling on all background worker processes (parallelism, replication, extensions).

Smallest index portion to scan that justifies considering a parallel index scan.

The smallest table scan size for which the planner considers going parallel.

The planner's assumed fixed cost of starting parallel workers.

The planner's per-row cost of moving a row from a worker to the leader.

The master switch for the background autovacuum daemon.

Fraction of a table that must change before autovacuum re-runs ANALYZE.

The transaction-age at which a forced anti-wraparound vacuum must run.

How many tables autovacuum can clean at the same time.

How long the autovacuum daemon sleeps between checking for work.

How long autovacuum sleeps after hitting its cost limit.

How much I/O work autovacuum does before pausing — its throttle.

Triggers vacuum on insert-heavy tables that have few dead rows.

Fraction of a table that must change (dead rows) before autovacuum kicks in.

The pause manual VACUUM takes after hitting vacuum_cost_limit (default 0 = no throttle).

The cost budget for *manual* VACUUM — also the basis for autovacuum's own limit.

How old a row must be before a vacuum will freeze it.

The table age at which a normal vacuum escalates to a full-table freeze scan.

Which network interfaces the server accepts TCP connections on.

Hard cap on concurrent client connections.

Enables two-phase commit (PREPARE TRANSACTION) and caps how many can be pending.

The algorithm used to store new role passwords — use SCRAM, not MD5.

Enables TLS for client connections.

The shell command that copies each completed WAL segment to durable storage.

Turns on WAL archiving — the basis for point-in-time recovery and some backups.

Forces a WAL switch on a timer so low-traffic systems still archive regularly.

Lets a read replica tell the primary not to vacuum rows its queries still need.

How many replication slots can exist — slots guarantee WAL retention for consumers.

Bounds how much WAL one replication slot may hold — guards against a dead consumer filling the disk.

How many simultaneous replication connections (standbys, backups) are allowed.

Names the standbys that must confirm a commit for synchronous replication.

Records the commit time of each transaction (used by conflict resolution and auditing).

Whether PostgreSQL forces data to physically reach disk — the master durability switch.

Writes a full copy of a page to WAL on its first change after a checkpoint, guarding against torn pages.

How long COMMIT waits for durability — the safe knob for trading a little durability for speed.

Computes a stable query identifier so tools and logs can group identical queries.

Logs autovacuum/autoanalyze actions that take longer than this.

Logs each checkpoint with its timing and how many buffers it wrote.

Logs each successful new client connection.

Where PostgreSQL writes log lines — plain text, CSV, JSON, syslog, or Windows event log.

Logs each client disconnection, including session duration.

Logs the duration of every completed statement (without the statement text).

The template for what metadata prefixes each log line (time, PID, user, db…).

Logs a statement that waited longer than deadlock_timeout for a lock.

Logs any statement that runs longer than this threshold — your slow-query log.

Logs statements by category — none, DDL only, data-modifying, or all.

Logs temporary files above a size — a direct signal that work_mem is too small.

Runs a dedicated process that captures stderr and rotates log files.

Extensions loaded at server start — required for pg_stat_statements, auto_explain, etc.

Counts calls and time for functions, surfaced in pg_stat_user_functions.

Measures actual time spent on disk reads/writes, shown in EXPLAIN and stats.

How long to wait on a lock before checking whether a deadlock exists.

Terminates sessions left idle inside an open transaction.

Closes sessions that sit idle (not in a transaction) for too long.

Caps how long a statement waits to acquire a lock before giving up.

Sizes the shared lock table — raise it for partitioning-heavy workloads.

Sizes the predicate-lock table used by SERIALIZABLE isolation.

Aborts any single statement that runs longer than this — a runaway-query guard.

Caps how much temporary file space one process may use before its query is aborted.