Fixes

Author: lfittl

src/backend/commands/explain.c

@@ -324,15 +324,16 @@ standard_ExplainOneQuery(Query *query, int cursorOptions,
 						 QueryEnvironment *queryEnv)
 {
 	PlannedStmt *plan;
-	QueryInstrumentation *instr = NULL;
+	QueryInstrumentation *plan_instr = NULL;
+	InstrumentOption plan_instr_opts = INSTRUMENT_TIMER;
 	MemoryContextCounters mem_counters;
 	MemoryContext planner_ctx = NULL;
 	MemoryContext saved_ctx = NULL;
 
 	if (es->buffers)
-		instr = InstrQueryAlloc(INSTRUMENT_TIMER | INSTRUMENT_BUFFERS);
-	else
-		instr = InstrQueryAlloc(INSTRUMENT_TIMER);
+		plan_instr_opts |= INSTRUMENT_BUFFERS;
+
+	plan_instr = InstrQueryAlloc(plan_instr_opts);
 
 	if (es->memory)
 	{
@@ -350,12 +351,12 @@ standard_ExplainOneQuery(Query *query, int cursorOptions,
 		saved_ctx = MemoryContextSwitchTo(planner_ctx);
 	}
 
-	InstrQueryStart(instr);
+	InstrQueryStart(plan_instr);
 
 	/* plan the query */
 	plan = pg_plan_query(query, queryString, cursorOptions, params, es);
 
-	InstrQueryStopFinalize(instr);
+	InstrQueryStopFinalize(plan_instr);
 
 	if (es->memory)
 	{
@@ -365,7 +366,7 @@ standard_ExplainOneQuery(Query *query, int cursorOptions,
 
 	/* run it (if needed) and produce output */
 	ExplainOnePlan(plan, into, es, queryString, params, queryEnv,
-				   &instr->instr.total, (es->buffers ? &instr->instr.bufusage : NULL),
+				   &plan_instr->instr.total, (es->buffers ? &plan_instr->instr.bufusage : NULL),
 				   es->memory ? &mem_counters : NULL);
 }
 

src/backend/executor/execMain.c

@@ -467,26 +467,28 @@ standard_ExecutorFinish(QueryDesc *queryDesc)
 	if (!(estate->es_top_eflags & EXEC_FLAG_SKIP_TRIGGERS))
 		AfterTriggerEndQuery(estate);
 
-	/*
-	 * Accumulate per-node and trigger statistics to their respective parent
-	 * instrumentation stacks.
-	 *
-	 * We skip this in parallel workers because their per-node stats are
-	 * reported individually via ExecParallelReportInstrumentation, and the
-	 * leader's own ExecFinalizeNodeInstrumentation handles propagation.  If
-	 * we accumulated here, the leader would double-count: worker parent nodes
-	 * would already include their children's stats, and then the leader's
-	 * accumulation would add the children again.
-	 */
-	if (queryDesc->totaltime && estate->es_instrument && !IsParallelWorker())
+	if (queryDesc->totaltime)
 	{
-		ExecFinalizeNodeInstrumentation(queryDesc->planstate);
+		/*
+		 * Accumulate per-node and trigger statistics to their respective parent
+		 * instrumentation stacks.
+		 *
+		 * We skip this in parallel workers because their per-node stats are
+		 * reported individually via ExecParallelReportInstrumentation, and the
+		 * leader's own ExecFinalizeNodeInstrumentation handles propagation.  If
+		 * we accumulated here, the leader would double-count: worker parent nodes
+		 * would already include their children's stats, and then the leader's
+		 * accumulation would add the children again.
+		 */
+		if (estate->es_instrument && !IsParallelWorker())
+		{
+			ExecFinalizeNodeInstrumentation(queryDesc->planstate);
 
-		ExecFinalizeTriggerInstrumentation(estate);
-	}
+			ExecFinalizeTriggerInstrumentation(estate);
+		}
 
-	if (queryDesc->totaltime)
 		InstrQueryStopFinalize(queryDesc->totaltime);
+	}
 
 	MemoryContextSwitchTo(oldcontext);
 

src/backend/executor/instrument.c

@@ -21,13 +21,20 @@
 
 WalUsage	pgWalUsage;
 Instrumentation instr_top;
-InstrStackState instr_stack = {0, 0, NULL, &instr_top};
+InstrStackState instr_stack = {
+	.stack_space = 0,
+	.stack_size = 0,
+	.entries = NULL,
+	.current = &instr_top,
+};
 
 void
 InstrStackGrow(void)
 {
 	int			space = instr_stack.stack_space;
 
+	Assert(instr_stack.stack_size >= instr_stack.stack_space);
+
 	if (instr_stack.entries == NULL)
 	{
 		space = 10;				/* Allocate sufficient initial space for
@@ -283,7 +290,10 @@ InstrQueryStopFinalize(QueryInstrumentation *qinstr)
 	InstrStopFinalize(&qinstr->instr);
 
 	if (!qinstr->instr.need_stack)
+	{
+		Assert(qinstr->owner == NULL);
 		return;
+	}
 
 	Assert(qinstr->owner != NULL);
 	ResourceOwnerForgetInstrumentation(qinstr->owner, qinstr);