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 429 : TidExprListCreate(TidScanState *tidstate)
71 : {
72 429 : TidScan *node = (TidScan *) tidstate->ss.ps.plan;
73 : ListCell *l;
74 :
75 429 : tidstate->tss_tidexprs = NIL;
76 429 : tidstate->tss_isCurrentOf = false;
77 :
78 872 : foreach(l, node->tidquals)
79 : {
80 443 : Expr *expr = (Expr *) lfirst(l);
81 443 : TidExpr *tidexpr = palloc0_object(TidExpr);
82 :
83 443 : if (is_opclause(expr))
84 : {
85 : Node *arg1;
86 : Node *arg2;
87 :
88 192 : arg1 = get_leftop(expr);
89 192 : arg2 = get_rightop(expr);
90 192 : if (IsCTIDVar(arg1))
91 168 : tidexpr->exprstate = ExecInitExpr((Expr *) arg2,
92 : &tidstate->ss.ps);
93 24 : else if (IsCTIDVar(arg2))
94 24 : tidexpr->exprstate = ExecInitExpr((Expr *) arg1,
95 : &tidstate->ss.ps);
96 : else
97 0 : elog(ERROR, "could not identify CTID variable");
98 192 : tidexpr->isarray = false;
99 : }
100 251 : else if (expr && IsA(expr, ScalarArrayOpExpr))
101 25 : {
102 25 : ScalarArrayOpExpr *saex = (ScalarArrayOpExpr *) expr;
103 :
104 : Assert(IsCTIDVar(linitial(saex->args)));
105 25 : tidexpr->exprstate = ExecInitExpr(lsecond(saex->args),
106 : &tidstate->ss.ps);
107 25 : tidexpr->isarray = true;
108 : }
109 226 : else if (expr && IsA(expr, CurrentOfExpr))
110 226 : {
111 226 : CurrentOfExpr *cexpr = (CurrentOfExpr *) expr;
112 :
113 226 : tidexpr->cexpr = cexpr;
114 226 : tidstate->tss_isCurrentOf = true;
115 : }
116 : else
117 0 : elog(ERROR, "could not identify CTID expression");
118 :
119 443 : 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 429 : }
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 381 : TidListEval(TidScanState *tidstate)
135 : {
136 381 : 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 381 : if (tidstate->ss.ss_currentScanDesc == NULL)
149 378 : tidstate->ss.ss_currentScanDesc =
150 378 : table_beginscan_tid(tidstate->ss.ss_currentRelation,
151 378 : tidstate->ss.ps.state->es_snapshot);
152 381 : 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 381 : numAllocTids = list_length(tidstate->tss_tidexprs);
160 : tidList = (ItemPointerData *)
161 381 : palloc(numAllocTids * sizeof(ItemPointerData));
162 381 : numTids = 0;
163 :
164 740 : foreach(l, tidstate->tss_tidexprs)
165 : {
166 389 : TidExpr *tidexpr = (TidExpr *) lfirst(l);
167 : ItemPointer itemptr;
168 : bool isNull;
169 :
170 389 : if (tidexpr->exprstate && !tidexpr->isarray)
171 : {
172 : itemptr = (ItemPointer)
173 171 : DatumGetPointer(ExecEvalExprSwitchContext(tidexpr->exprstate,
174 : econtext,
175 : &isNull));
176 171 : 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 171 : if (!table_tuple_tid_valid(scan, itemptr))
187 0 : continue;
188 :
189 171 : if (numTids >= numAllocTids)
190 : {
191 3 : numAllocTids *= 2;
192 : tidList = (ItemPointerData *)
193 3 : repalloc(tidList,
194 : numAllocTids * sizeof(ItemPointerData));
195 : }
196 171 : tidList[numTids++] = *itemptr;
197 : }
198 218 : else if (tidexpr->exprstate && tidexpr->isarray)
199 22 : {
200 : Datum arraydatum;
201 : ArrayType *itemarray;
202 : Datum *ipdatums;
203 : bool *ipnulls;
204 : int ndatums;
205 : int i;
206 :
207 22 : arraydatum = ExecEvalExprSwitchContext(tidexpr->exprstate,
208 : econtext,
209 : &isNull);
210 22 : if (isNull)
211 0 : continue;
212 22 : itemarray = DatumGetArrayTypeP(arraydatum);
213 22 : deconstruct_array_builtin(itemarray, TIDOID, &ipdatums, &ipnulls, &ndatums);
214 22 : if (numTids + ndatums > numAllocTids)
215 : {
216 19 : numAllocTids = numTids + ndatums;
217 : tidList = (ItemPointerData *)
218 19 : repalloc(tidList,
219 : numAllocTids * sizeof(ItemPointerData));
220 : }
221 78 : for (i = 0; i < ndatums; i++)
222 : {
223 56 : if (ipnulls[i])
224 0 : continue;
225 :
226 56 : itemptr = (ItemPointer) DatumGetPointer(ipdatums[i]);
227 :
228 56 : if (!table_tuple_tid_valid(scan, itemptr))
229 9 : continue;
230 :
231 47 : tidList[numTids++] = *itemptr;
232 : }
233 22 : pfree(ipdatums);
234 22 : pfree(ipnulls);
235 : }
236 : else
237 : {
238 : ItemPointerData cursor_tid;
239 :
240 : Assert(tidexpr->cexpr);
241 166 : if (execCurrentOf(tidexpr->cexpr, econtext,
242 196 : RelationGetRelid(tidstate->ss.ss_currentRelation),
243 : &cursor_tid))
244 : {
245 141 : if (numTids >= numAllocTids)
246 : {
247 0 : numAllocTids *= 2;
248 : tidList = (ItemPointerData *)
249 0 : repalloc(tidList,
250 : numAllocTids * sizeof(ItemPointerData));
251 : }
252 141 : 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 351 : if (numTids > 1)
264 : {
265 : /* CurrentOfExpr could never appear OR'd with something else */
266 : Assert(!tidstate->tss_isCurrentOf);
267 :
268 27 : qsort(tidList, numTids, sizeof(ItemPointerData),
269 : itemptr_comparator);
270 27 : numTids = qunique(tidList, numTids, sizeof(ItemPointerData),
271 : itemptr_comparator);
272 : }
273 :
274 351 : tidstate->tss_TidList = tidList;
275 351 : tidstate->tss_NumTids = numTids;
276 351 : tidstate->tss_TidPtr = -1;
277 351 : }
278 :
279 : /*
280 : * qsort comparator for ItemPointerData items
281 : */
282 : static int
283 71 : itemptr_comparator(const void *a, const void *b)
284 : {
285 71 : const ItemPointerData *ipa = (const ItemPointerData *) a;
286 71 : const ItemPointerData *ipb = (const ItemPointerData *) b;
287 71 : BlockNumber ba = ItemPointerGetBlockNumber(ipa);
288 71 : BlockNumber bb = ItemPointerGetBlockNumber(ipb);
289 71 : OffsetNumber oa = ItemPointerGetOffsetNumber(ipa);
290 71 : OffsetNumber ob = ItemPointerGetOffsetNumber(ipb);
291 :
292 71 : if (ba < bb)
293 4 : return -1;
294 67 : if (ba > bb)
295 4 : return 1;
296 63 : if (oa < ob)
297 23 : return -1;
298 40 : if (oa > ob)
299 39 : 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 696 : 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 696 : estate = node->ss.ps.state;
328 696 : direction = estate->es_direction;
329 696 : snapshot = estate->es_snapshot;
330 696 : heapRelation = node->ss.ss_currentRelation;
331 696 : slot = node->ss.ss_ScanTupleSlot;
332 :
333 : /*
334 : * First time through, compute the list of TIDs to be visited
335 : */
336 696 : if (node->tss_TidList == NULL)
337 379 : TidListEval(node);
338 :
339 666 : scan = node->ss.ss_currentScanDesc;
340 666 : tidList = node->tss_TidList;
341 666 : numTids = node->tss_NumTids;
342 :
343 : /*
344 : * Initialize or advance scan position, depending on direction.
345 : */
346 666 : bBackward = ScanDirectionIsBackward(direction);
347 666 : if (bBackward)
348 : {
349 3 : if (node->tss_TidPtr < 0)
350 : {
351 : /* initialize for backward scan */
352 0 : node->tss_TidPtr = numTids - 1;
353 : }
354 : else
355 3 : node->tss_TidPtr--;
356 : }
357 : else
358 : {
359 663 : if (node->tss_TidPtr < 0)
360 : {
361 : /* initialize for forward scan */
362 349 : node->tss_TidPtr = 0;
363 : }
364 : else
365 314 : node->tss_TidPtr++;
366 : }
367 :
368 688 : while (node->tss_TidPtr >= 0 && node->tss_TidPtr < numTids)
369 : {
370 353 : 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 353 : if (node->tss_isCurrentOf)
378 141 : table_tuple_get_latest_tid(scan, &tid);
379 :
380 353 : if (table_tuple_fetch_row_version(heapRelation, &tid, snapshot, slot))
381 323 : return slot;
382 :
383 : /* Bad TID or failed snapshot qual; try next */
384 22 : if (bBackward)
385 0 : node->tss_TidPtr--;
386 : else
387 22 : node->tss_TidPtr++;
388 :
389 22 : 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 335 : 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 689 : ExecTidScan(PlanState *pstate)
445 : {
446 689 : TidScanState *node = castNode(TidScanState, pstate);
447 :
448 689 : return ExecScan(&node->ss,
449 : (ExecScanAccessMtd) TidNext,
450 : (ExecScanRecheckMtd) TidRecheck);
451 : }
452 :
453 : /* ----------------------------------------------------------------
454 : * ExecReScanTidScan(node)
455 : * ----------------------------------------------------------------
456 : */
457 : void
458 9 : ExecReScanTidScan(TidScanState *node)
459 : {
460 9 : if (node->tss_TidList)
461 3 : pfree(node->tss_TidList);
462 9 : node->tss_TidList = NULL;
463 9 : node->tss_NumTids = 0;
464 9 : node->tss_TidPtr = -1;
465 :
466 : /* not really necessary, but seems good form */
467 9 : if (node->ss.ss_currentScanDesc)
468 3 : table_rescan(node->ss.ss_currentScanDesc, NULL);
469 :
470 9 : ExecScanReScan(&node->ss);
471 9 : }
472 :
473 : /* ----------------------------------------------------------------
474 : * ExecEndTidScan
475 : *
476 : * Releases any storage allocated through C routines.
477 : * Returns nothing.
478 : * ----------------------------------------------------------------
479 : */
480 : void
481 358 : ExecEndTidScan(TidScanState *node)
482 : {
483 358 : if (node->ss.ss_currentScanDesc)
484 331 : table_endscan(node->ss.ss_currentScanDesc);
485 358 : }
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 429 : ExecInitTidScan(TidScan *node, EState *estate, int eflags)
500 : {
501 : TidScanState *tidstate;
502 : Relation currentRelation;
503 :
504 : /*
505 : * create state structure
506 : */
507 429 : tidstate = makeNode(TidScanState);
508 429 : tidstate->ss.ps.plan = (Plan *) node;
509 429 : tidstate->ss.ps.state = estate;
510 429 : tidstate->ss.ps.ExecProcNode = ExecTidScan;
511 :
512 : /*
513 : * Miscellaneous initialization
514 : *
515 : * create expression context for node
516 : */
517 429 : ExecAssignExprContext(estate, &tidstate->ss.ps);
518 :
519 : /*
520 : * mark tid list as not computed yet
521 : */
522 429 : tidstate->tss_TidList = NULL;
523 429 : tidstate->tss_NumTids = 0;
524 429 : tidstate->tss_TidPtr = -1;
525 :
526 : /*
527 : * open the scan relation
528 : */
529 429 : currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
530 :
531 429 : tidstate->ss.ss_currentRelation = currentRelation;
532 429 : tidstate->ss.ss_currentScanDesc = NULL; /* no heap scan here */
533 :
534 : /*
535 : * get the scan type from the relation descriptor.
536 : */
537 429 : ExecInitScanTupleSlot(estate, &tidstate->ss,
538 : RelationGetDescr(currentRelation),
539 : table_slot_callbacks(currentRelation));
540 :
541 : /*
542 : * Initialize result type and projection.
543 : */
544 429 : ExecInitResultTypeTL(&tidstate->ss.ps);
545 429 : ExecAssignScanProjectionInfo(&tidstate->ss);
546 :
547 : /*
548 : * initialize child expressions
549 : */
550 429 : tidstate->ss.ps.qual =
551 429 : ExecInitQual(node->scan.plan.qual, (PlanState *) tidstate);
552 :
553 429 : TidExprListCreate(tidstate);
554 :
555 : /*
556 : * all done.
557 : */
558 429 : return tidstate;
559 : }
|
