void plot_history::new_page() {
if (!_replaying) {
auto previous_plot = get_active();
if (previous_plot != nullptr) {
pGEDevDesc ge_dev_desc = Rf_desc2GEDesc(_device_desc);
util::protected_sexp snapshot(ge_dev_desc->savedSnapshot);
if (previous_plot->has_pending_render()) {
previous_plot->set_snapshot(snapshot);
previous_plot->render(false);
}
}
// Create a plot object for this new page
append(std::make_unique<plot>(_device_desc));
}
}
/*
* ContinuousQueryWorkerStartup
*
* Launches a CQ worker, which continuously generates partial query results to send
* back to the combiner process.
*/
void
ContinuousQueryWorkerRun(Portal portal, ContinuousViewState *state, QueryDesc *queryDesc, ResourceOwner owner)
{
EState *estate = NULL;
DestReceiver *dest;
CmdType operation;
MemoryContext oldcontext;
int timeoutms = state->maxwaitms;
MemoryContext runcontext;
CQProcEntry *entry = GetCQProcEntry(MyCQId);
ResourceOwner cqowner = ResourceOwnerCreate(NULL, "CQResourceOwner");
bool savereadonly = XactReadOnly;
cq_stat_initialize(state->viewid, MyProcPid);
dest = CreateDestReceiver(DestCombiner);
SetCombinerDestReceiverParams(dest, MyCQId);
/* workers only need read-only transactions */
XactReadOnly = true;
runcontext = AllocSetContextCreate(TopMemoryContext, "CQRunContext",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
elog(LOG, "\"%s\" worker %d running", queryDesc->plannedstmt->cq_target->relname, MyProcPid);
MarkWorkerAsRunning(MyCQId, MyWorkerId);
pgstat_report_activity(STATE_RUNNING, queryDesc->sourceText);
TupleBufferInitLatch(WorkerTupleBuffer, MyCQId, MyWorkerId, &MyProc->procLatch);
oldcontext = MemoryContextSwitchTo(runcontext);
retry:
PG_TRY();
{
bool xact_commit = true;
TimestampTz last_process = GetCurrentTimestamp();
TimestampTz last_commit = GetCurrentTimestamp();
start_executor(queryDesc, runcontext, cqowner);
CurrentResourceOwner = cqowner;
estate = queryDesc->estate;
operation = queryDesc->operation;
/*
* Initialize context that lives for the duration of a single iteration
* of the main worker loop
*/
CQExecutionContext = AllocSetContextCreate(estate->es_query_cxt, "CQExecutionContext",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
estate->es_lastoid = InvalidOid;
/*
* Startup combiner receiver
*/
(*dest->rStartup) (dest, operation, queryDesc->tupDesc);
for (;;)
{
if (!TupleBufferHasUnreadSlots())
{
if (TimestampDifferenceExceeds(last_process, GetCurrentTimestamp(), state->emptysleepms))
{
/* force stats flush */
cq_stat_report(true);
pgstat_report_activity(STATE_IDLE, queryDesc->sourceText);
TupleBufferWait(WorkerTupleBuffer, MyCQId, MyWorkerId);
pgstat_report_activity(STATE_RUNNING, queryDesc->sourceText);
}
else
pg_usleep(Min(WAIT_SLEEP_MS, state->emptysleepms) * 1000);
}
TupleBufferResetNotify(WorkerTupleBuffer, MyCQId, MyWorkerId);
if (xact_commit)
StartTransactionCommand();
set_snapshot(estate, cqowner);
CurrentResourceOwner = cqowner;
MemoryContextSwitchTo(estate->es_query_cxt);
estate->es_processed = 0;
estate->es_filtered = 0;
/*
* Run plan on a microbatch
*/
ExecutePlan(estate, queryDesc->planstate, operation,
true, 0, timeoutms, ForwardScanDirection, dest);
IncrementCQExecutions(1);
TupleBufferClearPinnedSlots();
if (state->long_xact)
{
if (TimestampDifferenceExceeds(last_commit, GetCurrentTimestamp(), LONG_RUNNING_XACT_DURATION))
xact_commit = true;
else
xact_commit = false;
}
unset_snapshot(estate, cqowner);
if (xact_commit)
{
CommitTransactionCommand();
last_commit = GetCurrentTimestamp();
}
MemoryContextResetAndDeleteChildren(CQExecutionContext);
MemoryContextSwitchTo(runcontext);
CurrentResourceOwner = cqowner;
if (estate->es_processed || estate->es_filtered)
{
/*
* If the CV query is such that the select does not return any tuples
* ex: select id where id=99; and id=99 does not exist, then this reset
* will fail. What will happen is that the worker will block at the latch for every
* allocated slot, TILL a cv returns a non-zero tuple, at which point
* the worker will resume a simple sleep for the threshold time.
*/
last_process = GetCurrentTimestamp();
/*
* Send stats to the collector
*/
cq_stat_report(false);
}
/* Has the CQ been deactivated? */
if (!entry->active)
{
if (ActiveSnapshotSet())
unset_snapshot(estate, cqowner);
if (IsTransactionState())
CommitTransactionCommand();
break;
}
}
CurrentResourceOwner = cqowner;
/*
* The cleanup functions below expect these things to be registered
*/
RegisterSnapshotOnOwner(estate->es_snapshot, cqowner);
RegisterSnapshotOnOwner(queryDesc->snapshot, cqowner);
RegisterSnapshotOnOwner(queryDesc->crosscheck_snapshot, cqowner);
/* cleanup */
ExecutorFinish(queryDesc);
ExecutorEnd(queryDesc);
FreeQueryDesc(queryDesc);
}
PG_CATCH();
{
EmitErrorReport();
FlushErrorState();
/* Since the worker is read-only, we can simply commit the transaction. */
if (ActiveSnapshotSet())
unset_snapshot(estate, cqowner);
if (IsTransactionState())
CommitTransactionCommand();
TupleBufferUnpinAllPinnedSlots();
TupleBufferClearReaders();
/* This resets the es_query_ctx and in turn the CQExecutionContext */
MemoryContextResetAndDeleteChildren(runcontext);
IncrementCQErrors(1);
if (continuous_query_crash_recovery)
goto retry;
}
PG_END_TRY();
(*dest->rShutdown) (dest);
MemoryContextSwitchTo(oldcontext);
MemoryContextDelete(runcontext);
XactReadOnly = savereadonly;
/*
* Remove proc-level stats
*/
cq_stat_report(true);
cq_stat_send_purge(state->viewid, MyProcPid, CQ_STAT_WORKER);
CurrentResourceOwner = owner;
}
