Product1 distinct publisher2 min readUpdated
EXPLAIN prints planning and execution time side by side. In a Timescale walkthrough of a 500-partition table, the planner touched 21 times more pages than the query did.
The Product Desk · Product desk
Compiled by The Product DeskSomething wrong?How this is made
The per-partition cost is bookkeeping, not arithmetic. Before the planner can rule a partition out, it takes a lock on the relation, loads its relcache entry and builds planner state for it [10]. That happens for every partition in the table, so the bill tracks how many partitions exist rather than how many survive pruning [10].
Do the division nobody in the plan output does for you. Twenty thousand planning blocks across 500 partitions is about 40 blocks each, roughly 321 KB of metadata touched to open and price a chunk that is then thrown away [7]. The scan that actually answered the question read 898 heap blocks [20], something in the order of 7 MB [4]. And planning was 89.7 percent of the 70.1 ms the statement spent end to end [6].
The awkward part is that the plan was good. Pruning left a single partition, the bitmap scan hit cache on every block, and the row estimate came in within three percent [9]. A reviewer walking the plan tree from the top finds nothing to fix in it, which is precisely the state in which someone reaches for an index [18]. Timescale's own framing is that this ends in weeks spent optimizing the phase that was never slow [19].
None of this makes the optimizer overhead waste. On a warehouse query with eight joins, the same post notes, the optimization pass pays for itself many times over [15], and execution time still scales with heap pages read, hashing, sorting and aggregating rather than with how many plans were weighed [16]. Partition count is what breaks the trade, because the setup is charged whether or not pruning ends up needing it [10].
Treat the absolute milliseconds with suspicion. This is one vendor's synthetic device_metrics table on PostgreSQL 16.13, 2.1 billion rows in 500 daily chunks, with work_mem at 4 MB and shared_buffers at 256 MB [4]. Those settings are small enough that a real fleet will produce different figures. The ratio is the portable part, and the source's instruction is cheap either way: read the last two lines before the tree [21], then read the two Buffers lines against each other, because a planner touching more pages than the scan has already named the phase worth working on [6].
Follow any of these and your For You feed starts watching them — no settings page required.
Ranked by verification strength, evidence, and original report placement.
Every EXPLAIN ANALYZE prints two numbers at the bottom: Planning Time, how long Postgres spent deciding how to answer the query, and Execution Time, how long it spent answering it.
According to the Timescale post, most engineers read only one of the two numbers printed at the bottom of an EXPLAIN ANALYZE plan.
The plans shown are real output from PostgreSQL 16.13 against a device_metrics table partitioned into 500 daily chunks named device_metrics_YYYYMMDD, holding 2.1 billion rows, with work_mem at 4 MB and shared_buffers at 256 MB.
The BUFFERS output showed planning touching shared hit=20063 blocks while the query execution touched shared hit=932 blocks.
The post states the planner read 21 times more pages than the query did, to open and price 500 partitions before discarding 499.
The plan reported Subplans Removed: 499, meaning pruning left one partition of 500.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Concrete plan output plus documented mechanism, from one vendor source
The story rests on specific, internally consistent artifacts: a full plan with Planning Time 62.913 ms, Execution Time 7.202 ms, Planning Buffers shared hit=20063 versus 932, Subplans Removed: 499, Heap Blocks exact=898, plus a stated environment (PostgreSQL 16.13, 500 daily partitions, 2.1 billion rows, work_mem 4 MB, shared_buffers 256 MB) and a mirror-image plan showing the opposite diagnosis. The mechanism is independently grounded by the quoted PostgreSQL documentation on partition count driving planning time and memory. Evidence stops short of strong because all of it comes from one publisher, output is hedged as illustrative rather than a repeated measurement, the memory settings are small for the stated data volume, and the prescribed planning-side fixes are never measured — no before/after showing planning time actually falling.
No adoption signal in supplied sources
The single source is a technique walkthrough with illustrative plan output. It contains no releases, deployments, usage disclosures, customer counts, benchmark suites or third-party reports of anyone applying this diagnostic or reducing partition counts as a result, so adoption cannot be scored without inference.
Mechanism sound; magnitudes generalized from one small-memory demo
Slightly overstated rather than sensationalized. The underlying mechanism is real and documented upstream, and the plan output is specific and self-consistent. The overstatement is in generalization: the intro presents 'planning takes nine times longer than running it' on a 500-partition table as a general condition, when it is one query on one instance configured with 256 MB shared_buffers and 4 MB work_mem, with output hedged as 'you may see'. The claim that adding an index makes things worse is argued from mechanism rather than measured, and no planning-side remedy is demonstrated to reduce the 62.9 ms. No cross-publisher exaggeration exists to inflate the gap further, since the cluster has a single source.
Vendor content marketing aligned with its own partitioning product
The source is a commercial blog (timescale.com, published at tigerdata.com) from a company whose business is partitioned time-series Postgres. The post's conclusion — that partition count imposes a hidden planning tax and that adding indexes is the wrong reflex — sits directly adjacent to that commercial interest, and no disclosure of the alignment appears in the text. The score is moderate-high rather than severe because the claims are verifiable from plan output any reader can reproduce, the post cites upstream PostgreSQL documentation instead of a product, and it never names or pitches a product as the remedy.
Reproducible mechanism, single unverified vendor measurement
Confidence is moderate. The mechanism, the diagnostic procedure and the direction of the effect are well supported and independently documented upstream, and the derived arithmetic follows directly from numbers printed in the plan. But there is one publisher, one hedged measurement, no replication, no adoption evidence, an unmeasured remediation path and an undisclosed vendor interest — enough uncertainty that the specific magnitudes (8.7x time, ~21.5x blocks, ~157 MB of planning traffic) should be treated as configuration-specific rather than characteristic.
build
Notion's agent stack is live, not slideware, and it only changes one of your decisions1 distinct publisher
build
The 680 MB database that was really a 17 GB disk: self-hosted support platforms fail at month six1 distinct publisher
build
Your "Index Only Scan" Did 2,847 Heap Fetches: Covering Indexes Are a Vacuum Problem1 distinct publisher
build
Once the question needs a cube, you own the parser1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
1 article · August 21, 2026