runtime_explain_13.0.patch

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 20708db9f12..866948bd0c1 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -955,14 +955,36 @@ report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es)
		char	   *relname;
		char	   *conname = NULL;

+		instr_time	starttimespan;
+		double		total;
+		double		ntuples;
+		double		ncalls;
+
+		if (!es->runtime)
+		{
		/* Must clean up instrumentation state */
		InstrEndLoop(instr);
+		}
+
+		/* Collect statistic variables */
+		if (!INSTR_TIME_IS_ZERO(instr->starttime))
+		{
+			INSTR_TIME_SET_CURRENT(starttimespan);
+			INSTR_TIME_SUBTRACT(starttimespan, instr->starttime);
+		}
+		else
+			INSTR_TIME_SET_ZERO(starttimespan);
+
+		total = instr->total + INSTR_TIME_GET_DOUBLE(instr->counter)
+							 + INSTR_TIME_GET_DOUBLE(starttimespan);
+		ntuples = instr->ntuples + instr->tuplecount;
+		ncalls = ntuples + !INSTR_TIME_IS_ZERO(starttimespan);

		/*
		 * We ignore triggers that were never invoked; they likely aren't
		 * relevant to the current query type.
		 */
-		if (instr->ntuples == 0)
+		if (ncalls == 0)
			continue;

		ExplainOpenGroup("Trigger", NULL, true, es);
@@ -988,9 +1010,9 @@ report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es)
				appendStringInfo(es->str, " on %s", relname);
			if (es->timing)
				appendStringInfo(es->str, ": time=%.3f calls=%.0f\n",
-								 1000.0 * instr->total, instr->ntuples);
+								 1000.0 * total, ncalls);
			else
-				appendStringInfo(es->str, ": calls=%.0f\n", instr->ntuples);
+				appendStringInfo(es->str, ": calls=%.0f\n", ncalls);
		}
		else
		{
@@ -999,9 +1021,8 @@ report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es)
				ExplainPropertyText("Constraint Name", conname, es);
			ExplainPropertyText("Relation", relname, es);
			if (es->timing)
-				ExplainPropertyFloat("Time", "ms", 1000.0 * instr->total, 3,
-									 es);
-			ExplainPropertyFloat("Calls", NULL, instr->ntuples, 0, es);
+				ExplainPropertyFloat("Time", "ms", 1000.0 * total, 3, es);
+			ExplainPropertyFloat("Calls", NULL, ncalls, 0, es);
		}

		if (conname)
@@ -1560,8 +1581,11 @@ ExplainNode(PlanState *planstate, List *ancestors,
	 * instrumentation results the user didn't ask for.  But we do the
	 * InstrEndLoop call anyway, if possible, to reduce the number of cases
	 * auto_explain has to contend with.
+	 *
+	 * If flag es->stateinfo is set, i.e. when printing the current execution
+	 * state, this step of cleaning up is missed.
	 */
-	if (planstate->instrument)
+	if (planstate->instrument && !es->runtime)
		InstrEndLoop(planstate->instrument);

	if (es->analyze &&
@@ -1596,7 +1620,7 @@ ExplainNode(PlanState *planstate, List *ancestors,
			ExplainPropertyFloat("Actual Loops", NULL, nloops, 0, es);
		}
	}
-	else if (es->analyze)
+	else if (es->analyze && !es->runtime)
	{
		if (es->format == EXPLAIN_FORMAT_TEXT)
			appendStringInfoString(es->str, " (never executed)");
@@ -1612,6 +1636,75 @@ ExplainNode(PlanState *planstate, List *ancestors,
		}
	}

+	/*
+	 * Print the progress of node execution at current loop.
+	 */
+	if (planstate->instrument && es->analyze && es->runtime)
+	{
+		instr_time	starttimespan;
+		double	startup_sec;
+		double	total_sec;
+		double	rows;
+		double	loop_num;
+		bool 	finished;
+
+		if (!INSTR_TIME_IS_ZERO(planstate->instrument->starttime))
+		{
+			INSTR_TIME_SET_CURRENT(starttimespan);
+			INSTR_TIME_SUBTRACT(starttimespan, planstate->instrument->starttime);
+		}
+		else
+			INSTR_TIME_SET_ZERO(starttimespan);
+		startup_sec = 1000.0 * planstate->instrument->firsttuple;
+		total_sec = 1000.0 * (INSTR_TIME_GET_DOUBLE(planstate->instrument->counter)
+							+ INSTR_TIME_GET_DOUBLE(starttimespan));
+		rows = planstate->instrument->tuplecount;
+		loop_num = planstate->instrument->nloops + 1;
+
+		finished = planstate->instrument->nloops > 0
+				&& !planstate->instrument->running
+				&& INSTR_TIME_IS_ZERO(starttimespan);
+
+		if (!finished)
+		{
+			ExplainOpenGroup("Current loop", "Current loop", true, es);
+			if (es->format == EXPLAIN_FORMAT_TEXT)
+			{
+				if (es->timing)
+				{
+					if (planstate->instrument->running)
+						appendStringInfo(es->str,
+								" (Current loop: actual time=%.3f..%.3f rows=%.0f, loop number=%.0f)",
+								startup_sec, total_sec, rows, loop_num);
+					else
+						appendStringInfo(es->str,
+								" (Current loop: running time=%.3f actual rows=0, loop number=%.0f)",
+								total_sec, loop_num);
+				}
+				else
+					appendStringInfo(es->str,
+							" (Current loop: actual rows=%.0f, loop number=%.0f)",
+							rows, loop_num);
+			}
+			else
+			{
+				ExplainPropertyFloat("Actual Loop Number", NULL, loop_num, 0, es);
+				if (es->timing)
+				{
+					if (planstate->instrument->running)
+					{
+						ExplainPropertyFloat("Actual Startup Time", NULL, startup_sec, 3, es);
+						ExplainPropertyFloat("Actual Total Time", NULL, total_sec, 3, es);
+					}
+					else
+						ExplainPropertyFloat("Running Time", NULL, total_sec, 3, es);
+				}
+				ExplainPropertyFloat("Actual Rows", NULL, rows, 0, es);
+			}
+			ExplainCloseGroup("Current loop", "Current loop", true, es);
+		}
+	}
+
	/* in text format, first line ends here */
	if (es->format == EXPLAIN_FORMAT_TEXT)
		appendStringInfoChar(es->str, '\n');
@@ -1990,6 +2083,9 @@ ExplainNode(PlanState *planstate, List *ancestors,

	/* Prepare per-worker buffer/WAL usage */
	if (es->workers_state && (es->buffers || es->wal) && es->verbose)
+	/* Show worker detail after query execution */
+	if (es->analyze && es->verbose && planstate->worker_instrument
+		&& !es->runtime)
	{
		WorkerInstrumentation *w = planstate->worker_instrument;

@@ -2960,6 +3056,11 @@ show_hash_info(HashState *hashstate, ExplainState *es)
		memcpy(&hinstrument, hashstate->hinstrument,
			   sizeof(HashInstrumentation));

+	if (hashstate->hashtable)
+	{
+		ExecHashAccumInstrumentation(&hinstrument, hashstate->hashtable);
+	}
+
	/*
	 * Merge results from workers.  In the parallel-oblivious case, the
	 * results from all participants should be identical, except where
@@ -3196,20 +3297,16 @@ show_instrumentation_count(const char *qlabel, int which,
	if (!es->analyze || !planstate->instrument)
		return;

+	nloops = planstate->instrument->nloops;
	if (which == 2)
-		nfiltered = planstate->instrument->nfiltered2;
+		nfiltered = ((nloops > 0) ? planstate->instrument->nfiltered2 / nloops : 0);
	else
-		nfiltered = planstate->instrument->nfiltered1;
+		nfiltered = ((nloops > 0) ? planstate->instrument->nfiltered1 / nloops : 0);
	nloops = planstate->instrument->nloops;

	/* In text mode, suppress zero counts; they're not interesting enough */
	if (nfiltered > 0 || es->format != EXPLAIN_FORMAT_TEXT)
-	{
-		if (nloops > 0)
-			ExplainPropertyFloat(qlabel, NULL, nfiltered / nloops, 0, es);
-		else
-			ExplainPropertyFloat(qlabel, NULL, 0.0, 0, es);
-	}
+		ExplainPropertyFloat(qlabel, NULL, nfiltered, 0, es);
 }

 /*
@@ -3781,15 +3878,27 @@ show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
			double		insert_path;
			double		other_path;

-			InstrEndLoop(mtstate->mt_plans[0]->instrument);
+			if (!es->runtime)
+				InstrEndLoop(mtstate->mt_plans[0]->instrument);

			/* count the number of source rows */
-			total = mtstate->mt_plans[0]->instrument->ntuples;
 			other_path = mtstate->ps.instrument->ntuples2;
-			insert_path = total - other_path;

+			/*
+			 * Insert occurs after extracting row from subplan and in runtime mode
+			 * we can appear between these two operations - situation when
+			 * total > insert_path + other_path. Therefore we don't know exactly
+			 * whether last row from subplan is inserted.
+			 * We don't print inserted tuples in runtime mode in order to not print
+			 * inconsistent data
+			 */
+			if (!es->runtime)
+			{
+				total = mtstate->mt_plans[0]->instrument->ntuples;
+				insert_path = total - other_path;
+				ExplainPropertyFloat("Tuples Inserted", NULL, insert_path, 0, es);
+			}
+
-			ExplainPropertyFloat("Tuples Inserted", NULL,
-								 insert_path, 0, es);
			ExplainPropertyFloat("Conflicting Tuples", NULL,
								 other_path, 0, es);
		}
diff --git a/src/include/commands/explain.h b/src/include/commands/explain.h
index ba661d32a63..ee49febfce5 100644
--- a/src/include/commands/explain.h
+++ b/src/include/commands/explain.h
@@ -47,6 +47,8 @@ typedef struct ExplainState
	bool		summary;		/* print total planning and execution timing */
	bool		settings;		/* print modified settings */
	ExplainFormat format;		/* output format */
+	bool		runtime;		/* print intermediate state of query execution,
+								   not after completion */
	/* state for output formatting --- not reset for each new plan tree */
	int			indent;			/* current indentation level */
	List	   *grouping_stack; /* format-specific grouping state */
--
2.25.1