runtime_explain_14.0.patch

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 10644dfac4..7106ed4257 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -984,14 +984,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);
@@ -1017,9 +1039,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
 		{
@@ -1028,9 +1050,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)
@@ -1600,8 +1621,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 &&
@@ -1636,7 +1660,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)");
@@ -1652,6 +1676,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');
@@ -2051,6 +2144,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;
 
@@ -3015,6 +3111,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
@@ -3392,20 +3493,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);
 }
 
 /*
@@ -3977,15 +4074,27 @@ show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
 			double		insert_path;
 			double		other_path;
 
-			InstrEndLoop(outerPlanState(mtstate)->instrument);
+			if (!es->runtime)
+				InstrEndLoop(outerPlanState(mtstate)->instrument);
 
 			/* count the number of source rows */
-			total = outerPlanState(mtstate)->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 = outerPlanState(mtstate)->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 e94d9e49cf..6a157b8bc0 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