Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * nodeTidscan.c
4 : : * Routines to support direct tid scans of relations
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/executor/nodeTidscan.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : : /*
16 : : * INTERFACE ROUTINES
17 : : *
18 : : * ExecTidScan scans a relation using tids
19 : : * ExecInitTidScan creates and initializes state info.
20 : : * ExecReScanTidScan rescans the tid relation.
21 : : * ExecEndTidScan releases all storage.
22 : : */
23 : : #include "postgres.h"
24 : :
25 : : #include "access/sysattr.h"
26 : : #include "access/tableam.h"
27 : : #include "catalog/pg_type.h"
28 : : #include "executor/executor.h"
29 : : #include "executor/nodeTidscan.h"
30 : : #include "lib/qunique.h"
31 : : #include "miscadmin.h"
32 : : #include "nodes/nodeFuncs.h"
33 : : #include "utils/array.h"
34 : : #include "utils/rel.h"
35 : :
36 : :
37 : : /*
38 : : * It's sufficient to check varattno to identify the CTID variable, as any
39 : : * Var in the relation scan qual must be for our table. (Even if it's a
40 : : * parameterized scan referencing some other table's CTID, the other table's
41 : : * Var would have become a Param by the time it gets here.)
42 : : */
43 : : #define IsCTIDVar(node) \
44 : : ((node) != NULL && \
45 : : IsA((node), Var) && \
46 : : ((Var *) (node))->varattno == SelfItemPointerAttributeNumber)
47 : :
48 : : /* one element in tss_tidexprs */
49 : : typedef struct TidExpr
50 : : {
51 : : ExprState *exprstate; /* ExprState for a TID-yielding subexpr */
52 : : bool isarray; /* if true, it yields tid[] not just tid */
53 : : CurrentOfExpr *cexpr; /* alternatively, we can have CURRENT OF */
54 : : } TidExpr;
55 : :
56 : : static void TidExprListCreate(TidScanState *tidstate);
57 : : static void TidListEval(TidScanState *tidstate);
58 : : static int itemptr_comparator(const void *a, const void *b);
59 : : static TupleTableSlot *TidNext(TidScanState *node);
60 : :
61 : :
62 : : /*
63 : : * Extract the qual subexpressions that yield TIDs to search for,
64 : : * and compile them into ExprStates if they're ordinary expressions.
65 : : *
66 : : * CURRENT OF is a special case that we can't compile usefully;
67 : : * just drop it into the TidExpr list as-is.
68 : : */
69 : : static void
70 : 533 : TidExprListCreate(TidScanState *tidstate)
71 : : {
72 : 533 : TidScan *node = (TidScan *) tidstate->ss.ps.plan;
73 : : ListCell *l;
74 : :
75 : 533 : tidstate->tss_tidexprs = NIL;
76 : 533 : tidstate->tss_isCurrentOf = false;
77 : :
78 [ + - + + : 1084 : foreach(l, node->tidquals)
+ + ]
79 : : {
80 : 551 : Expr *expr = (Expr *) lfirst(l);
81 : 551 : TidExpr *tidexpr = palloc0_object(TidExpr);
82 : :
83 [ + + ]: 551 : if (is_opclause(expr))
84 : : {
85 : : Node *arg1;
86 : : Node *arg2;
87 : :
88 : 210 : arg1 = get_leftop(expr);
89 : 210 : arg2 = get_rightop(expr);
90 [ + - + + : 210 : if (IsCTIDVar(arg1))
+ - ]
91 : 178 : tidexpr->exprstate = ExecInitExpr((Expr *) arg2,
92 : : &tidstate->ss.ps);
93 [ + - + - : 32 : else if (IsCTIDVar(arg2))
+ - ]
94 : 32 : tidexpr->exprstate = ExecInitExpr((Expr *) arg1,
95 : : &tidstate->ss.ps);
96 : : else
97 [ # # ]: 0 : elog(ERROR, "could not identify CTID variable");
98 : 210 : tidexpr->isarray = false;
99 : : }
100 [ + - + + ]: 341 : else if (expr && IsA(expr, ScalarArrayOpExpr))
101 : 33 : {
102 : 33 : ScalarArrayOpExpr *saex = (ScalarArrayOpExpr *) expr;
103 : :
104 : : Assert(IsCTIDVar(linitial(saex->args)));
105 : 33 : tidexpr->exprstate = ExecInitExpr(lsecond(saex->args),
106 : : &tidstate->ss.ps);
107 : 33 : tidexpr->isarray = true;
108 : : }
109 [ + - + - ]: 308 : else if (expr && IsA(expr, CurrentOfExpr))
110 : 308 : {
111 : 308 : CurrentOfExpr *cexpr = (CurrentOfExpr *) expr;
112 : :
113 : 308 : tidexpr->cexpr = cexpr;
114 : 308 : tidstate->tss_isCurrentOf = true;
115 : : }
116 : : else
117 [ # # ]: 0 : elog(ERROR, "could not identify CTID expression");
118 : :
119 : 551 : tidstate->tss_tidexprs = lappend(tidstate->tss_tidexprs, tidexpr);
120 : : }
121 : :
122 : : /* CurrentOfExpr could never appear OR'd with something else */
123 : : Assert(list_length(tidstate->tss_tidexprs) == 1 ||
124 : : !tidstate->tss_isCurrentOf);
125 : 533 : }
126 : :
127 : : /*
128 : : * Compute the list of TIDs to be visited, by evaluating the expressions
129 : : * for them.
130 : : *
131 : : * (The result is actually an array, not a list.)
132 : : */
133 : : static void
134 : 467 : TidListEval(TidScanState *tidstate)
135 : : {
136 : 467 : ExprContext *econtext = tidstate->ss.ps.ps_ExprContext;
137 : : TableScanDesc scan;
138 : : ItemPointerData *tidList;
139 : : int numAllocTids;
140 : : int numTids;
141 : : ListCell *l;
142 : :
143 : : /*
144 : : * Start scan on-demand - initializing a scan isn't free (e.g. heap stats
145 : : * the size of the table), so it makes sense to delay that until needed -
146 : : * the node might never get executed.
147 : : */
148 [ + + ]: 467 : if (tidstate->ss.ss_currentScanDesc == NULL)
149 : 463 : tidstate->ss.ss_currentScanDesc =
150 : 463 : table_beginscan_tid(tidstate->ss.ss_currentRelation,
151 : 463 : tidstate->ss.ps.state->es_snapshot);
152 : 467 : scan = tidstate->ss.ss_currentScanDesc;
153 : :
154 : : /*
155 : : * We initialize the array with enough slots for the case that all quals
156 : : * are simple OpExprs or CurrentOfExprs. If there are any
157 : : * ScalarArrayOpExprs, we may have to enlarge the array.
158 : : */
159 : 467 : numAllocTids = list_length(tidstate->tss_tidexprs);
160 : : tidList = (ItemPointerData *)
161 : 467 : palloc(numAllocTids * sizeof(ItemPointerData));
162 : 467 : numTids = 0;
163 : :
164 [ + - + + : 904 : foreach(l, tidstate->tss_tidexprs)
+ + ]
165 : : {
166 : 477 : TidExpr *tidexpr = (TidExpr *) lfirst(l);
167 : : ItemPointer itemptr;
168 : : bool isNull;
169 : :
170 [ + + + + ]: 477 : if (tidexpr->exprstate && !tidexpr->isarray)
171 : : {
172 : : itemptr = (ItemPointer)
173 : 180 : DatumGetPointer(ExecEvalExprSwitchContext(tidexpr->exprstate,
174 : : econtext,
175 : : &isNull));
176 [ - + ]: 180 : if (isNull)
177 : 0 : continue;
178 : :
179 : : /*
180 : : * We silently discard any TIDs that the AM considers invalid
181 : : * (E.g. for heap, they could be out of range at the time of scan
182 : : * start. Since we hold at least AccessShareLock on the table, it
183 : : * won't be possible for someone to truncate away the blocks we
184 : : * intend to visit.).
185 : : */
186 [ - + ]: 180 : if (!table_tuple_tid_valid(scan, itemptr))
187 : 0 : continue;
188 : :
189 [ + + ]: 180 : if (numTids >= numAllocTids)
190 : : {
191 : 4 : numAllocTids *= 2;
192 : : tidList = (ItemPointerData *)
193 : 4 : repalloc(tidList,
194 : : numAllocTids * sizeof(ItemPointerData));
195 : : }
196 : 180 : tidList[numTids++] = *itemptr;
197 : : }
198 [ + + + - ]: 297 : else if (tidexpr->exprstate && tidexpr->isarray)
199 : 29 : {
200 : : Datum arraydatum;
201 : : ArrayType *itemarray;
202 : : Datum *ipdatums;
203 : : bool *ipnulls;
204 : : int ndatums;
205 : : int i;
206 : :
207 : 29 : arraydatum = ExecEvalExprSwitchContext(tidexpr->exprstate,
208 : : econtext,
209 : : &isNull);
210 [ - + ]: 29 : if (isNull)
211 : 0 : continue;
212 : 29 : itemarray = DatumGetArrayTypeP(arraydatum);
213 : 29 : deconstruct_array_builtin(itemarray, TIDOID, &ipdatums, &ipnulls, &ndatums);
214 [ + + ]: 29 : if (numTids + ndatums > numAllocTids)
215 : : {
216 : 25 : numAllocTids = numTids + ndatums;
217 : : tidList = (ItemPointerData *)
218 : 25 : repalloc(tidList,
219 : : numAllocTids * sizeof(ItemPointerData));
220 : : }
221 [ + + ]: 102 : for (i = 0; i < ndatums; i++)
222 : : {
223 [ - + ]: 73 : if (ipnulls[i])
224 : 0 : continue;
225 : :
226 : 73 : itemptr = (ItemPointer) DatumGetPointer(ipdatums[i]);
227 : :
228 [ + + ]: 73 : if (!table_tuple_tid_valid(scan, itemptr))
229 : 12 : continue;
230 : :
231 : 61 : tidList[numTids++] = *itemptr;
232 : : }
233 : 29 : pfree(ipdatums);
234 : 29 : pfree(ipnulls);
235 : : }
236 : : else
237 : : {
238 : : ItemPointerData cursor_tid;
239 : :
240 : : Assert(tidexpr->cexpr);
241 [ + + ]: 228 : if (execCurrentOf(tidexpr->cexpr, econtext,
242 : 268 : RelationGetRelid(tidstate->ss.ss_currentRelation),
243 : : &cursor_tid))
244 : : {
245 [ - + ]: 195 : if (numTids >= numAllocTids)
246 : : {
247 : 0 : numAllocTids *= 2;
248 : : tidList = (ItemPointerData *)
249 : 0 : repalloc(tidList,
250 : : numAllocTids * sizeof(ItemPointerData));
251 : : }
252 : 195 : tidList[numTids++] = cursor_tid;
253 : : }
254 : : }
255 : : }
256 : :
257 : : /*
258 : : * Sort the array of TIDs into order, and eliminate duplicates.
259 : : * Eliminating duplicates is necessary since we want OR semantics across
260 : : * the list. Sorting makes it easier to detect duplicates, and as a bonus
261 : : * ensures that we will visit the heap in the most efficient way.
262 : : */
263 [ + + ]: 427 : if (numTids > 1)
264 : : {
265 : : /* CurrentOfExpr could never appear OR'd with something else */
266 : : Assert(!tidstate->tss_isCurrentOf);
267 : :
268 : 35 : qsort(tidList, numTids, sizeof(ItemPointerData),
269 : : itemptr_comparator);
270 : 35 : numTids = qunique(tidList, numTids, sizeof(ItemPointerData),
271 : : itemptr_comparator);
272 : : }
273 : :
274 : 427 : tidstate->tss_TidList = tidList;
275 : 427 : tidstate->tss_NumTids = numTids;
276 : 427 : tidstate->tss_TidPtr = -1;
277 : 427 : }
278 : :
279 : : /*
280 : : * qsort comparator for ItemPointerData items
281 : : */
282 : : static int
283 : 90 : itemptr_comparator(const void *a, const void *b)
284 : : {
285 : 90 : const ItemPointerData *ipa = (const ItemPointerData *) a;
286 : 90 : const ItemPointerData *ipb = (const ItemPointerData *) b;
287 : 90 : BlockNumber ba = ItemPointerGetBlockNumber(ipa);
288 : 90 : BlockNumber bb = ItemPointerGetBlockNumber(ipb);
289 : 90 : OffsetNumber oa = ItemPointerGetOffsetNumber(ipa);
290 : 90 : OffsetNumber ob = ItemPointerGetOffsetNumber(ipb);
291 : :
292 [ + + ]: 90 : if (ba < bb)
293 : 4 : return -1;
294 [ + + ]: 86 : if (ba > bb)
295 : 4 : return 1;
296 [ + + ]: 82 : if (oa < ob)
297 : 30 : return -1;
298 [ + + ]: 52 : if (oa > ob)
299 : 51 : return 1;
300 : 1 : return 0;
301 : : }
302 : :
303 : : /* ----------------------------------------------------------------
304 : : * TidNext
305 : : *
306 : : * Retrieve a tuple from the TidScan node's currentRelation
307 : : * using the tids in the TidScanState information.
308 : : *
309 : : * ----------------------------------------------------------------
310 : : */
311 : : static TupleTableSlot *
312 : 850 : TidNext(TidScanState *node)
313 : : {
314 : : EState *estate;
315 : : ScanDirection direction;
316 : : Snapshot snapshot;
317 : : TableScanDesc scan;
318 : : Relation heapRelation;
319 : : TupleTableSlot *slot;
320 : : ItemPointerData *tidList;
321 : : int numTids;
322 : : bool bBackward;
323 : :
324 : : /*
325 : : * extract necessary information from tid scan node
326 : : */
327 : 850 : estate = node->ss.ps.state;
328 : 850 : direction = estate->es_direction;
329 : 850 : snapshot = estate->es_snapshot;
330 : 850 : heapRelation = node->ss.ss_currentRelation;
331 : 850 : slot = node->ss.ss_ScanTupleSlot;
332 : :
333 : : /*
334 : : * First time through, compute the list of TIDs to be visited
335 : : */
336 [ + + ]: 850 : if (node->tss_TidList == NULL)
337 : 465 : TidListEval(node);
338 : :
339 : 810 : scan = node->ss.ss_currentScanDesc;
340 : 810 : tidList = node->tss_TidList;
341 : 810 : numTids = node->tss_NumTids;
342 : :
343 : : /*
344 : : * Initialize or advance scan position, depending on direction.
345 : : */
346 : 810 : bBackward = ScanDirectionIsBackward(direction);
347 [ + + ]: 810 : if (bBackward)
348 : : {
349 [ - + ]: 4 : if (node->tss_TidPtr < 0)
350 : : {
351 : : /* initialize for backward scan */
352 : 0 : node->tss_TidPtr = numTids - 1;
353 : : }
354 : : else
355 : 4 : node->tss_TidPtr--;
356 : : }
357 : : else
358 : : {
359 [ + + ]: 806 : if (node->tss_TidPtr < 0)
360 : : {
361 : : /* initialize for forward scan */
362 : 425 : node->tss_TidPtr = 0;
363 : : }
364 : : else
365 : 381 : node->tss_TidPtr++;
366 : : }
367 : :
368 [ + - + + ]: 838 : while (node->tss_TidPtr >= 0 && node->tss_TidPtr < numTids)
369 : : {
370 : 429 : ItemPointerData tid = tidList[node->tss_TidPtr];
371 : :
372 : : /*
373 : : * For WHERE CURRENT OF, the tuple retrieved from the cursor might
374 : : * since have been updated; if so, we should fetch the version that is
375 : : * current according to our snapshot.
376 : : */
377 [ + + ]: 429 : if (node->tss_isCurrentOf)
378 : 195 : table_tuple_get_latest_tid(scan, &tid);
379 : :
380 [ + + ]: 429 : if (table_tuple_fetch_row_version(heapRelation, &tid, snapshot, slot))
381 : 393 : return slot;
382 : :
383 : : /* Bad TID or failed snapshot qual; try next */
384 [ - + ]: 28 : if (bBackward)
385 : 0 : node->tss_TidPtr--;
386 : : else
387 : 28 : node->tss_TidPtr++;
388 : :
389 [ - + ]: 28 : CHECK_FOR_INTERRUPTS();
390 : : }
391 : :
392 : : /*
393 : : * if we get here it means the tid scan failed so we are at the end of the
394 : : * scan..
395 : : */
396 : 409 : return ExecClearTuple(slot);
397 : : }
398 : :
399 : : /*
400 : : * TidRecheck -- access method routine to recheck a tuple in EvalPlanQual
401 : : */
402 : : static bool
403 : 2 : TidRecheck(TidScanState *node, TupleTableSlot *slot)
404 : : {
405 : : ItemPointer match;
406 : :
407 : : /* WHERE CURRENT OF always intends to resolve to the latest tuple */
408 [ - + ]: 2 : if (node->tss_isCurrentOf)
409 : 0 : return true;
410 : :
411 [ + - ]: 2 : if (node->tss_TidList == NULL)
412 : 2 : TidListEval(node);
413 : :
414 : : /*
415 : : * Binary search the TidList to see if this ctid is mentioned and return
416 : : * true if it is.
417 : : */
418 : 2 : match = (ItemPointer) bsearch(&slot->tts_tid, node->tss_TidList,
419 : 2 : node->tss_NumTids, sizeof(ItemPointerData),
420 : : itemptr_comparator);
421 : 2 : return match != NULL;
422 : : }
423 : :
424 : :
425 : : /* ----------------------------------------------------------------
426 : : * ExecTidScan(node)
427 : : *
428 : : * Scans the relation using tids and returns
429 : : * the next qualifying tuple in the direction specified.
430 : : * We call the ExecScan() routine and pass it the appropriate
431 : : * access method functions.
432 : : *
433 : : * Conditions:
434 : : * -- the "cursor" maintained by the AMI is positioned at the tuple
435 : : * returned previously.
436 : : *
437 : : * Initial States:
438 : : * -- the relation indicated is opened for scanning so that the
439 : : * "cursor" is positioned before the first qualifying tuple.
440 : : * -- tss_TidPtr is -1.
441 : : * ----------------------------------------------------------------
442 : : */
443 : : static TupleTableSlot *
444 : 840 : ExecTidScan(PlanState *pstate)
445 : : {
446 : 840 : TidScanState *node = castNode(TidScanState, pstate);
447 : :
448 : 840 : return ExecScan(&node->ss,
449 : : (ExecScanAccessMtd) TidNext,
450 : : (ExecScanRecheckMtd) TidRecheck);
451 : : }
452 : :
453 : : /* ----------------------------------------------------------------
454 : : * ExecReScanTidScan(node)
455 : : * ----------------------------------------------------------------
456 : : */
457 : : void
458 : 12 : ExecReScanTidScan(TidScanState *node)
459 : : {
460 [ + + ]: 12 : if (node->tss_TidList)
461 : 4 : pfree(node->tss_TidList);
462 : 12 : node->tss_TidList = NULL;
463 : 12 : node->tss_NumTids = 0;
464 : 12 : node->tss_TidPtr = -1;
465 : :
466 : : /* not really necessary, but seems good form */
467 [ + + ]: 12 : if (node->ss.ss_currentScanDesc)
468 : 4 : table_rescan(node->ss.ss_currentScanDesc, NULL);
469 : :
470 : 12 : ExecScanReScan(&node->ss);
471 : 12 : }
472 : :
473 : : /* ----------------------------------------------------------------
474 : : * ExecEndTidScan
475 : : *
476 : : * Releases any storage allocated through C routines.
477 : : * Returns nothing.
478 : : * ----------------------------------------------------------------
479 : : */
480 : : void
481 : 442 : ExecEndTidScan(TidScanState *node)
482 : : {
483 [ + + ]: 442 : if (node->ss.ss_currentScanDesc)
484 : 404 : table_endscan(node->ss.ss_currentScanDesc);
485 : 442 : }
486 : :
487 : : /* ----------------------------------------------------------------
488 : : * ExecInitTidScan
489 : : *
490 : : * Initializes the tid scan's state information, creates
491 : : * scan keys, and opens the base and tid relations.
492 : : *
493 : : * Parameters:
494 : : * node: TidScan node produced by the planner.
495 : : * estate: the execution state initialized in InitPlan.
496 : : * ----------------------------------------------------------------
497 : : */
498 : : TidScanState *
499 : 533 : ExecInitTidScan(TidScan *node, EState *estate, int eflags)
500 : : {
501 : : TidScanState *tidstate;
502 : : Relation currentRelation;
503 : :
504 : : /*
505 : : * create state structure
506 : : */
507 : 533 : tidstate = makeNode(TidScanState);
508 : 533 : tidstate->ss.ps.plan = (Plan *) node;
509 : 533 : tidstate->ss.ps.state = estate;
510 : 533 : tidstate->ss.ps.ExecProcNode = ExecTidScan;
511 : :
512 : : /*
513 : : * Miscellaneous initialization
514 : : *
515 : : * create expression context for node
516 : : */
517 : 533 : ExecAssignExprContext(estate, &tidstate->ss.ps);
518 : :
519 : : /*
520 : : * mark tid list as not computed yet
521 : : */
522 : 533 : tidstate->tss_TidList = NULL;
523 : 533 : tidstate->tss_NumTids = 0;
524 : 533 : tidstate->tss_TidPtr = -1;
525 : :
526 : : /*
527 : : * open the scan relation
528 : : */
529 : 533 : currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
530 : :
531 : 533 : tidstate->ss.ss_currentRelation = currentRelation;
532 : 533 : tidstate->ss.ss_currentScanDesc = NULL; /* no heap scan here */
533 : :
534 : : /*
535 : : * get the scan type from the relation descriptor.
536 : : */
537 : 533 : ExecInitScanTupleSlot(estate, &tidstate->ss,
538 : : RelationGetDescr(currentRelation),
539 : : table_slot_callbacks(currentRelation),
540 : : TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS);
541 : :
542 : : /*
543 : : * Initialize result type and projection.
544 : : */
545 : 533 : ExecInitResultTypeTL(&tidstate->ss.ps);
546 : 533 : ExecAssignScanProjectionInfo(&tidstate->ss);
547 : :
548 : : /*
549 : : * initialize child expressions
550 : : */
551 : 533 : tidstate->ss.ps.qual =
552 : 533 : ExecInitQual(node->scan.plan.qual, (PlanState *) tidstate);
553 : :
554 : 533 : TidExprListCreate(tidstate);
555 : :
556 : : /*
557 : : * all done.
558 : : */
559 : 533 : return tidstate;
560 : : }
|
