opensourcemirror
/
postgresql
mirror of git://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Store tuples for EvalPlanQual in slots, rather than as HeapTuples. 

For the upcoming pluggable table access methods it's quite
inconvenient to store tuples as HeapTuples, as that'd require
converting tuples from a their native format into HeapTuples. Instead
use slots to manage epq tuples.

To fit into that scheme, change the foreign data wrapper callback
RefetchForeignRow, to store the tuple in a slot. Insist on using the
caller provided slot, so it conveniently can be stored in the
corresponding EPQ slot.  As there is no in core user of
RefetchForeignRow, that change was done blindly, but we plan to test
that soon.

To avoid duplicating that work for row locks, move row locks to just
directly use the EPQ slots - it previously temporarily stored tuples
in LockRowsState.lr_curtuples, but that doesn't seem beneficial, given
we'd possibly end up with a significant number of additional slots.

The behaviour of es_epqTupleSet[rti -1] is now checked by
es_epqTupleSlot[rti -1] != NULL, as that is distinguishable from a
slot containing an empty tuple.

Author: Andres Freund, Haribabu Kommi, Ashutosh Bapat
Discussion: https://postgr.es/m/20180703070645.wchpu5muyto5n647@alap3.anarazel.de
This commit is contained in:
Andres Freund 2019-03-01 10:37:57 -08:00
parent 6cbdbd9e8d
commit ad0bda5d24
13 changed files with 189 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
doc/src/sgml/fdwhandler.sgml
View File

@ -992,29 +992,31 @@ GetForeignRowMarkType(RangeTblEntry *rte,
<para> <para>
<programlisting> <programlisting>
HeapTuple void
RefetchForeignRow(EState *estate, RefetchForeignRow(EState *estate,
ExecRowMark *erm, ExecRowMark *erm,
Datum rowid, Datum rowid,
TupleTableSlot *slot,
bool *updated); bool *updated);
</programlisting> </programlisting>
Re-fetch one tuple from the foreign table, after locking it if required. Re-fetch one tuple slot from the foreign table, after locking it if required.
<literal>estate</literal> is global execution state for the query. <literal>estate</literal> is global execution state for the query.
<literal>erm</literal> is the <structname>ExecRowMark</structname> struct describing <literal>erm</literal> is the <structname>ExecRowMark</structname> struct describing
the target foreign table and the row lock type (if any) to acquire. the target foreign table and the row lock type (if any) to acquire.
<literal>rowid</literal> identifies the tuple to be fetched. <literal>rowid</literal> identifies the tuple to be fetched.
<literal>updated</literal> is an output parameter. <literal>slot</literal> contains nothing useful upon call, but can be used to
hold the returned tuple. <literal>updated</literal> is an output parameter.
</para> </para>
<para> <para>
This function should return a palloc'ed copy of the fetched tuple, This function should store the tuple into the provided, or clear it if if
or <literal>NULL</literal> if the row lock couldn't be obtained. The row lock the row lock couldn't be obtained. The row lock type to acquire is
type to acquire is defined by <literal>erm-&gt;markType</literal>, which is the defined by <literal>erm-&gt;markType</literal>, which is the value
value previously returned by <function>GetForeignRowMarkType</function>. previously returned by <function>GetForeignRowMarkType</function>.
(<literal>ROW_MARK_REFERENCE</literal> means to just re-fetch the tuple without (<literal>ROW_MARK_REFERENCE</literal> means to just re-fetch the tuple
acquiring any lock, and <literal>ROW_MARK_COPY</literal> will never be seen by without acquiring any lock, and <literal>ROW_MARK_COPY</literal> will
this routine.) never be seen by this routine.)
</para> </para>
<para> <para>
@ -1026,7 +1028,7 @@ RefetchForeignRow(EState *estate,
<para> <para>
Note that by default, failure to acquire a row lock should result in Note that by default, failure to acquire a row lock should result in
raising an error; a <literal>NULL</literal> return is only appropriate if raising an error; returning with an empty slot is only appropriate if
the <literal>SKIP LOCKED</literal> option is specified the <literal>SKIP LOCKED</literal> option is specified
by <literal>erm-&gt;waitPolicy</literal>. by <literal>erm-&gt;waitPolicy</literal>.
</para> </para>

185
src/backend/executor/execMain.c
View File

@ -977,8 +977,7 @@ InitPlan(QueryDesc *queryDesc, int eflags)
estate->es_tupleTable = NIL; estate->es_tupleTable = NIL;
/* mark EvalPlanQual not active */ /* mark EvalPlanQual not active */
estate->es_epqTuple = NULL; estate->es_epqTupleSlot = NULL;
estate->es_epqTupleSet = NULL;
estate->es_epqScanDone = NULL; estate->es_epqScanDone = NULL;
/* /*
@ -2441,35 +2440,29 @@ EvalPlanQual(EState *estate, EPQState *epqstate,
ItemPointer tid, TransactionId priorXmax) ItemPointer tid, TransactionId priorXmax)
{ {
TupleTableSlot *slot; TupleTableSlot *slot;
HeapTuple copyTuple; TupleTableSlot *testslot;
Assert(rti > 0); Assert(rti > 0);
/*
* Get and lock the updated version of the row; if fail, return NULL.
*/
copyTuple = EvalPlanQualFetch(estate, relation, lockmode, LockWaitBlock,
tid, priorXmax);
if (copyTuple == NULL)
return NULL;
/*
* For UPDATE/DELETE we have to return tid of actual row we're executing
* PQ for.
*/
*tid = copyTuple->t_self;
/* /*
* Need to run a recheck subquery. Initialize or reinitialize EPQ state. * Need to run a recheck subquery. Initialize or reinitialize EPQ state.
*/ */
EvalPlanQualBegin(epqstate, estate); EvalPlanQualBegin(epqstate, estate);
/* /*
* Free old test tuple, if any, and store new tuple where relation's scan * Get and lock the updated version of the row; if fail, return NULL.
* node will see it
*/ */
EvalPlanQualSetTuple(epqstate, rti, copyTuple); testslot = EvalPlanQualSlot(epqstate, relation, rti);
if (!EvalPlanQualFetch(estate, relation, lockmode, LockWaitBlock,
tid, priorXmax,
testslot))
return NULL;
/*
* For UPDATE/DELETE we have to return tid of actual row we're executing
* PQ for.
*/
*tid = testslot->tts_tid;
/* /*
* Fetch any non-locked source rows * Fetch any non-locked source rows
@ -2496,7 +2489,7 @@ EvalPlanQual(EState *estate, EPQState *epqstate,
* re-used to test a tuple for a different relation. (Not clear that can * re-used to test a tuple for a different relation. (Not clear that can
* really happen, but let's be safe.) * really happen, but let's be safe.)
*/ */
EvalPlanQualSetTuple(epqstate, rti, NULL); ExecClearTuple(testslot);
return slot; return slot;
} }
@ -2510,21 +2503,22 @@ EvalPlanQual(EState *estate, EPQState *epqstate,
* wait_policy - requested lock wait policy * wait_policy - requested lock wait policy
* *tid - t_ctid from the outdated tuple (ie, next updated version) * *tid - t_ctid from the outdated tuple (ie, next updated version)
* priorXmax - t_xmax from the outdated tuple * priorXmax - t_xmax from the outdated tuple
* slot - slot to store newest tuple version
* *
* Returns a palloc'd copy of the newest tuple version, or NULL if we find * Returns true, with slot containing the newest tuple version, or false if we
* that there is no newest version (ie, the row was deleted not updated). * find that there is no newest version (ie, the row was deleted not updated).
* We also return NULL if the tuple is locked and the wait policy is to skip * We also return false if the tuple is locked and the wait policy is to skip
* such tuples. * such tuples.
* *
* If successful, we have locked the newest tuple version, so caller does not * If successful, we have locked the newest tuple version, so caller does not
* need to worry about it changing anymore. * need to worry about it changing anymore.
*/ */
HeapTuple bool
EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode, EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
LockWaitPolicy wait_policy, LockWaitPolicy wait_policy,
ItemPointer tid, TransactionId priorXmax) ItemPointer tid, TransactionId priorXmax,
TupleTableSlot *slot)
{ {
HeapTuple copyTuple = NULL;
HeapTupleData tuple; HeapTupleData tuple;
SnapshotData SnapshotDirty; SnapshotData SnapshotDirty;
@ -2557,7 +2551,7 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
priorXmax)) priorXmax))
{ {
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
return NULL; return false;
} }
/* otherwise xmin should not be dirty... */ /* otherwise xmin should not be dirty... */
@ -2580,7 +2574,7 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
break; break;
case LockWaitSkip: case LockWaitSkip:
if (!ConditionalXactLockTableWait(SnapshotDirty.xmax)) if (!ConditionalXactLockTableWait(SnapshotDirty.xmax))
return NULL; /* skip instead of waiting */ return false; /* skip instead of waiting */
break; break;
case LockWaitError: case LockWaitError:
if (!ConditionalXactLockTableWait(SnapshotDirty.xmax)) if (!ConditionalXactLockTableWait(SnapshotDirty.xmax))
@ -2608,7 +2602,7 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
HeapTupleHeaderGetCmin(tuple.t_data) >= estate->es_output_cid) HeapTupleHeaderGetCmin(tuple.t_data) >= estate->es_output_cid)
{ {
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
return NULL; return false;
} }
/* /*
@ -2640,7 +2634,7 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
* now, treat the tuple as deleted and do not process. * now, treat the tuple as deleted and do not process.
*/ */
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
return NULL; return false;
case HeapTupleMayBeUpdated: case HeapTupleMayBeUpdated:
/* successfully locked */ /* successfully locked */
@ -2668,11 +2662,11 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
continue; continue;
} }
/* tuple was deleted, so give up */ /* tuple was deleted, so give up */
return NULL; return false;
case HeapTupleWouldBlock: case HeapTupleWouldBlock:
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
return NULL; return false;
case HeapTupleInvisible: case HeapTupleInvisible:
elog(ERROR, "attempted to lock invisible tuple"); elog(ERROR, "attempted to lock invisible tuple");
@ -2682,14 +2676,14 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
elog(ERROR, "unrecognized heap_lock_tuple status: %u", elog(ERROR, "unrecognized heap_lock_tuple status: %u",
test); test);
return NULL; /* keep compiler quiet */ return false; /* keep compiler quiet */
} }
/* /*
* We got tuple - now copy it for use by recheck query. * We got tuple - store it for use by the recheck query.
*/ */
copyTuple = heap_copytuple(&tuple); ExecStorePinnedBufferHeapTuple(&tuple, slot, buffer);
ReleaseBuffer(buffer); ExecMaterializeSlot(slot);
break; break;
} }
@ -2700,7 +2694,7 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
if (tuple.t_data == NULL) if (tuple.t_data == NULL)
{ {
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
return NULL; return false;
} }
/* /*
@ -2710,7 +2704,7 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
priorXmax)) priorXmax))
{ {
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
return NULL; return false;
} }
/* /*
@ -2737,7 +2731,7 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
{ {
/* deleted, so forget about it */ /* deleted, so forget about it */
ReleaseBuffer(buffer); ReleaseBuffer(buffer);
return NULL; return false;
} }
/* updated, so look at the updated row */ /* updated, so look at the updated row */
@ -2748,10 +2742,8 @@ EvalPlanQualFetch(EState *estate, Relation relation, LockTupleMode lockmode,
/* loop back to fetch next in chain */ /* loop back to fetch next in chain */
} }
/* /* signal success */
* Return the copied tuple return true;
*/
return copyTuple;
} }
/* /*
@ -2792,38 +2784,36 @@ EvalPlanQualSetPlan(EPQState *epqstate, Plan *subplan, List *auxrowmarks)
} }
/* /*
* Install one test tuple into EPQ state, or clear test tuple if tuple == NULL * Return, and create if necessary, a slot for an EPQ test tuple.
*
* NB: passed tuple must be palloc'd; it may get freed later
*/ */
void TupleTableSlot *
EvalPlanQualSetTuple(EPQState *epqstate, Index rti, HeapTuple tuple) EvalPlanQualSlot(EPQState *epqstate,
Relation relation, Index rti)
{ {
EState *estate = epqstate->estate; TupleTableSlot **slot;
Assert(rti > 0); Assert(rti > 0 && rti <= epqstate->estate->es_range_table_size);
slot = &epqstate->estate->es_epqTupleSlot[rti - 1];
/* if (*slot == NULL)
* free old test tuple, if any, and store new tuple where relation's scan {
* node will see it MemoryContext oldcontext;
*/
if (estate->es_epqTuple[rti - 1] != NULL)
heap_freetuple(estate->es_epqTuple[rti - 1]);
estate->es_epqTuple[rti - 1] = tuple;
estate->es_epqTupleSet[rti - 1] = true;
}
/* oldcontext = MemoryContextSwitchTo(epqstate->estate->es_query_cxt);
* Fetch back the current test tuple (if any) for the specified RTI
*/
HeapTuple
EvalPlanQualGetTuple(EPQState *epqstate, Index rti)
{
EState *estate = epqstate->estate;
Assert(rti > 0); if (relation)
*slot = ExecAllocTableSlot(&epqstate->estate->es_tupleTable,
RelationGetDescr(relation),
&TTSOpsBufferHeapTuple);
else
*slot = ExecAllocTableSlot(&epqstate->estate->es_tupleTable,
epqstate->origslot->tts_tupleDescriptor,
&TTSOpsVirtual);
return estate->es_epqTuple[rti - 1]; MemoryContextSwitchTo(oldcontext);
}
return *slot;
} }
/* /*
@ -2844,13 +2834,14 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
ExecRowMark *erm = aerm->rowmark; ExecRowMark *erm = aerm->rowmark;
Datum datum; Datum datum;
bool isNull; bool isNull;
HeapTupleData tuple; TupleTableSlot *slot;
if (RowMarkRequiresRowShareLock(erm->markType)) if (RowMarkRequiresRowShareLock(erm->markType))
elog(ERROR, "EvalPlanQual doesn't support locking rowmarks"); elog(ERROR, "EvalPlanQual doesn't support locking rowmarks");
/* clear any leftover test tuple for this rel */ /* clear any leftover test tuple for this rel */
EvalPlanQualSetTuple(epqstate, erm->rti, NULL); slot = EvalPlanQualSlot(epqstate, erm->relation, erm->rti);
ExecClearTuple(slot);
/* if child rel, must check whether it produced this row */ /* if child rel, must check whether it produced this row */
if (erm->rti != erm->prti) if (erm->rti != erm->prti)
@ -2875,8 +2866,6 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
if (erm->markType == ROW_MARK_REFERENCE) if (erm->markType == ROW_MARK_REFERENCE)
{ {
HeapTuple copyTuple;
Assert(erm->relation != NULL); Assert(erm->relation != NULL);
/* fetch the tuple's ctid */ /* fetch the tuple's ctid */
@ -2900,11 +2889,13 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED), (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot lock rows in foreign table \"%s\"", errmsg("cannot lock rows in foreign table \"%s\"",
RelationGetRelationName(erm->relation)))); RelationGetRelationName(erm->relation))));
copyTuple = fdwroutine->RefetchForeignRow(epqstate->estate,
erm, fdwroutine->RefetchForeignRow(epqstate->estate,
datum, erm,
&updated); datum,
if (copyTuple == NULL) slot,
&updated);
if (TupIsNull(slot))
elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck"); elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
/* /*
@ -2916,6 +2907,7 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
else else
{ {
/* ordinary table, fetch the tuple */ /* ordinary table, fetch the tuple */
HeapTupleData tuple;
Buffer buffer; Buffer buffer;
tuple.t_self = *((ItemPointer) DatumGetPointer(datum)); tuple.t_self = *((ItemPointer) DatumGetPointer(datum));
@ -2923,18 +2915,13 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
false, NULL)) false, NULL))
elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck"); elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
/* successful, copy tuple */ /* successful, store tuple */
copyTuple = heap_copytuple(&tuple); ExecStorePinnedBufferHeapTuple(&tuple, slot, buffer);
ReleaseBuffer(buffer); ExecMaterializeSlot(slot);
} }
/* store tuple */
EvalPlanQualSetTuple(epqstate, erm->rti, copyTuple);
} }
else else
{ {
HeapTupleHeader td;
Assert(erm->markType == ROW_MARK_COPY); Assert(erm->markType == ROW_MARK_COPY);
/* fetch the whole-row Var for the relation */ /* fetch the whole-row Var for the relation */
@ -2944,19 +2931,8 @@ EvalPlanQualFetchRowMarks(EPQState *epqstate)
/* non-locked rels could be on the inside of outer joins */ /* non-locked rels could be on the inside of outer joins */
if (isNull) if (isNull)
continue; continue;
td = DatumGetHeapTupleHeader(datum);
/* build a temporary HeapTuple control structure */ ExecStoreHeapTupleDatum(datum, slot);
tuple.t_len = HeapTupleHeaderGetDatumLength(td);
tuple.t_data = td;
/* relation might be a foreign table, if so provide tableoid */
tuple.t_tableOid = erm->relid;
/* also copy t_ctid in case there's valid data there */
tuple.t_self = td->t_ctid;
/* copy and store tuple */
EvalPlanQualSetTuple(epqstate, erm->rti,
heap_copytuple(&tuple));
} }
} }
} }
@ -3152,17 +3128,14 @@ EvalPlanQualStart(EPQState *epqstate, EState *parentestate, Plan *planTree)
* sub-rechecks to inherit the values being examined by an outer recheck. * sub-rechecks to inherit the values being examined by an outer recheck.
*/ */
estate->es_epqScanDone = (bool *) palloc0(rtsize * sizeof(bool)); estate->es_epqScanDone = (bool *) palloc0(rtsize * sizeof(bool));
if (parentestate->es_epqTuple != NULL) if (parentestate->es_epqTupleSlot != NULL)
{ {
estate->es_epqTuple = parentestate->es_epqTuple; estate->es_epqTupleSlot = parentestate->es_epqTupleSlot;
estate->es_epqTupleSet = parentestate->es_epqTupleSet;
} }
else else
{ {
estate->es_epqTuple = (HeapTuple *) estate->es_epqTupleSlot = (TupleTableSlot **)
palloc0(rtsize * sizeof(HeapTuple)); palloc0(rtsize * sizeof(TupleTableSlot *));
estate->es_epqTupleSet = (bool *)
palloc0(rtsize * sizeof(bool));
} }
/* /*

16
src/backend/executor/execScan.c
View File

@ -40,7 +40,7 @@ ExecScanFetch(ScanState *node,
CHECK_FOR_INTERRUPTS(); CHECK_FOR_INTERRUPTS();
if (estate->es_epqTuple != NULL) if (estate->es_epqTupleSlot != NULL)
{ {
/* /*
* We are inside an EvalPlanQual recheck. Return the test tuple if * We are inside an EvalPlanQual recheck. Return the test tuple if
@ -63,7 +63,7 @@ ExecScanFetch(ScanState *node,
ExecClearTuple(slot); /* would not be returned by scan */ ExecClearTuple(slot); /* would not be returned by scan */
return slot; return slot;
} }
else if (estate->es_epqTupleSet[scanrelid - 1]) else if (estate->es_epqTupleSlot[scanrelid - 1] != NULL)
{ {
TupleTableSlot *slot = node->ss_ScanTupleSlot; TupleTableSlot *slot = node->ss_ScanTupleSlot;
@ -73,17 +73,15 @@ ExecScanFetch(ScanState *node,
/* Else mark to remember that we shouldn't return more */ /* Else mark to remember that we shouldn't return more */
estate->es_epqScanDone[scanrelid - 1] = true; estate->es_epqScanDone[scanrelid - 1] = true;
/* Return empty slot if we haven't got a test tuple */ slot = estate->es_epqTupleSlot[scanrelid - 1];
if (estate->es_epqTuple[scanrelid - 1] == NULL)
return ExecClearTuple(slot);
/* Store test tuple in the plan node's scan slot */ /* Return empty slot if we haven't got a test tuple */
ExecForceStoreHeapTuple(estate->es_epqTuple[scanrelid - 1], if (TupIsNull(slot))
slot); return NULL;
/* Check if it meets the access-method conditions */ /* Check if it meets the access-method conditions */
if (!(*recheckMtd) (node, slot)) if (!(*recheckMtd) (node, slot))
ExecClearTuple(slot); /* would not be returned by scan */ return ExecClearTuple(slot); /* would not be returned by scan */
return slot; return slot;
} }

26
src/backend/executor/execTuples.c
View File

@ -1542,6 +1542,32 @@ ExecStoreAllNullTuple(TupleTableSlot *slot)
return ExecStoreVirtualTuple(slot); return ExecStoreVirtualTuple(slot);
} }
/*
* Store a HeapTuple in datum form, into a slot. That always requires
* deforming it and storing it in virtual form.
*
* Until the slot is materialized, the contents of the slot depend on the
* datum.
*/
void
ExecStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
{
HeapTupleData tuple = {0};
HeapTupleHeader td;
td = DatumGetHeapTupleHeader(data);
tuple.t_len = HeapTupleHeaderGetDatumLength(td);
tuple.t_self = td->t_ctid;
tuple.t_data = td;
ExecClearTuple(slot);
heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
slot->tts_values, slot->tts_isnull);
ExecStoreVirtualTuple(slot);
}
/* /*
* ExecFetchSlotHeapTuple - fetch HeapTuple representing the slot's content * ExecFetchSlotHeapTuple - fetch HeapTuple representing the slot's content
* *

3
src/backend/executor/execUtils.c
View File

@ -155,8 +155,7 @@ CreateExecutorState(void)
estate->es_per_tuple_exprcontext = NULL; estate->es_per_tuple_exprcontext = NULL;
estate->es_epqTuple = NULL; estate->es_epqTupleSlot = NULL;
estate->es_epqTupleSet = NULL;
estate->es_epqScanDone = NULL; estate->es_epqScanDone = NULL;
estate->es_sourceText = NULL; estate->es_sourceText = NULL;

8
src/backend/executor/nodeIndexonlyscan.c
View File

@ -426,7 +426,7 @@ ExecIndexOnlyMarkPos(IndexOnlyScanState *node)
{ {
EState *estate = node->ss.ps.state; EState *estate = node->ss.ps.state;
if (estate->es_epqTuple != NULL) if (estate->es_epqTupleSlot != NULL)
{ {
/* /*
* We are inside an EvalPlanQual recheck. If a test tuple exists for * We are inside an EvalPlanQual recheck. If a test tuple exists for
@ -440,7 +440,7 @@ ExecIndexOnlyMarkPos(IndexOnlyScanState *node)
Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid; Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
Assert(scanrelid > 0); Assert(scanrelid > 0);
if (estate->es_epqTupleSet[scanrelid - 1]) if (estate->es_epqTupleSlot[scanrelid - 1] != NULL)
{ {
/* Verify the claim above */ /* Verify the claim above */
if (!estate->es_epqScanDone[scanrelid - 1]) if (!estate->es_epqScanDone[scanrelid - 1])
@ -461,13 +461,13 @@ ExecIndexOnlyRestrPos(IndexOnlyScanState *node)
{ {
EState *estate = node->ss.ps.state; EState *estate = node->ss.ps.state;
if (estate->es_epqTuple != NULL) if (estate->es_epqTupleSlot != NULL)
{ {
/* See comments in ExecIndexOnlyMarkPos */ /* See comments in ExecIndexOnlyMarkPos */
Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid; Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
Assert(scanrelid > 0); Assert(scanrelid > 0);
if (estate->es_epqTupleSet[scanrelid - 1]) if (estate->es_epqTupleSlot[scanrelid - 1])
{ {
/* Verify the claim above */ /* Verify the claim above */
if (!estate->es_epqScanDone[scanrelid - 1]) if (!estate->es_epqScanDone[scanrelid - 1])

8
src/backend/executor/nodeIndexscan.c
View File

@ -850,7 +850,7 @@ ExecIndexMarkPos(IndexScanState *node)
{ {
EState *estate = node->ss.ps.state; EState *estate = node->ss.ps.state;
if (estate->es_epqTuple != NULL) if (estate->es_epqTupleSlot != NULL)
{ {
/* /*
* We are inside an EvalPlanQual recheck. If a test tuple exists for * We are inside an EvalPlanQual recheck. If a test tuple exists for
@ -864,7 +864,7 @@ ExecIndexMarkPos(IndexScanState *node)
Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid; Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
Assert(scanrelid > 0); Assert(scanrelid > 0);
if (estate->es_epqTupleSet[scanrelid - 1]) if (estate->es_epqTupleSlot[scanrelid - 1] != NULL)
{ {
/* Verify the claim above */ /* Verify the claim above */
if (!estate->es_epqScanDone[scanrelid - 1]) if (!estate->es_epqScanDone[scanrelid - 1])
@ -885,13 +885,13 @@ ExecIndexRestrPos(IndexScanState *node)
{ {
EState *estate = node->ss.ps.state; EState *estate = node->ss.ps.state;
if (estate->es_epqTuple != NULL) if (estate->es_epqTupleSlot != NULL)
{ {
/* See comments in ExecIndexMarkPos */ /* See comments in ExecIndexMarkPos */
Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid; Index scanrelid = ((Scan *) node->ss.ps.plan)->scanrelid;
Assert(scanrelid > 0); Assert(scanrelid > 0);
if (estate->es_epqTupleSet[scanrelid - 1]) if (estate->es_epqTupleSlot[scanrelid - 1] != NULL)
{ {
/* Verify the claim above */ /* Verify the claim above */
if (!estate->es_epqScanDone[scanrelid - 1]) if (!estate->es_epqScanDone[scanrelid - 1])

92
src/backend/executor/nodeLockRows.c
View File

@ -66,6 +66,12 @@ lnext:
/* We don't need EvalPlanQual unless we get updated tuple version(s) */ /* We don't need EvalPlanQual unless we get updated tuple version(s) */
epq_needed = false; epq_needed = false;
/*
* Initialize EPQ machinery. Need to do that early because source tuples
* are stored in slots initialized therein.
*/
EvalPlanQualBegin(&node->lr_epqstate, estate);
/* /*
* Attempt to lock the source tuple(s). (Note we only have locking * Attempt to lock the source tuple(s). (Note we only have locking
* rowmarks in lr_arowMarks.) * rowmarks in lr_arowMarks.)
@ -74,7 +80,6 @@ lnext:
{ {
ExecAuxRowMark *aerm = (ExecAuxRowMark *) lfirst(lc); ExecAuxRowMark *aerm = (ExecAuxRowMark *) lfirst(lc);
ExecRowMark *erm = aerm->rowmark; ExecRowMark *erm = aerm->rowmark;
HeapTuple *testTuple;
Datum datum; Datum datum;
bool isNull; bool isNull;
HeapTupleData tuple; HeapTupleData tuple;
@ -82,13 +87,11 @@ lnext:
HeapUpdateFailureData hufd; HeapUpdateFailureData hufd;
LockTupleMode lockmode; LockTupleMode lockmode;
HTSU_Result test; HTSU_Result test;
HeapTuple copyTuple; TupleTableSlot *markSlot;
/* clear any leftover test tuple for this rel */ /* clear any leftover test tuple for this rel */
testTuple = &(node->lr_curtuples[erm->rti - 1]); markSlot = EvalPlanQualSlot(&node->lr_epqstate, erm->relation, erm->rti);
if (*testTuple != NULL) ExecClearTuple(markSlot);
heap_freetuple(*testTuple);
*testTuple = NULL;
/* if child rel, must check whether it produced this row */ /* if child rel, must check whether it produced this row */
if (erm->rti != erm->prti) if (erm->rti != erm->prti)
@ -135,19 +138,18 @@ lnext:
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED), (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot lock rows in foreign table \"%s\"", errmsg("cannot lock rows in foreign table \"%s\"",
RelationGetRelationName(erm->relation)))); RelationGetRelationName(erm->relation))));
copyTuple = fdwroutine->RefetchForeignRow(estate,
erm, fdwroutine->RefetchForeignRow(estate,
datum, erm,
&updated); datum,
if (copyTuple == NULL) markSlot,
&updated);
if (TupIsNull(markSlot))
{ {
/* couldn't get the lock, so skip this row */ /* couldn't get the lock, so skip this row */
goto lnext; goto lnext;
} }
/* save locked tuple for possible EvalPlanQual testing below */
*testTuple = copyTuple;
/* /*
* if FDW says tuple was updated before getting locked, we need to * if FDW says tuple was updated before getting locked, we need to
* perform EPQ testing to see if quals are still satisfied * perform EPQ testing to see if quals are still satisfied
@ -230,11 +232,10 @@ lnext:
} }
/* updated, so fetch and lock the updated version */ /* updated, so fetch and lock the updated version */
copyTuple = EvalPlanQualFetch(estate, erm->relation, if (!EvalPlanQualFetch(estate, erm->relation,
lockmode, erm->waitPolicy, lockmode, erm->waitPolicy,
&hufd.ctid, hufd.xmax); &hufd.ctid, hufd.xmax,
markSlot))
if (copyTuple == NULL)
{ {
/* /*
* Tuple was deleted; or it's locked and we're under SKIP * Tuple was deleted; or it's locked and we're under SKIP
@ -243,10 +244,7 @@ lnext:
goto lnext; goto lnext;
} }
/* remember the actually locked tuple's TID */ /* remember the actually locked tuple's TID */
tuple.t_self = copyTuple->t_self; tuple.t_self = markSlot->tts_tid;
/* Save locked tuple for EvalPlanQual testing below */
*testTuple = copyTuple;
/* Remember we need to do EPQ testing */ /* Remember we need to do EPQ testing */
epq_needed = true; epq_needed = true;
@ -272,42 +270,34 @@ lnext:
*/ */
if (epq_needed) if (epq_needed)
{ {
/* Initialize EPQ machinery */
EvalPlanQualBegin(&node->lr_epqstate, estate);
/* /*
* Transfer any already-fetched tuples into the EPQ state, and fetch a * Fetch a copy of any rows that were successfully locked without any
* copy of any rows that were successfully locked without any update * update having occurred. (We do this in a separate pass so as to
* having occurred. (We do this in a separate pass so as to avoid * avoid overhead in the common case where there are no concurrent
* overhead in the common case where there are no concurrent updates.) * updates.) Make sure any inactive child rels have NULL test tuples
* Make sure any inactive child rels have NULL test tuples in EPQ. * in EPQ.
*/ */
foreach(lc, node->lr_arowMarks) foreach(lc, node->lr_arowMarks)
{ {
ExecAuxRowMark *aerm = (ExecAuxRowMark *) lfirst(lc); ExecAuxRowMark *aerm = (ExecAuxRowMark *) lfirst(lc);
ExecRowMark *erm = aerm->rowmark; ExecRowMark *erm = aerm->rowmark;
TupleTableSlot *markSlot;
HeapTupleData tuple; HeapTupleData tuple;
Buffer buffer; Buffer buffer;
markSlot = EvalPlanQualSlot(&node->lr_epqstate, erm->relation, erm->rti);
/* skip non-active child tables, but clear their test tuples */ /* skip non-active child tables, but clear their test tuples */
if (!erm->ermActive) if (!erm->ermActive)
{ {
Assert(erm->rti != erm->prti); /* check it's child table */ Assert(erm->rti != erm->prti); /* check it's child table */
EvalPlanQualSetTuple(&node->lr_epqstate, erm->rti, NULL); ExecClearTuple(markSlot);
continue; continue;
} }
/* was tuple updated and fetched above? */ /* was tuple updated and fetched above? */
if (node->lr_curtuples[erm->rti - 1] != NULL) if (!TupIsNull(markSlot))
{
/* yes, so set it as the EPQ test tuple for this rel */
EvalPlanQualSetTuple(&node->lr_epqstate,
erm->rti,
node->lr_curtuples[erm->rti - 1]);
/* freeing this tuple is now the responsibility of EPQ */
node->lr_curtuples[erm->rti - 1] = NULL;
continue; continue;
}
/* foreign tables should have been fetched above */ /* foreign tables should have been fetched above */
Assert(erm->relation->rd_rel->relkind != RELKIND_FOREIGN_TABLE); Assert(erm->relation->rd_rel->relkind != RELKIND_FOREIGN_TABLE);
@ -318,11 +308,9 @@ lnext:
if (!heap_fetch(erm->relation, SnapshotAny, &tuple, &buffer, if (!heap_fetch(erm->relation, SnapshotAny, &tuple, &buffer,
false, NULL)) false, NULL))
elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck"); elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
ExecStorePinnedBufferHeapTuple(&tuple, markSlot, buffer);
/* successful, copy and store tuple */ ExecMaterializeSlot(markSlot);
EvalPlanQualSetTuple(&node->lr_epqstate, erm->rti, /* successful, use tuple in slot */
heap_copytuple(&tuple));
ReleaseBuffer(buffer);
} }
/* /*
@ -401,13 +389,6 @@ ExecInitLockRows(LockRows *node, EState *estate, int eflags)
*/ */
lrstate->ps.ps_ProjInfo = NULL; lrstate->ps.ps_ProjInfo = NULL;
/*
* Create workspace in which we can remember per-RTE locked tuples
*/
lrstate->lr_ntables = estate->es_range_table_size;
lrstate->lr_curtuples = (HeapTuple *)
palloc0(lrstate->lr_ntables * sizeof(HeapTuple));
/* /*
* Locate the ExecRowMark(s) that this node is responsible for, and * Locate the ExecRowMark(s) that this node is responsible for, and
* construct ExecAuxRowMarks for them. (InitPlan should already have * construct ExecAuxRowMarks for them. (InitPlan should already have
@ -425,9 +406,6 @@ ExecInitLockRows(LockRows *node, EState *estate, int eflags)
if (rc->isParent) if (rc->isParent)
continue; continue;
/* safety check on size of lr_curtuples array */
Assert(rc->rti > 0 && rc->rti <= lrstate->lr_ntables);
/* find ExecRowMark and build ExecAuxRowMark */ /* find ExecRowMark and build ExecAuxRowMark */
erm = ExecFindRowMark(estate, rc->rti, false); erm = ExecFindRowMark(estate, rc->rti, false);
aerm = ExecBuildAuxRowMark(erm, outerPlan->targetlist); aerm = ExecBuildAuxRowMark(erm, outerPlan->targetlist);

2
src/backend/executor/nodeModifyTable.c
View File

@ -1803,7 +1803,7 @@ ExecModifyTable(PlanState *pstate)
* case it is within a CTE subplan. Hence this test must be here, not in * case it is within a CTE subplan. Hence this test must be here, not in
* ExecInitModifyTable.) * ExecInitModifyTable.)
*/ */
if (estate->es_epqTuple != NULL) if (estate->es_epqTupleSlot != NULL)
elog(ERROR, "ModifyTable should not be called during EvalPlanQual"); elog(ERROR, "ModifyTable should not be called during EvalPlanQual");
/* /*

10
src/include/executor/executor.h
View File

@ -197,16 +197,16 @@ extern ExecAuxRowMark *ExecBuildAuxRowMark(ExecRowMark *erm, List *targetlist);
extern TupleTableSlot *EvalPlanQual(EState *estate, EPQState *epqstate, extern TupleTableSlot *EvalPlanQual(EState *estate, EPQState *epqstate,
Relation relation, Index rti, LockTupleMode lockmode, Relation relation, Index rti, LockTupleMode lockmode,
ItemPointer tid, TransactionId priorXmax); ItemPointer tid, TransactionId priorXmax);
extern HeapTuple EvalPlanQualFetch(EState *estate, Relation relation, extern bool EvalPlanQualFetch(EState *estate, Relation relation,
LockTupleMode lockmode, LockWaitPolicy wait_policy, LockTupleMode lockmode, LockWaitPolicy wait_policy,
ItemPointer tid, TransactionId priorXmax); ItemPointer tid, TransactionId priorXmax,
TupleTableSlot *slot);
extern void EvalPlanQualInit(EPQState *epqstate, EState *estate, extern void EvalPlanQualInit(EPQState *epqstate, EState *estate,
Plan *subplan, List *auxrowmarks, int epqParam); Plan *subplan, List *auxrowmarks, int epqParam);
extern void EvalPlanQualSetPlan(EPQState *epqstate, extern void EvalPlanQualSetPlan(EPQState *epqstate,
Plan *subplan, List *auxrowmarks); Plan *subplan, List *auxrowmarks);
extern void EvalPlanQualSetTuple(EPQState *epqstate, Index rti, extern TupleTableSlot *EvalPlanQualSlot(EPQState *epqstate,
HeapTuple tuple); Relation relation, Index rti);
extern HeapTuple EvalPlanQualGetTuple(EPQState *epqstate, Index rti);
#define EvalPlanQualSetSlot(epqstate, slot) ((epqstate)->origslot = (slot)) #define EvalPlanQualSetSlot(epqstate, slot) ((epqstate)->origslot = (slot))
extern void EvalPlanQualFetchRowMarks(EPQState *epqstate); extern void EvalPlanQualFetchRowMarks(EPQState *epqstate);

1
src/include/executor/tuptable.h
View File

@ -320,6 +320,7 @@ extern void ExecForceStoreMinimalTuple(MinimalTuple mtup, TupleTableSlot *slot,
bool shouldFree); bool shouldFree);
extern TupleTableSlot *ExecStoreVirtualTuple(TupleTableSlot *slot); extern TupleTableSlot *ExecStoreVirtualTuple(TupleTableSlot *slot);
extern TupleTableSlot *ExecStoreAllNullTuple(TupleTableSlot *slot); extern TupleTableSlot *ExecStoreAllNullTuple(TupleTableSlot *slot);
extern void ExecStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
extern HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree); extern HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree);
extern MinimalTuple ExecFetchSlotMinimalTuple(TupleTableSlot *slot, extern MinimalTuple ExecFetchSlotMinimalTuple(TupleTableSlot *slot,
bool *shouldFree); bool *shouldFree);

9
src/include/foreign/fdwapi.h
View File

@ -121,10 +121,11 @@ typedef void (*EndDirectModify_function) (ForeignScanState *node);
typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte, typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
LockClauseStrength strength); LockClauseStrength strength);
typedef HeapTuple (*RefetchForeignRow_function) (EState *estate, typedef void (*RefetchForeignRow_function) (EState *estate,
ExecRowMark *erm, ExecRowMark *erm,
Datum rowid, Datum rowid,
bool *updated); TupleTableSlot *slot,
bool *updated);
typedef void (*ExplainForeignScan_function) (ForeignScanState *node, typedef void (*ExplainForeignScan_function) (ForeignScanState *node,
struct ExplainState *es); struct ExplainState *es);

18
src/include/nodes/execnodes.h
View File

@ -562,15 +562,15 @@ typedef struct EState
/* /*
* These fields are for re-evaluating plan quals when an updated tuple is * These fields are for re-evaluating plan quals when an updated tuple is
* substituted in READ COMMITTED mode. es_epqTuple[] contains tuples that * substituted in READ COMMITTED mode. es_epqTupleSlot[] contains test
* scan plan nodes should return instead of whatever they'd normally * tuples that scan plan nodes should return instead of whatever they'd
* return, or NULL if nothing to return; es_epqTupleSet[] is true if a * normally return, or an empty slot if there is nothing to return; if
* particular array entry is valid; and es_epqScanDone[] is state to * es_epqTupleSlot[] is not NULL if a particular array entry is valid; and
* remember if the tuple has been returned already. Arrays are of size * es_epqScanDone[] is state to remember if the tuple has been returned
* es_range_table_size and are indexed by scan node scanrelid - 1. * already. Arrays are of size es_range_table_size and are indexed by
* scan node scanrelid - 1.
*/ */
HeapTuple *es_epqTuple; /* array of EPQ substitute tuples */ TupleTableSlot **es_epqTupleSlot; /* array of EPQ substitute tuples */
bool *es_epqTupleSet; /* true if EPQ tuple is provided */
bool *es_epqScanDone; /* true if EPQ tuple has been fetched */ bool *es_epqScanDone; /* true if EPQ tuple has been fetched */
bool es_use_parallel_mode; /* can we use parallel workers? */ bool es_use_parallel_mode; /* can we use parallel workers? */
@ -2257,8 +2257,6 @@ typedef struct LockRowsState
PlanState ps; /* its first field is NodeTag */ PlanState ps; /* its first field is NodeTag */
List *lr_arowMarks; /* List of ExecAuxRowMarks */ List *lr_arowMarks; /* List of ExecAuxRowMarks */
EPQState lr_epqstate; /* for evaluating EvalPlanQual rechecks */ EPQState lr_epqstate; /* for evaluating EvalPlanQual rechecks */
HeapTuple *lr_curtuples; /* locked tuples (one entry per RT entry) */
int lr_ntables; /* length of lr_curtuples[] array */
} LockRowsState; } LockRowsState;
/* ---------------- /* ----------------