PostgreSQL Source Code  git master
nodeLockRows.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * nodeLockRows.c
4  * Routines to handle FOR UPDATE/FOR SHARE row locking
5  *
6  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/executor/nodeLockRows.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 /*
16  * INTERFACE ROUTINES
17  * ExecLockRows - fetch locked rows
18  * ExecInitLockRows - initialize node and subnodes..
19  * ExecEndLockRows - shutdown node and subnodes
20  */
21 
22 #include "postgres.h"
23 
24 #include "access/tableam.h"
25 #include "access/xact.h"
26 #include "executor/executor.h"
27 #include "executor/nodeLockRows.h"
28 #include "foreign/fdwapi.h"
29 #include "miscadmin.h"
30 #include "utils/rel.h"
31 
32 
33 /* ----------------------------------------------------------------
34  * ExecLockRows
35  * ----------------------------------------------------------------
36  */
37 static TupleTableSlot * /* return: a tuple or NULL */
39 {
40  LockRowsState *node = castNode(LockRowsState, pstate);
41  TupleTableSlot *slot;
42  EState *estate;
44  bool epq_needed;
45  ListCell *lc;
46 
48 
49  /*
50  * get information from the node
51  */
52  estate = node->ps.state;
53  outerPlan = outerPlanState(node);
54 
55  /*
56  * Get next tuple from subplan, if any.
57  */
58 lnext:
59  slot = ExecProcNode(outerPlan);
60 
61  if (TupIsNull(slot))
62  {
63  /* Release any resources held by EPQ mechanism before exiting */
65  return NULL;
66  }
67 
68  /* We don't need EvalPlanQual unless we get updated tuple version(s) */
69  epq_needed = false;
70 
71  /*
72  * Attempt to lock the source tuple(s). (Note we only have locking
73  * rowmarks in lr_arowMarks.)
74  */
75  foreach(lc, node->lr_arowMarks)
76  {
77  ExecAuxRowMark *aerm = (ExecAuxRowMark *) lfirst(lc);
78  ExecRowMark *erm = aerm->rowmark;
79  Datum datum;
80  bool isNull;
81  ItemPointerData tid;
82  TM_FailureData tmfd;
83  LockTupleMode lockmode;
84  int lockflags = 0;
86  TupleTableSlot *markSlot;
87 
88  /* clear any leftover test tuple for this rel */
89  markSlot = EvalPlanQualSlot(&node->lr_epqstate, erm->relation, erm->rti);
90  ExecClearTuple(markSlot);
91 
92  /* if child rel, must check whether it produced this row */
93  if (erm->rti != erm->prti)
94  {
95  Oid tableoid;
96 
97  datum = ExecGetJunkAttribute(slot,
98  aerm->toidAttNo,
99  &isNull);
100  /* shouldn't ever get a null result... */
101  if (isNull)
102  elog(ERROR, "tableoid is NULL");
103  tableoid = DatumGetObjectId(datum);
104 
105  Assert(OidIsValid(erm->relid));
106  if (tableoid != erm->relid)
107  {
108  /* this child is inactive right now */
109  erm->ermActive = false;
111  ExecClearTuple(markSlot);
112  continue;
113  }
114  }
115  erm->ermActive = true;
116 
117  /* fetch the tuple's ctid */
118  datum = ExecGetJunkAttribute(slot,
119  aerm->ctidAttNo,
120  &isNull);
121  /* shouldn't ever get a null result... */
122  if (isNull)
123  elog(ERROR, "ctid is NULL");
124 
125  /* requests for foreign tables must be passed to their FDW */
126  if (erm->relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
127  {
128  FdwRoutine *fdwroutine;
129  bool updated = false;
130 
131  fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
132  /* this should have been checked already, but let's be safe */
133  if (fdwroutine->RefetchForeignRow == NULL)
134  ereport(ERROR,
135  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
136  errmsg("cannot lock rows in foreign table \"%s\"",
138 
139  fdwroutine->RefetchForeignRow(estate,
140  erm,
141  datum,
142  markSlot,
143  &updated);
144  if (TupIsNull(markSlot))
145  {
146  /* couldn't get the lock, so skip this row */
147  goto lnext;
148  }
149 
150  /*
151  * if FDW says tuple was updated before getting locked, we need to
152  * perform EPQ testing to see if quals are still satisfied
153  */
154  if (updated)
155  epq_needed = true;
156 
157  continue;
158  }
159 
160  /* okay, try to lock (and fetch) the tuple */
161  tid = *((ItemPointer) DatumGetPointer(datum));
162  switch (erm->markType)
163  {
164  case ROW_MARK_EXCLUSIVE:
165  lockmode = LockTupleExclusive;
166  break;
168  lockmode = LockTupleNoKeyExclusive;
169  break;
170  case ROW_MARK_SHARE:
171  lockmode = LockTupleShare;
172  break;
173  case ROW_MARK_KEYSHARE:
174  lockmode = LockTupleKeyShare;
175  break;
176  default:
177  elog(ERROR, "unsupported rowmark type");
178  lockmode = LockTupleNoKeyExclusive; /* keep compiler quiet */
179  break;
180  }
181 
185 
186  test = table_tuple_lock(erm->relation, &tid, estate->es_snapshot,
187  markSlot, estate->es_output_cid,
188  lockmode, erm->waitPolicy,
189  lockflags,
190  &tmfd);
191 
192  switch (test)
193  {
194  case TM_WouldBlock:
195  /* couldn't lock tuple in SKIP LOCKED mode */
196  goto lnext;
197 
198  case TM_SelfModified:
199 
200  /*
201  * The target tuple was already updated or deleted by the
202  * current command, or by a later command in the current
203  * transaction. We *must* ignore the tuple in the former
204  * case, so as to avoid the "Halloween problem" of repeated
205  * update attempts. In the latter case it might be sensible
206  * to fetch the updated tuple instead, but doing so would
207  * require changing heap_update and heap_delete to not
208  * complain about updating "invisible" tuples, which seems
209  * pretty scary (table_tuple_lock will not complain, but few
210  * callers expect TM_Invisible, and we're not one of them). So
211  * for now, treat the tuple as deleted and do not process.
212  */
213  goto lnext;
214 
215  case TM_Ok:
216 
217  /*
218  * Got the lock successfully, the locked tuple saved in
219  * markSlot for, if needed, EvalPlanQual testing below.
220  */
221  if (tmfd.traversed)
222  epq_needed = true;
223  break;
224 
225  case TM_Updated:
227  ereport(ERROR,
228  (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
229  errmsg("could not serialize access due to concurrent update")));
230  elog(ERROR, "unexpected table_tuple_lock status: %u",
231  test);
232  break;
233 
234  case TM_Deleted:
236  ereport(ERROR,
237  (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
238  errmsg("could not serialize access due to concurrent update")));
239  /* tuple was deleted so don't return it */
240  goto lnext;
241 
242  case TM_Invisible:
243  elog(ERROR, "attempted to lock invisible tuple");
244  break;
245 
246  default:
247  elog(ERROR, "unrecognized table_tuple_lock status: %u",
248  test);
249  }
250 
251  /* Remember locked tuple's TID for EPQ testing and WHERE CURRENT OF */
252  erm->curCtid = tid;
253  }
254 
255  /*
256  * If we need to do EvalPlanQual testing, do so.
257  */
258  if (epq_needed)
259  {
260  /* Initialize EPQ machinery */
262 
263  /*
264  * To fetch non-locked source rows the EPQ logic needs to access junk
265  * columns from the tuple being tested.
266  */
267  EvalPlanQualSetSlot(&node->lr_epqstate, slot);
268 
269  /*
270  * And finally we can re-evaluate the tuple.
271  */
272  slot = EvalPlanQualNext(&node->lr_epqstate);
273  if (TupIsNull(slot))
274  {
275  /* Updated tuple fails qual, so ignore it and go on */
276  goto lnext;
277  }
278  }
279 
280  /* Got all locks, so return the current tuple */
281  return slot;
282 }
283 
284 /* ----------------------------------------------------------------
285  * ExecInitLockRows
286  *
287  * This initializes the LockRows node state structures and
288  * the node's subplan.
289  * ----------------------------------------------------------------
290  */
292 ExecInitLockRows(LockRows *node, EState *estate, int eflags)
293 {
294  LockRowsState *lrstate;
295  Plan *outerPlan = outerPlan(node);
296  List *epq_arowmarks;
297  ListCell *lc;
298 
299  /* check for unsupported flags */
300  Assert(!(eflags & EXEC_FLAG_MARK));
301 
302  /*
303  * create state structure
304  */
305  lrstate = makeNode(LockRowsState);
306  lrstate->ps.plan = (Plan *) node;
307  lrstate->ps.state = estate;
308  lrstate->ps.ExecProcNode = ExecLockRows;
309 
310  /*
311  * Miscellaneous initialization
312  *
313  * LockRows nodes never call ExecQual or ExecProject, therefore no
314  * ExprContext is needed.
315  */
316 
317  /*
318  * Initialize result type.
319  */
320  ExecInitResultTypeTL(&lrstate->ps);
321 
322  /*
323  * then initialize outer plan
324  */
325  outerPlanState(lrstate) = ExecInitNode(outerPlan, estate, eflags);
326 
327  /* node returns unmodified slots from the outer plan */
328  lrstate->ps.resultopsset = true;
329  lrstate->ps.resultops = ExecGetResultSlotOps(outerPlanState(lrstate),
330  &lrstate->ps.resultopsfixed);
331 
332  /*
333  * LockRows nodes do no projections, so initialize projection info for
334  * this node appropriately
335  */
336  lrstate->ps.ps_ProjInfo = NULL;
337 
338  /*
339  * Locate the ExecRowMark(s) that this node is responsible for, and
340  * construct ExecAuxRowMarks for them. (InitPlan should already have
341  * built the global list of ExecRowMarks.)
342  */
343  lrstate->lr_arowMarks = NIL;
344  epq_arowmarks = NIL;
345  foreach(lc, node->rowMarks)
346  {
348  ExecRowMark *erm;
349  ExecAuxRowMark *aerm;
350 
351  /* ignore "parent" rowmarks; they are irrelevant at runtime */
352  if (rc->isParent)
353  continue;
354 
355  /* find ExecRowMark and build ExecAuxRowMark */
356  erm = ExecFindRowMark(estate, rc->rti, false);
357  aerm = ExecBuildAuxRowMark(erm, outerPlan->targetlist);
358 
359  /*
360  * Only locking rowmarks go into our own list. Non-locking marks are
361  * passed off to the EvalPlanQual machinery. This is because we don't
362  * want to bother fetching non-locked rows unless we actually have to
363  * do an EPQ recheck.
364  */
366  lrstate->lr_arowMarks = lappend(lrstate->lr_arowMarks, aerm);
367  else
368  epq_arowmarks = lappend(epq_arowmarks, aerm);
369  }
370 
371  /* Now we have the info needed to set up EPQ state */
372  EvalPlanQualInit(&lrstate->lr_epqstate, estate,
373  outerPlan, epq_arowmarks, node->epqParam);
374 
375  return lrstate;
376 }
377 
378 /* ----------------------------------------------------------------
379  * ExecEndLockRows
380  *
381  * This shuts down the subplan and frees resources allocated
382  * to this node.
383  * ----------------------------------------------------------------
384  */
385 void
387 {
388  /* We may have shut down EPQ already, but no harm in another call */
391 }
392 
393 
394 void
396 {
397  /*
398  * if chgParam of subnode is not null then plan will be re-scanned by
399  * first ExecProcNode.
400  */
401  if (node->ps.lefttree->chgParam == NULL)
402  ExecReScan(node->ps.lefttree);
403 }
#define NIL
Definition: pg_list.h:65
LockTupleMode
Definition: lockoptions.h:49
CommandId es_output_cid
Definition: execnodes.h:572
static void test(void)
ProjectionInfo * ps_ProjInfo
Definition: execnodes.h:1006
const TupleTableSlotOps * ExecGetResultSlotOps(PlanState *planstate, bool *isfixed)
Definition: execUtils.c:499
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
EPQState lr_epqstate
Definition: execnodes.h:2599
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:322
#define castNode(_type_, nodeptr)
Definition: nodes.h:608
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:556
Relation relation
Definition: execnodes.h:672
LockRowsState * ExecInitLockRows(LockRows *node, EState *estate, int eflags)
Definition: nodeLockRows.c:292
#define DatumGetObjectId(X)
Definition: postgres.h:544
void ExecReScanLockRows(LockRowsState *node)
Definition: nodeLockRows.c:395
void ExecReScan(PlanState *node)
Definition: execAmi.c:78
void ExecEndLockRows(LockRowsState *node)
Definition: nodeLockRows.c:386
#define IsolationUsesXactSnapshot()
Definition: xact.h:51
static TupleTableSlot * ExecLockRows(PlanState *pstate)
Definition: nodeLockRows.c:38
int errcode(int sqlerrcode)
Definition: elog.c:698
bool ermActive
Definition: execnodes.h:680
int epqParam
Definition: plannodes.h:1011
LockWaitPolicy waitPolicy
Definition: execnodes.h:679
Snapshot es_snapshot
Definition: execnodes.h:558
#define TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS
Definition: tableam.h:240
EState * state
Definition: execnodes.h:968
Form_pg_class rd_rel
Definition: rel.h:109
unsigned int Oid
Definition: postgres_ext.h:31
#define OidIsValid(objectId)
Definition: c.h:710
#define RowMarkRequiresRowShareLock(marktype)
Definition: plannodes.h:1074
const TupleTableSlotOps * resultops
Definition: execnodes.h:1043
TupleTableSlot * EvalPlanQualNext(EPQState *epqstate)
Definition: execMain.c:2606
struct PlanState * lefttree
Definition: execnodes.h:988
void EvalPlanQualEnd(EPQState *epqstate)
Definition: execMain.c:2834
ItemPointerData * ItemPointer
Definition: itemptr.h:49
ExecRowMark * rowmark
Definition: execnodes.h:696
ItemPointerData curCtid
Definition: execnodes.h:681
#define ERROR
Definition: elog.h:46
static TM_Result table_tuple_lock(Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, uint8 flags, TM_FailureData *tmfd)
Definition: tableam.h:1549
TupleTableSlot * EvalPlanQualSlot(EPQState *epqstate, Relation relation, Index rti)
Definition: execMain.c:2469
#define lfirst_node(type, lc)
Definition: pg_list.h:172
#define outerPlanState(node)
Definition: execnodes.h:1062
PlanState ps
Definition: execnodes.h:2597
Index rti
Definition: execnodes.h:674
Index prti
Definition: execnodes.h:675
void ExecInitResultTypeTL(PlanState *planstate)
Definition: execTuples.c:1755
#define RelationGetRelationName(relation)
Definition: rel.h:511
#define TupIsNull(slot)
Definition: tuptable.h:292
bool resultopsset
Definition: execnodes.h:1051
Bitmapset * chgParam
Definition: execnodes.h:998
#define outerPlan(node)
Definition: plannodes.h:171
List * lappend(List *list, void *datum)
Definition: list.c:336
void EvalPlanQualInit(EPQState *epqstate, EState *parentestate, Plan *subplan, List *auxrowmarks, int epqParam)
Definition: execMain.c:2413
TM_Result
Definition: tableam.h:71
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:972
static Datum ExecGetJunkAttribute(TupleTableSlot *slot, AttrNumber attno, bool *isNull)
Definition: executor.h:178
uintptr_t Datum
Definition: postgres.h:411
static TupleTableSlot * ExecProcNode(PlanState *node)
Definition: executor.h:252
Plan * plan
Definition: execnodes.h:966
#define ereport(elevel,...)
Definition: elog.h:157
#define makeNode(_type_)
Definition: nodes.h:587
#define Assert(condition)
Definition: c.h:804
#define lfirst(lc)
Definition: pg_list.h:169
#define EXEC_FLAG_MARK
Definition: executor.h:59
Definition: tableam.h:77
List * rowMarks
Definition: plannodes.h:1010
RowMarkType markType
Definition: execnodes.h:677
#define TUPLE_LOCK_FLAG_FIND_LAST_VERSION
Definition: tableam.h:242
AttrNumber toidAttNo
Definition: execnodes.h:698
List * targetlist
Definition: plannodes.h:141
#define DatumGetPointer(X)
Definition: postgres.h:593
bool resultopsfixed
Definition: execnodes.h:1047
#define ItemPointerSetInvalid(pointer)
Definition: itemptr.h:172
int errmsg(const char *fmt,...)
Definition: elog.c:909
FdwRoutine * GetFdwRoutineForRelation(Relation relation, bool makecopy)
Definition: foreign.c:427
#define elog(elevel,...)
Definition: elog.h:232
List * lr_arowMarks
Definition: execnodes.h:2598
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:120
bool isParent
Definition: plannodes.h:1124
bool traversed
Definition: tableam.h:129
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:141
Definition: pg_list.h:50
void EvalPlanQualBegin(EPQState *epqstate)
Definition: execMain.c:2622
AttrNumber ctidAttNo
Definition: execnodes.h:697
ExecAuxRowMark * ExecBuildAuxRowMark(ExecRowMark *erm, List *targetlist)
Definition: execMain.c:2289
#define EvalPlanQualSetSlot(epqstate, slot)
Definition: executor.h:227
RefetchForeignRow_function RefetchForeignRow
Definition: fdwapi.h:248
ExecRowMark * ExecFindRowMark(EState *estate, Index rti, bool missing_ok)
Definition: execMain.c:2266