Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * execTuples.c
4 : * Routines dealing with TupleTableSlots. These are used for resource
5 : * management associated with tuples (eg, releasing buffer pins for
6 : * tuples in disk buffers, or freeing the memory occupied by transient
7 : * tuples). Slots also provide access abstraction that lets us implement
8 : * "virtual" tuples to reduce data-copying overhead.
9 : *
10 : * Routines dealing with the type information for tuples. Currently,
11 : * the type information for a tuple is an array of FormData_pg_attribute.
12 : * This information is needed by routines manipulating tuples
13 : * (getattribute, formtuple, etc.).
14 : *
15 : *
16 : * EXAMPLE OF HOW TABLE ROUTINES WORK
17 : * Suppose we have a query such as SELECT emp.name FROM emp and we have
18 : * a single SeqScan node in the query plan.
19 : *
20 : * At ExecutorStart()
21 : * ----------------
22 : *
23 : * - ExecInitSeqScan() calls ExecInitScanTupleSlot() to construct a
24 : * TupleTableSlots for the tuples returned by the access method, and
25 : * ExecInitResultTypeTL() to define the node's return
26 : * type. ExecAssignScanProjectionInfo() will, if necessary, create
27 : * another TupleTableSlot for the tuples resulting from performing
28 : * target list projections.
29 : *
30 : * During ExecutorRun()
31 : * ----------------
32 : * - SeqNext() calls ExecStoreBufferHeapTuple() to place the tuple
33 : * returned by the access method into the scan tuple slot.
34 : *
35 : * - ExecSeqScan() (via ExecScan), if necessary, calls ExecProject(),
36 : * putting the result of the projection in the result tuple slot. If
37 : * not necessary, it directly returns the slot returned by SeqNext().
38 : *
39 : * - ExecutePlan() calls the output function.
40 : *
41 : * The important thing to watch in the executor code is how pointers
42 : * to the slots containing tuples are passed instead of the tuples
43 : * themselves. This facilitates the communication of related information
44 : * (such as whether or not a tuple should be pfreed, what buffer contains
45 : * this tuple, the tuple's tuple descriptor, etc). It also allows us
46 : * to avoid physically constructing projection tuples in many cases.
47 : *
48 : *
49 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
50 : * Portions Copyright (c) 1994, Regents of the University of California
51 : *
52 : *
53 : * IDENTIFICATION
54 : * src/backend/executor/execTuples.c
55 : *
56 : *-------------------------------------------------------------------------
57 : */
58 : #include "postgres.h"
59 :
60 : #include "access/heaptoast.h"
61 : #include "access/htup_details.h"
62 : #include "access/tupdesc_details.h"
63 : #include "access/xact.h"
64 : #include "catalog/pg_type.h"
65 : #include "funcapi.h"
66 : #include "nodes/nodeFuncs.h"
67 : #include "storage/bufmgr.h"
68 : #include "utils/builtins.h"
69 : #include "utils/expandeddatum.h"
70 : #include "utils/lsyscache.h"
71 : #include "utils/typcache.h"
72 :
73 : static TupleDesc ExecTypeFromTLInternal(List *targetList,
74 : bool skipjunk);
75 : static pg_attribute_always_inline void slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp,
76 : int reqnatts, bool support_cstring);
77 : static inline void tts_buffer_heap_store_tuple(TupleTableSlot *slot,
78 : HeapTuple tuple,
79 : Buffer buffer,
80 : bool transfer_pin);
81 : static void tts_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, bool shouldFree);
82 :
83 :
84 : const TupleTableSlotOps TTSOpsVirtual;
85 : const TupleTableSlotOps TTSOpsHeapTuple;
86 : const TupleTableSlotOps TTSOpsMinimalTuple;
87 : const TupleTableSlotOps TTSOpsBufferHeapTuple;
88 :
89 :
90 : /*
91 : * TupleTableSlotOps implementations.
92 : */
93 :
94 : /*
95 : * TupleTableSlotOps implementation for VirtualTupleTableSlot.
96 : */
97 : static void
98 1656675 : tts_virtual_init(TupleTableSlot *slot)
99 : {
100 1656675 : }
101 :
102 : static void
103 1636942 : tts_virtual_release(TupleTableSlot *slot)
104 : {
105 1636942 : }
106 :
107 : static void
108 59521681 : tts_virtual_clear(TupleTableSlot *slot)
109 : {
110 59521681 : if (unlikely(TTS_SHOULDFREE(slot)))
111 : {
112 1206316 : VirtualTupleTableSlot *vslot = (VirtualTupleTableSlot *) slot;
113 :
114 1206316 : pfree(vslot->data);
115 1206316 : vslot->data = NULL;
116 :
117 1206316 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
118 : }
119 :
120 59521681 : slot->tts_nvalid = 0;
121 59521681 : slot->tts_flags |= TTS_FLAG_EMPTY;
122 59521681 : ItemPointerSetInvalid(&slot->tts_tid);
123 59521681 : }
124 :
125 : /*
126 : * VirtualTupleTableSlots always have fully populated tts_values and
127 : * tts_isnull arrays. So this function should never be called.
128 : */
129 : static void
130 0 : tts_virtual_getsomeattrs(TupleTableSlot *slot, int natts)
131 : {
132 0 : elog(ERROR, "getsomeattrs is not required to be called on a virtual tuple table slot");
133 : }
134 :
135 : /*
136 : * VirtualTupleTableSlots never provide system attributes (except those
137 : * handled generically, such as tableoid). We generally shouldn't get
138 : * here, but provide a user-friendly message if we do.
139 : */
140 : static Datum
141 8 : tts_virtual_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
142 : {
143 : Assert(!TTS_EMPTY(slot));
144 :
145 8 : ereport(ERROR,
146 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
147 : errmsg("cannot retrieve a system column in this context")));
148 :
149 : return 0; /* silence compiler warnings */
150 : }
151 :
152 : /*
153 : * VirtualTupleTableSlots never have storage tuples. We generally
154 : * shouldn't get here, but provide a user-friendly message if we do.
155 : */
156 : static bool
157 0 : tts_virtual_is_current_xact_tuple(TupleTableSlot *slot)
158 : {
159 : Assert(!TTS_EMPTY(slot));
160 :
161 0 : ereport(ERROR,
162 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
163 : errmsg("don't have transaction information for this type of tuple")));
164 :
165 : return false; /* silence compiler warnings */
166 : }
167 :
168 : /*
169 : * To materialize a virtual slot all the datums that aren't passed by value
170 : * have to be copied into the slot's memory context. To do so, compute the
171 : * required size, and allocate enough memory to store all attributes. That's
172 : * good for cache hit ratio, but more importantly requires only memory
173 : * allocation/deallocation.
174 : */
175 : static void
176 2842154 : tts_virtual_materialize(TupleTableSlot *slot)
177 : {
178 2842154 : VirtualTupleTableSlot *vslot = (VirtualTupleTableSlot *) slot;
179 2842154 : TupleDesc desc = slot->tts_tupleDescriptor;
180 2842154 : Size sz = 0;
181 : char *data;
182 :
183 : /* already materialized */
184 2842154 : if (TTS_SHOULDFREE(slot))
185 232135 : return;
186 :
187 : /* compute size of memory required */
188 8287627 : for (int natt = 0; natt < desc->natts; natt++)
189 : {
190 5677608 : CompactAttribute *att = TupleDescCompactAttr(desc, natt);
191 : Datum val;
192 :
193 5677608 : if (att->attbyval || slot->tts_isnull[natt])
194 4209735 : continue;
195 :
196 1467873 : val = slot->tts_values[natt];
197 :
198 2586229 : if (att->attlen == -1 &&
199 1118356 : VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(val)))
200 : {
201 : /*
202 : * We want to flatten the expanded value so that the materialized
203 : * slot doesn't depend on it.
204 : */
205 0 : sz = att_nominal_alignby(sz, att->attalignby);
206 0 : sz += EOH_get_flat_size(DatumGetEOHP(val));
207 : }
208 : else
209 : {
210 1467873 : sz = att_nominal_alignby(sz, att->attalignby);
211 1467873 : sz = att_addlength_datum(sz, att->attlen, val);
212 : }
213 : }
214 :
215 : /* all data is byval */
216 2610019 : if (sz == 0)
217 1403624 : return;
218 :
219 : /* allocate memory */
220 1206395 : vslot->data = data = MemoryContextAlloc(slot->tts_mcxt, sz);
221 1206395 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
222 :
223 : /* and copy all attributes into the pre-allocated space */
224 4687678 : for (int natt = 0; natt < desc->natts; natt++)
225 : {
226 3481283 : CompactAttribute *att = TupleDescCompactAttr(desc, natt);
227 : Datum val;
228 :
229 3481283 : if (att->attbyval || slot->tts_isnull[natt])
230 2013410 : continue;
231 :
232 1467873 : val = slot->tts_values[natt];
233 :
234 2586229 : if (att->attlen == -1 &&
235 1118356 : VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(val)))
236 0 : {
237 : Size data_length;
238 :
239 : /*
240 : * We want to flatten the expanded value so that the materialized
241 : * slot doesn't depend on it.
242 : */
243 0 : ExpandedObjectHeader *eoh = DatumGetEOHP(val);
244 :
245 0 : data = (char *) att_nominal_alignby(data,
246 : att->attalignby);
247 0 : data_length = EOH_get_flat_size(eoh);
248 0 : EOH_flatten_into(eoh, data, data_length);
249 :
250 0 : slot->tts_values[natt] = PointerGetDatum(data);
251 0 : data += data_length;
252 : }
253 : else
254 : {
255 1467873 : Size data_length = 0;
256 :
257 1467873 : data = (char *) att_nominal_alignby(data, att->attalignby);
258 1467873 : data_length = att_addlength_datum(data_length, att->attlen, val);
259 :
260 1467873 : memcpy(data, DatumGetPointer(val), data_length);
261 :
262 1467873 : slot->tts_values[natt] = PointerGetDatum(data);
263 1467873 : data += data_length;
264 : }
265 : }
266 : }
267 :
268 : static void
269 90731 : tts_virtual_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
270 : {
271 90731 : TupleDesc srcdesc = srcslot->tts_tupleDescriptor;
272 :
273 90731 : tts_virtual_clear(dstslot);
274 :
275 90731 : slot_getallattrs(srcslot);
276 :
277 186396 : for (int natt = 0; natt < srcdesc->natts; natt++)
278 : {
279 95665 : dstslot->tts_values[natt] = srcslot->tts_values[natt];
280 95665 : dstslot->tts_isnull[natt] = srcslot->tts_isnull[natt];
281 : }
282 :
283 90731 : dstslot->tts_nvalid = srcdesc->natts;
284 90731 : dstslot->tts_flags &= ~TTS_FLAG_EMPTY;
285 :
286 : /* make sure storage doesn't depend on external memory */
287 90731 : tts_virtual_materialize(dstslot);
288 90731 : }
289 :
290 : static HeapTuple
291 9376290 : tts_virtual_copy_heap_tuple(TupleTableSlot *slot)
292 : {
293 : Assert(!TTS_EMPTY(slot));
294 :
295 18752580 : return heap_form_tuple(slot->tts_tupleDescriptor,
296 9376290 : slot->tts_values,
297 9376290 : slot->tts_isnull);
298 : }
299 :
300 : static MinimalTuple
301 18722060 : tts_virtual_copy_minimal_tuple(TupleTableSlot *slot, Size extra)
302 : {
303 : Assert(!TTS_EMPTY(slot));
304 :
305 37444120 : return heap_form_minimal_tuple(slot->tts_tupleDescriptor,
306 18722060 : slot->tts_values,
307 18722060 : slot->tts_isnull,
308 : extra);
309 : }
310 :
311 :
312 : /*
313 : * TupleTableSlotOps implementation for HeapTupleTableSlot.
314 : */
315 :
316 : static void
317 2466407 : tts_heap_init(TupleTableSlot *slot)
318 : {
319 2466407 : }
320 :
321 : static void
322 2465746 : tts_heap_release(TupleTableSlot *slot)
323 : {
324 2465746 : }
325 :
326 : static void
327 6335294 : tts_heap_clear(TupleTableSlot *slot)
328 : {
329 6335294 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
330 :
331 : /* Free the memory for the heap tuple if it's allowed. */
332 6335294 : if (TTS_SHOULDFREE(slot))
333 : {
334 1058775 : heap_freetuple(hslot->tuple);
335 1058775 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
336 : }
337 :
338 6335294 : slot->tts_nvalid = 0;
339 6335294 : slot->tts_flags |= TTS_FLAG_EMPTY;
340 6335294 : ItemPointerSetInvalid(&slot->tts_tid);
341 6335294 : hslot->off = 0;
342 6335294 : hslot->tuple = NULL;
343 6335294 : }
344 :
345 : static void
346 6398965 : tts_heap_getsomeattrs(TupleTableSlot *slot, int natts)
347 : {
348 6398965 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
349 :
350 : Assert(!TTS_EMPTY(slot));
351 :
352 6398965 : slot_deform_heap_tuple(slot, hslot->tuple, &hslot->off, natts, false);
353 6398965 : }
354 :
355 : static Datum
356 0 : tts_heap_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
357 : {
358 0 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
359 :
360 : Assert(!TTS_EMPTY(slot));
361 :
362 : /*
363 : * In some code paths it's possible to get here with a non-materialized
364 : * slot, in which case we can't retrieve system columns.
365 : */
366 0 : if (!hslot->tuple)
367 0 : ereport(ERROR,
368 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
369 : errmsg("cannot retrieve a system column in this context")));
370 :
371 0 : return heap_getsysattr(hslot->tuple, attnum,
372 : slot->tts_tupleDescriptor, isnull);
373 : }
374 :
375 : static bool
376 0 : tts_heap_is_current_xact_tuple(TupleTableSlot *slot)
377 : {
378 0 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
379 : TransactionId xmin;
380 :
381 : Assert(!TTS_EMPTY(slot));
382 :
383 : /*
384 : * In some code paths it's possible to get here with a non-materialized
385 : * slot, in which case we can't check if tuple is created by the current
386 : * transaction.
387 : */
388 0 : if (!hslot->tuple)
389 0 : ereport(ERROR,
390 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
391 : errmsg("don't have a storage tuple in this context")));
392 :
393 0 : xmin = HeapTupleHeaderGetRawXmin(hslot->tuple->t_data);
394 :
395 0 : return TransactionIdIsCurrentTransactionId(xmin);
396 : }
397 :
398 : static void
399 2116295 : tts_heap_materialize(TupleTableSlot *slot)
400 : {
401 2116295 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
402 : MemoryContext oldContext;
403 :
404 : Assert(!TTS_EMPTY(slot));
405 :
406 : /* If slot has its tuple already materialized, nothing to do. */
407 2116295 : if (TTS_SHOULDFREE(slot))
408 1058509 : return;
409 :
410 1057786 : oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
411 :
412 : /*
413 : * Have to deform from scratch, otherwise tts_values[] entries could point
414 : * into the non-materialized tuple (which might be gone when accessed).
415 : */
416 1057786 : slot->tts_nvalid = 0;
417 1057786 : hslot->off = 0;
418 :
419 1057786 : if (!hslot->tuple)
420 1057779 : hslot->tuple = heap_form_tuple(slot->tts_tupleDescriptor,
421 1057779 : slot->tts_values,
422 1057779 : slot->tts_isnull);
423 : else
424 : {
425 : /*
426 : * The tuple contained in this slot is not allocated in the memory
427 : * context of the given slot (else it would have TTS_FLAG_SHOULDFREE
428 : * set). Copy the tuple into the given slot's memory context.
429 : */
430 7 : hslot->tuple = heap_copytuple(hslot->tuple);
431 : }
432 :
433 1057786 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
434 :
435 1057786 : MemoryContextSwitchTo(oldContext);
436 : }
437 :
438 : static void
439 900 : tts_heap_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
440 : {
441 : HeapTuple tuple;
442 : MemoryContext oldcontext;
443 :
444 900 : oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
445 900 : tuple = ExecCopySlotHeapTuple(srcslot);
446 900 : MemoryContextSwitchTo(oldcontext);
447 :
448 900 : ExecStoreHeapTuple(tuple, dstslot, true);
449 900 : }
450 :
451 : static HeapTuple
452 2115289 : tts_heap_get_heap_tuple(TupleTableSlot *slot)
453 : {
454 2115289 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
455 :
456 : Assert(!TTS_EMPTY(slot));
457 2115289 : if (!hslot->tuple)
458 0 : tts_heap_materialize(slot);
459 :
460 2115289 : return hslot->tuple;
461 : }
462 :
463 : static HeapTuple
464 344 : tts_heap_copy_heap_tuple(TupleTableSlot *slot)
465 : {
466 344 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
467 :
468 : Assert(!TTS_EMPTY(slot));
469 344 : if (!hslot->tuple)
470 0 : tts_heap_materialize(slot);
471 :
472 344 : return heap_copytuple(hslot->tuple);
473 : }
474 :
475 : static MinimalTuple
476 2718 : tts_heap_copy_minimal_tuple(TupleTableSlot *slot, Size extra)
477 : {
478 2718 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
479 :
480 2718 : if (!hslot->tuple)
481 21 : tts_heap_materialize(slot);
482 :
483 2718 : return minimal_tuple_from_heap_tuple(hslot->tuple, extra);
484 : }
485 :
486 : static void
487 2810198 : tts_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, bool shouldFree)
488 : {
489 2810198 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
490 :
491 2810198 : tts_heap_clear(slot);
492 :
493 2810198 : slot->tts_nvalid = 0;
494 2810198 : hslot->tuple = tuple;
495 2810198 : hslot->off = 0;
496 2810198 : slot->tts_flags &= ~(TTS_FLAG_EMPTY | TTS_FLAG_SHOULDFREE);
497 2810198 : slot->tts_tid = tuple->t_self;
498 :
499 2810198 : if (shouldFree)
500 1000 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
501 2810198 : }
502 :
503 :
504 : /*
505 : * TupleTableSlotOps implementation for MinimalTupleTableSlot.
506 : */
507 :
508 : static void
509 260386 : tts_minimal_init(TupleTableSlot *slot)
510 : {
511 260386 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
512 :
513 : /*
514 : * Initialize the heap tuple pointer to access attributes of the minimal
515 : * tuple contained in the slot as if its a heap tuple.
516 : */
517 260386 : mslot->tuple = &mslot->minhdr;
518 260386 : }
519 :
520 : static void
521 227296 : tts_minimal_release(TupleTableSlot *slot)
522 : {
523 227296 : }
524 :
525 : static void
526 51174486 : tts_minimal_clear(TupleTableSlot *slot)
527 : {
528 51174486 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
529 :
530 51174486 : if (TTS_SHOULDFREE(slot))
531 : {
532 8196462 : heap_free_minimal_tuple(mslot->mintuple);
533 8196462 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
534 : }
535 :
536 51174486 : slot->tts_nvalid = 0;
537 51174486 : slot->tts_flags |= TTS_FLAG_EMPTY;
538 51174486 : ItemPointerSetInvalid(&slot->tts_tid);
539 51174486 : mslot->off = 0;
540 51174486 : mslot->mintuple = NULL;
541 51174486 : }
542 :
543 : static void
544 37814916 : tts_minimal_getsomeattrs(TupleTableSlot *slot, int natts)
545 : {
546 37814916 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
547 :
548 : Assert(!TTS_EMPTY(slot));
549 :
550 37814916 : slot_deform_heap_tuple(slot, mslot->tuple, &mslot->off, natts, true);
551 37814916 : }
552 :
553 : /*
554 : * MinimalTupleTableSlots never provide system attributes. We generally
555 : * shouldn't get here, but provide a user-friendly message if we do.
556 : */
557 : static Datum
558 0 : tts_minimal_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
559 : {
560 : Assert(!TTS_EMPTY(slot));
561 :
562 0 : ereport(ERROR,
563 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
564 : errmsg("cannot retrieve a system column in this context")));
565 :
566 : return 0; /* silence compiler warnings */
567 : }
568 :
569 : /*
570 : * Within MinimalTuple abstraction transaction information is unavailable.
571 : * We generally shouldn't get here, but provide a user-friendly message if
572 : * we do.
573 : */
574 : static bool
575 0 : tts_minimal_is_current_xact_tuple(TupleTableSlot *slot)
576 : {
577 : Assert(!TTS_EMPTY(slot));
578 :
579 0 : ereport(ERROR,
580 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
581 : errmsg("don't have transaction information for this type of tuple")));
582 :
583 : return false; /* silence compiler warnings */
584 : }
585 :
586 : static void
587 1008580 : tts_minimal_materialize(TupleTableSlot *slot)
588 : {
589 1008580 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
590 : MemoryContext oldContext;
591 :
592 : Assert(!TTS_EMPTY(slot));
593 :
594 : /* If slot has its tuple already materialized, nothing to do. */
595 1008580 : if (TTS_SHOULDFREE(slot))
596 96017 : return;
597 :
598 912563 : oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
599 :
600 : /*
601 : * Have to deform from scratch, otherwise tts_values[] entries could point
602 : * into the non-materialized tuple (which might be gone when accessed).
603 : */
604 912563 : slot->tts_nvalid = 0;
605 912563 : mslot->off = 0;
606 :
607 912563 : if (!mslot->mintuple)
608 : {
609 856905 : mslot->mintuple = heap_form_minimal_tuple(slot->tts_tupleDescriptor,
610 856905 : slot->tts_values,
611 856905 : slot->tts_isnull,
612 : 0);
613 : }
614 : else
615 : {
616 : /*
617 : * The minimal tuple contained in this slot is not allocated in the
618 : * memory context of the given slot (else it would have
619 : * TTS_FLAG_SHOULDFREE set). Copy the minimal tuple into the given
620 : * slot's memory context.
621 : */
622 55658 : mslot->mintuple = heap_copy_minimal_tuple(mslot->mintuple, 0);
623 : }
624 :
625 912563 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
626 :
627 : Assert(mslot->tuple == &mslot->minhdr);
628 :
629 912563 : mslot->minhdr.t_len = mslot->mintuple->t_len + MINIMAL_TUPLE_OFFSET;
630 912563 : mslot->minhdr.t_data = (HeapTupleHeader) ((char *) mslot->mintuple - MINIMAL_TUPLE_OFFSET);
631 :
632 912563 : MemoryContextSwitchTo(oldContext);
633 : }
634 :
635 : static void
636 777045 : tts_minimal_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
637 : {
638 : MemoryContext oldcontext;
639 : MinimalTuple mintuple;
640 :
641 777045 : oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
642 777045 : mintuple = ExecCopySlotMinimalTuple(srcslot);
643 777045 : MemoryContextSwitchTo(oldcontext);
644 :
645 777045 : ExecStoreMinimalTuple(mintuple, dstslot, true);
646 777045 : }
647 :
648 : static MinimalTuple
649 3317514 : tts_minimal_get_minimal_tuple(TupleTableSlot *slot)
650 : {
651 3317514 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
652 :
653 3317514 : if (!mslot->mintuple)
654 0 : tts_minimal_materialize(slot);
655 :
656 3317514 : return mslot->mintuple;
657 : }
658 :
659 : static HeapTuple
660 491276 : tts_minimal_copy_heap_tuple(TupleTableSlot *slot)
661 : {
662 491276 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
663 :
664 491276 : if (!mslot->mintuple)
665 938 : tts_minimal_materialize(slot);
666 :
667 491276 : return heap_tuple_from_minimal_tuple(mslot->mintuple);
668 : }
669 :
670 : static MinimalTuple
671 1854068 : tts_minimal_copy_minimal_tuple(TupleTableSlot *slot, Size extra)
672 : {
673 1854068 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
674 :
675 1854068 : if (!mslot->mintuple)
676 732419 : tts_minimal_materialize(slot);
677 :
678 1854068 : return heap_copy_minimal_tuple(mslot->mintuple, extra);
679 : }
680 :
681 : static void
682 42784622 : tts_minimal_store_tuple(TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
683 : {
684 42784622 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
685 :
686 42784622 : tts_minimal_clear(slot);
687 :
688 : Assert(!TTS_SHOULDFREE(slot));
689 : Assert(TTS_EMPTY(slot));
690 :
691 42784622 : slot->tts_flags &= ~TTS_FLAG_EMPTY;
692 42784622 : slot->tts_nvalid = 0;
693 42784622 : mslot->off = 0;
694 :
695 42784622 : mslot->mintuple = mtup;
696 : Assert(mslot->tuple == &mslot->minhdr);
697 42784622 : mslot->minhdr.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
698 42784622 : mslot->minhdr.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
699 : /* no need to set t_self or t_tableOid since we won't allow access */
700 :
701 42784622 : if (shouldFree)
702 7284929 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
703 42784622 : }
704 :
705 :
706 : /*
707 : * TupleTableSlotOps implementation for BufferHeapTupleTableSlot.
708 : */
709 :
710 : static void
711 18742577 : tts_buffer_heap_init(TupleTableSlot *slot)
712 : {
713 18742577 : }
714 :
715 : static void
716 18732996 : tts_buffer_heap_release(TupleTableSlot *slot)
717 : {
718 18732996 : }
719 :
720 : static void
721 33960754 : tts_buffer_heap_clear(TupleTableSlot *slot)
722 : {
723 33960754 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
724 :
725 : /*
726 : * Free the memory for heap tuple if allowed. A tuple coming from buffer
727 : * can never be freed. But we may have materialized a tuple from buffer.
728 : * Such a tuple can be freed.
729 : */
730 33960754 : if (TTS_SHOULDFREE(slot))
731 : {
732 : /* We should have unpinned the buffer while materializing the tuple. */
733 : Assert(!BufferIsValid(bslot->buffer));
734 :
735 8464631 : heap_freetuple(bslot->base.tuple);
736 8464631 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
737 : }
738 :
739 33960754 : if (BufferIsValid(bslot->buffer))
740 10965522 : ReleaseBuffer(bslot->buffer);
741 :
742 33960754 : slot->tts_nvalid = 0;
743 33960754 : slot->tts_flags |= TTS_FLAG_EMPTY;
744 33960754 : ItemPointerSetInvalid(&slot->tts_tid);
745 33960754 : bslot->base.tuple = NULL;
746 33960754 : bslot->base.off = 0;
747 33960754 : bslot->buffer = InvalidBuffer;
748 33960754 : }
749 :
750 : static void
751 90760048 : tts_buffer_heap_getsomeattrs(TupleTableSlot *slot, int natts)
752 : {
753 90760048 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
754 :
755 : Assert(!TTS_EMPTY(slot));
756 :
757 90760048 : slot_deform_heap_tuple(slot, bslot->base.tuple, &bslot->base.off, natts, false);
758 90760048 : }
759 :
760 : static Datum
761 72794 : tts_buffer_heap_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
762 : {
763 72794 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
764 :
765 : Assert(!TTS_EMPTY(slot));
766 :
767 : /*
768 : * In some code paths it's possible to get here with a non-materialized
769 : * slot, in which case we can't retrieve system columns.
770 : */
771 72794 : if (!bslot->base.tuple)
772 0 : ereport(ERROR,
773 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
774 : errmsg("cannot retrieve a system column in this context")));
775 :
776 72794 : return heap_getsysattr(bslot->base.tuple, attnum,
777 : slot->tts_tupleDescriptor, isnull);
778 : }
779 :
780 : static bool
781 564 : tts_buffer_is_current_xact_tuple(TupleTableSlot *slot)
782 : {
783 564 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
784 : TransactionId xmin;
785 :
786 : Assert(!TTS_EMPTY(slot));
787 :
788 : /*
789 : * In some code paths it's possible to get here with a non-materialized
790 : * slot, in which case we can't check if tuple is created by the current
791 : * transaction.
792 : */
793 564 : if (!bslot->base.tuple)
794 0 : ereport(ERROR,
795 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
796 : errmsg("don't have a storage tuple in this context")));
797 :
798 564 : xmin = HeapTupleHeaderGetRawXmin(bslot->base.tuple->t_data);
799 :
800 564 : return TransactionIdIsCurrentTransactionId(xmin);
801 : }
802 :
803 : static void
804 16778809 : tts_buffer_heap_materialize(TupleTableSlot *slot)
805 : {
806 16778809 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
807 : MemoryContext oldContext;
808 :
809 : Assert(!TTS_EMPTY(slot));
810 :
811 : /* If slot has its tuple already materialized, nothing to do. */
812 16778809 : if (TTS_SHOULDFREE(slot))
813 15200077 : return;
814 :
815 1578732 : oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
816 :
817 : /*
818 : * Have to deform from scratch, otherwise tts_values[] entries could point
819 : * into the non-materialized tuple (which might be gone when accessed).
820 : */
821 1578732 : bslot->base.off = 0;
822 1578732 : slot->tts_nvalid = 0;
823 :
824 1578732 : if (!bslot->base.tuple)
825 : {
826 : /*
827 : * Normally BufferHeapTupleTableSlot should have a tuple + buffer
828 : * associated with it, unless it's materialized (which would've
829 : * returned above). But when it's useful to allow storing virtual
830 : * tuples in a buffer slot, which then also needs to be
831 : * materializable.
832 : */
833 1340485 : bslot->base.tuple = heap_form_tuple(slot->tts_tupleDescriptor,
834 1340485 : slot->tts_values,
835 1340485 : slot->tts_isnull);
836 : }
837 : else
838 : {
839 238247 : bslot->base.tuple = heap_copytuple(bslot->base.tuple);
840 :
841 : /*
842 : * A heap tuple stored in a BufferHeapTupleTableSlot should have a
843 : * buffer associated with it, unless it's materialized or virtual.
844 : */
845 238247 : if (likely(BufferIsValid(bslot->buffer)))
846 238247 : ReleaseBuffer(bslot->buffer);
847 238247 : bslot->buffer = InvalidBuffer;
848 : }
849 :
850 : /*
851 : * We don't set TTS_FLAG_SHOULDFREE until after releasing the buffer, if
852 : * any. This avoids having a transient state that would fall foul of our
853 : * assertions that a slot with TTS_FLAG_SHOULDFREE doesn't own a buffer.
854 : * In the unlikely event that ReleaseBuffer() above errors out, we'd
855 : * effectively leak the copied tuple, but that seems fairly harmless.
856 : */
857 1578732 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
858 :
859 1578732 : MemoryContextSwitchTo(oldContext);
860 : }
861 :
862 : static void
863 7083933 : tts_buffer_heap_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
864 : {
865 7083933 : BufferHeapTupleTableSlot *bsrcslot = (BufferHeapTupleTableSlot *) srcslot;
866 7083933 : BufferHeapTupleTableSlot *bdstslot = (BufferHeapTupleTableSlot *) dstslot;
867 :
868 : /*
869 : * If the source slot is of a different kind, or is a buffer slot that has
870 : * been materialized / is virtual, make a new copy of the tuple. Otherwise
871 : * make a new reference to the in-buffer tuple.
872 : */
873 7083933 : if (dstslot->tts_ops != srcslot->tts_ops ||
874 4344 : TTS_SHOULDFREE(srcslot) ||
875 4342 : !bsrcslot->base.tuple)
876 7079591 : {
877 : MemoryContext oldContext;
878 :
879 7079591 : ExecClearTuple(dstslot);
880 7079591 : dstslot->tts_flags &= ~TTS_FLAG_EMPTY;
881 7079591 : oldContext = MemoryContextSwitchTo(dstslot->tts_mcxt);
882 7079591 : bdstslot->base.tuple = ExecCopySlotHeapTuple(srcslot);
883 7079591 : dstslot->tts_flags |= TTS_FLAG_SHOULDFREE;
884 7079591 : MemoryContextSwitchTo(oldContext);
885 : }
886 : else
887 : {
888 : Assert(BufferIsValid(bsrcslot->buffer));
889 :
890 4342 : tts_buffer_heap_store_tuple(dstslot, bsrcslot->base.tuple,
891 : bsrcslot->buffer, false);
892 :
893 : /*
894 : * The HeapTupleData portion of the source tuple might be shorter
895 : * lived than the destination slot. Therefore copy the HeapTuple into
896 : * our slot's tupdata, which is guaranteed to live long enough (but
897 : * will still point into the buffer).
898 : */
899 4342 : memcpy(&bdstslot->base.tupdata, bdstslot->base.tuple, sizeof(HeapTupleData));
900 4342 : bdstslot->base.tuple = &bdstslot->base.tupdata;
901 : }
902 7083933 : }
903 :
904 : static HeapTuple
905 24898158 : tts_buffer_heap_get_heap_tuple(TupleTableSlot *slot)
906 : {
907 24898158 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
908 :
909 : Assert(!TTS_EMPTY(slot));
910 :
911 24898158 : if (!bslot->base.tuple)
912 0 : tts_buffer_heap_materialize(slot);
913 :
914 24898158 : return bslot->base.tuple;
915 : }
916 :
917 : static HeapTuple
918 7272478 : tts_buffer_heap_copy_heap_tuple(TupleTableSlot *slot)
919 : {
920 7272478 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
921 :
922 : Assert(!TTS_EMPTY(slot));
923 :
924 7272478 : if (!bslot->base.tuple)
925 0 : tts_buffer_heap_materialize(slot);
926 :
927 7272478 : return heap_copytuple(bslot->base.tuple);
928 : }
929 :
930 : static MinimalTuple
931 1868817 : tts_buffer_heap_copy_minimal_tuple(TupleTableSlot *slot, Size extra)
932 : {
933 1868817 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
934 :
935 : Assert(!TTS_EMPTY(slot));
936 :
937 1868817 : if (!bslot->base.tuple)
938 0 : tts_buffer_heap_materialize(slot);
939 :
940 1868817 : return minimal_tuple_from_heap_tuple(bslot->base.tuple, extra);
941 : }
942 :
943 : static inline void
944 106880830 : tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple,
945 : Buffer buffer, bool transfer_pin)
946 : {
947 106880830 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
948 :
949 106880830 : if (TTS_SHOULDFREE(slot))
950 : {
951 : /* materialized slot shouldn't have a buffer to release */
952 : Assert(!BufferIsValid(bslot->buffer));
953 :
954 239392 : heap_freetuple(bslot->base.tuple);
955 239392 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
956 : }
957 :
958 106880830 : slot->tts_flags &= ~TTS_FLAG_EMPTY;
959 106880830 : slot->tts_nvalid = 0;
960 106880830 : bslot->base.tuple = tuple;
961 106880830 : bslot->base.off = 0;
962 106880830 : slot->tts_tid = tuple->t_self;
963 :
964 : /*
965 : * If tuple is on a disk page, keep the page pinned as long as we hold a
966 : * pointer into it. We assume the caller already has such a pin. If
967 : * transfer_pin is true, we'll transfer that pin to this slot, if not
968 : * we'll pin it again ourselves.
969 : *
970 : * This is coded to optimize the case where the slot previously held a
971 : * tuple on the same disk page: in that case releasing and re-acquiring
972 : * the pin is a waste of cycles. This is a common situation during
973 : * seqscans, so it's worth troubling over.
974 : */
975 106880830 : if (bslot->buffer != buffer)
976 : {
977 14636099 : if (BufferIsValid(bslot->buffer))
978 3427016 : ReleaseBuffer(bslot->buffer);
979 :
980 14636099 : bslot->buffer = buffer;
981 :
982 14636099 : if (!transfer_pin && BufferIsValid(buffer))
983 13651401 : IncrBufferRefCount(buffer);
984 : }
985 92244731 : else if (transfer_pin && BufferIsValid(buffer))
986 : {
987 : /*
988 : * In transfer_pin mode the caller won't know about the same-page
989 : * optimization, so we gotta release its pin.
990 : */
991 171204 : ReleaseBuffer(buffer);
992 : }
993 106880830 : }
994 :
995 : /*
996 : * slot_deform_heap_tuple
997 : * Given a TupleTableSlot, extract data from the slot's physical tuple
998 : * into its Datum/isnull arrays. Data is extracted up through the
999 : * reqnatts'th column. If there are insufficient attributes in the given
1000 : * tuple, then slot_getmissingattrs() is called to populate the
1001 : * remainder. If reqnatts is above the number of attributes in the
1002 : * slot's TupleDesc, an error is raised.
1003 : *
1004 : * This is essentially an incremental version of heap_deform_tuple:
1005 : * on each call we extract attributes up to the one needed, without
1006 : * re-computing information about previously extracted attributes.
1007 : * slot->tts_nvalid is the number of attributes already extracted.
1008 : *
1009 : * This is marked as always inline, so the different offp for different types
1010 : * of slots gets optimized away.
1011 : *
1012 : * support_cstring should be passed as a const to allow the compiler only
1013 : * emit code during inlining for cstring deforming when it's required.
1014 : * cstrings can exist in MinimalTuples, but not in HeapTuples.
1015 : */
1016 : static pg_attribute_always_inline void
1017 134973929 : slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp,
1018 : int reqnatts, bool support_cstring)
1019 : {
1020 : CompactAttribute *cattrs;
1021 : CompactAttribute *cattr;
1022 134973929 : TupleDesc tupleDesc = slot->tts_tupleDescriptor;
1023 134973929 : HeapTupleHeader tup = tuple->t_data;
1024 : size_t attnum;
1025 : int firstNonCacheOffsetAttr;
1026 : int firstNonGuaranteedAttr;
1027 : int firstNullAttr;
1028 : int natts;
1029 : Datum *values;
1030 : bool *isnull;
1031 : char *tp; /* ptr to tuple data */
1032 : uint32 off; /* offset in tuple data */
1033 :
1034 : /* Did someone forget to call TupleDescFinalize()? */
1035 : Assert(tupleDesc->firstNonCachedOffsetAttr >= 0);
1036 :
1037 134973929 : isnull = slot->tts_isnull;
1038 :
1039 : /*
1040 : * Some callers may form and deform tuples prior to NOT NULL constraints
1041 : * being checked. Here we'd like to optimize the case where we only need
1042 : * to fetch attributes before or up to the point where the attribute is
1043 : * guaranteed to exist in the tuple. We rely on the slot flag being set
1044 : * correctly to only enable this optimization when it's valid to do so.
1045 : * This optimization allows us to save fetching the number of attributes
1046 : * from the tuple and saves the additional cost of handling non-byval
1047 : * attrs.
1048 : */
1049 134973929 : firstNonGuaranteedAttr = Min(reqnatts, slot->tts_first_nonguaranteed);
1050 :
1051 134973929 : firstNonCacheOffsetAttr = tupleDesc->firstNonCachedOffsetAttr;
1052 :
1053 134973929 : if (HeapTupleHasNulls(tuple))
1054 : {
1055 34231494 : natts = HeapTupleHeaderGetNatts(tup);
1056 34231494 : tp = (char *) tup + MAXALIGN(offsetof(HeapTupleHeaderData, t_bits) +
1057 : BITMAPLEN(natts));
1058 :
1059 34231494 : natts = Min(natts, reqnatts);
1060 34231494 : if (natts > firstNonGuaranteedAttr)
1061 : {
1062 32322429 : bits8 *bp = tup->t_bits;
1063 :
1064 : /* Find the first NULL attr */
1065 32322429 : firstNullAttr = first_null_attr(bp, natts);
1066 :
1067 : /*
1068 : * And populate the isnull array for all attributes being fetched
1069 : * from the tuple.
1070 : */
1071 32322429 : populate_isnull_array(bp, natts, isnull);
1072 : }
1073 : else
1074 : {
1075 : /* Otherwise all required columns are guaranteed to exist */
1076 1909065 : firstNullAttr = natts;
1077 : }
1078 : }
1079 : else
1080 : {
1081 100742435 : tp = (char *) tup + MAXALIGN(offsetof(HeapTupleHeaderData, t_bits));
1082 :
1083 : /*
1084 : * We only need to look at the tuple's natts if we need more than the
1085 : * guaranteed number of columns
1086 : */
1087 100742435 : if (reqnatts > firstNonGuaranteedAttr)
1088 90897964 : natts = Min(HeapTupleHeaderGetNatts(tup), reqnatts);
1089 : else
1090 : {
1091 : /* No need to access the number of attributes in the tuple */
1092 9844471 : natts = reqnatts;
1093 : }
1094 :
1095 : /* All attrs can be fetched without checking for NULLs */
1096 100742435 : firstNullAttr = natts;
1097 : }
1098 :
1099 134973929 : attnum = slot->tts_nvalid;
1100 134973929 : values = slot->tts_values;
1101 134973929 : slot->tts_nvalid = reqnatts;
1102 :
1103 : /*
1104 : * We store the tupleDesc's CompactAttribute array in 'cattrs' as gcc
1105 : * seems to be unwilling to optimize accessing the CompactAttribute
1106 : * element efficiently when accessing it via TupleDescCompactAttr().
1107 : */
1108 134973929 : cattrs = tupleDesc->compact_attrs;
1109 :
1110 : /* Ensure we calculated tp correctly */
1111 : Assert(tp == (char *) tup + tup->t_hoff);
1112 :
1113 134973929 : if (attnum < firstNonGuaranteedAttr)
1114 : {
1115 : int attlen;
1116 :
1117 : do
1118 : {
1119 52988875 : isnull[attnum] = false;
1120 52988875 : cattr = &cattrs[attnum];
1121 52988875 : attlen = cattr->attlen;
1122 :
1123 : /* We don't expect any non-byval types */
1124 52988875 : pg_assume(attlen > 0);
1125 : Assert(cattr->attbyval == true);
1126 :
1127 52988875 : off = cattr->attcacheoff;
1128 52988875 : values[attnum] = fetch_att_noerr(tp + off, true, attlen);
1129 52988875 : attnum++;
1130 52988875 : } while (attnum < firstNonGuaranteedAttr);
1131 :
1132 33498800 : off += attlen;
1133 :
1134 33498800 : if (attnum == reqnatts)
1135 11753536 : goto done;
1136 : }
1137 : else
1138 : {
1139 : /*
1140 : * We may be incrementally deforming the tuple, so set 'off' to the
1141 : * previously cached value. This may be 0, if the slot has just
1142 : * received a new tuple.
1143 : */
1144 101475129 : off = *offp;
1145 :
1146 : /* We expect *offp to be set to 0 when attnum == 0 */
1147 : Assert(off == 0 || attnum > 0);
1148 : }
1149 :
1150 : /* We can use attcacheoff up until the first NULL */
1151 123220393 : firstNonCacheOffsetAttr = Min(firstNonCacheOffsetAttr, firstNullAttr);
1152 :
1153 : /*
1154 : * Handle the portion of the tuple that we have cached the offset for up
1155 : * to the first NULL attribute. The offset is effectively fixed for
1156 : * these, so we can use the CompactAttribute's attcacheoff.
1157 : */
1158 123220393 : if (attnum < firstNonCacheOffsetAttr)
1159 : {
1160 : int attlen;
1161 :
1162 : do
1163 : {
1164 363950292 : isnull[attnum] = false;
1165 363950292 : cattr = &cattrs[attnum];
1166 363950292 : attlen = cattr->attlen;
1167 363950292 : off = cattr->attcacheoff;
1168 727900584 : values[attnum] = fetch_att_noerr(tp + off,
1169 363950292 : cattr->attbyval,
1170 : attlen);
1171 363950292 : attnum++;
1172 363950292 : } while (attnum < firstNonCacheOffsetAttr);
1173 :
1174 : /*
1175 : * Point the offset after the end of the last attribute with a cached
1176 : * offset. We expect the final cached offset attribute to have a
1177 : * fixed width, so just add the attlen to the attcacheoff
1178 : */
1179 : Assert(attlen > 0);
1180 106636486 : off += attlen;
1181 : }
1182 :
1183 : /*
1184 : * Handle any portion of the tuple that doesn't have a fixed offset up
1185 : * until the first NULL attribute. This loop only differs from the one
1186 : * after it by the NULL checks.
1187 : */
1188 159300097 : for (; attnum < firstNullAttr; attnum++)
1189 : {
1190 : int attlen;
1191 :
1192 36079704 : isnull[attnum] = false;
1193 36079704 : cattr = &cattrs[attnum];
1194 36079704 : attlen = cattr->attlen;
1195 :
1196 : /*
1197 : * Only emit the cstring-related code in align_fetch_then_add() when
1198 : * cstring support is needed. We assume support_cstring will be
1199 : * passed as a const to allow the compiler to eliminate this branch.
1200 : */
1201 36079704 : if (!support_cstring)
1202 20892198 : pg_assume(attlen > 0 || attlen == -1);
1203 :
1204 : /* align 'off', fetch the datum, and increment off beyond the datum */
1205 36079704 : values[attnum] = align_fetch_then_add(tp,
1206 : &off,
1207 36079704 : cattr->attbyval,
1208 : attlen,
1209 36079704 : cattr->attalignby);
1210 : }
1211 :
1212 : /*
1213 : * Now handle any remaining attributes in the tuple up to the requested
1214 : * attnum. This time, include NULL checks as we're now at the first NULL
1215 : * attribute.
1216 : */
1217 173454089 : for (; attnum < natts; attnum++)
1218 : {
1219 : int attlen;
1220 :
1221 50233696 : if (isnull[attnum])
1222 : {
1223 35445595 : values[attnum] = (Datum) 0;
1224 35445595 : continue;
1225 : }
1226 :
1227 14788101 : cattr = &cattrs[attnum];
1228 14788101 : attlen = cattr->attlen;
1229 :
1230 : /* As above, only emit cstring code when needed. */
1231 14788101 : if (!support_cstring)
1232 10555944 : pg_assume(attlen > 0 || attlen == -1);
1233 :
1234 : /* align 'off', fetch the datum, and increment off beyond the datum */
1235 14788101 : values[attnum] = align_fetch_then_add(tp,
1236 : &off,
1237 14788101 : cattr->attbyval,
1238 : attlen,
1239 14788101 : cattr->attalignby);
1240 : }
1241 :
1242 : /* Fetch any missing attrs and raise an error if reqnatts is invalid */
1243 123220393 : if (unlikely(attnum < reqnatts))
1244 : {
1245 : /*
1246 : * Cache the offset before calling the function to allow the compiler
1247 : * to implement a tail-call optimization
1248 : */
1249 4831 : *offp = off;
1250 4831 : slot_getmissingattrs(slot, attnum, reqnatts);
1251 4831 : return;
1252 : }
1253 123215562 : done:
1254 :
1255 : /* Save current offset for next execution */
1256 134969098 : *offp = off;
1257 : }
1258 :
1259 : const TupleTableSlotOps TTSOpsVirtual = {
1260 : .base_slot_size = sizeof(VirtualTupleTableSlot),
1261 : .init = tts_virtual_init,
1262 : .release = tts_virtual_release,
1263 : .clear = tts_virtual_clear,
1264 : .getsomeattrs = tts_virtual_getsomeattrs,
1265 : .getsysattr = tts_virtual_getsysattr,
1266 : .materialize = tts_virtual_materialize,
1267 : .is_current_xact_tuple = tts_virtual_is_current_xact_tuple,
1268 : .copyslot = tts_virtual_copyslot,
1269 :
1270 : /*
1271 : * A virtual tuple table slot can not "own" a heap tuple or a minimal
1272 : * tuple.
1273 : */
1274 : .get_heap_tuple = NULL,
1275 : .get_minimal_tuple = NULL,
1276 : .copy_heap_tuple = tts_virtual_copy_heap_tuple,
1277 : .copy_minimal_tuple = tts_virtual_copy_minimal_tuple
1278 : };
1279 :
1280 : const TupleTableSlotOps TTSOpsHeapTuple = {
1281 : .base_slot_size = sizeof(HeapTupleTableSlot),
1282 : .init = tts_heap_init,
1283 : .release = tts_heap_release,
1284 : .clear = tts_heap_clear,
1285 : .getsomeattrs = tts_heap_getsomeattrs,
1286 : .getsysattr = tts_heap_getsysattr,
1287 : .is_current_xact_tuple = tts_heap_is_current_xact_tuple,
1288 : .materialize = tts_heap_materialize,
1289 : .copyslot = tts_heap_copyslot,
1290 : .get_heap_tuple = tts_heap_get_heap_tuple,
1291 :
1292 : /* A heap tuple table slot can not "own" a minimal tuple. */
1293 : .get_minimal_tuple = NULL,
1294 : .copy_heap_tuple = tts_heap_copy_heap_tuple,
1295 : .copy_minimal_tuple = tts_heap_copy_minimal_tuple
1296 : };
1297 :
1298 : const TupleTableSlotOps TTSOpsMinimalTuple = {
1299 : .base_slot_size = sizeof(MinimalTupleTableSlot),
1300 : .init = tts_minimal_init,
1301 : .release = tts_minimal_release,
1302 : .clear = tts_minimal_clear,
1303 : .getsomeattrs = tts_minimal_getsomeattrs,
1304 : .getsysattr = tts_minimal_getsysattr,
1305 : .is_current_xact_tuple = tts_minimal_is_current_xact_tuple,
1306 : .materialize = tts_minimal_materialize,
1307 : .copyslot = tts_minimal_copyslot,
1308 :
1309 : /* A minimal tuple table slot can not "own" a heap tuple. */
1310 : .get_heap_tuple = NULL,
1311 : .get_minimal_tuple = tts_minimal_get_minimal_tuple,
1312 : .copy_heap_tuple = tts_minimal_copy_heap_tuple,
1313 : .copy_minimal_tuple = tts_minimal_copy_minimal_tuple
1314 : };
1315 :
1316 : const TupleTableSlotOps TTSOpsBufferHeapTuple = {
1317 : .base_slot_size = sizeof(BufferHeapTupleTableSlot),
1318 : .init = tts_buffer_heap_init,
1319 : .release = tts_buffer_heap_release,
1320 : .clear = tts_buffer_heap_clear,
1321 : .getsomeattrs = tts_buffer_heap_getsomeattrs,
1322 : .getsysattr = tts_buffer_heap_getsysattr,
1323 : .is_current_xact_tuple = tts_buffer_is_current_xact_tuple,
1324 : .materialize = tts_buffer_heap_materialize,
1325 : .copyslot = tts_buffer_heap_copyslot,
1326 : .get_heap_tuple = tts_buffer_heap_get_heap_tuple,
1327 :
1328 : /* A buffer heap tuple table slot can not "own" a minimal tuple. */
1329 : .get_minimal_tuple = NULL,
1330 : .copy_heap_tuple = tts_buffer_heap_copy_heap_tuple,
1331 : .copy_minimal_tuple = tts_buffer_heap_copy_minimal_tuple
1332 : };
1333 :
1334 :
1335 : /* ----------------------------------------------------------------
1336 : * tuple table create/delete functions
1337 : * ----------------------------------------------------------------
1338 : */
1339 :
1340 : /* --------------------------------
1341 : * MakeTupleTableSlot
1342 : *
1343 : * Basic routine to make an empty TupleTableSlot of given
1344 : * TupleTableSlotType. If tupleDesc is specified the slot's descriptor is
1345 : * fixed for its lifetime, gaining some efficiency. If that's
1346 : * undesirable, pass NULL. 'flags' allows any of non-TTS_FLAGS_TRANSIENT
1347 : * flags to be set in tts_flags.
1348 : * --------------------------------
1349 : */
1350 : TupleTableSlot *
1351 23126045 : MakeTupleTableSlot(TupleDesc tupleDesc,
1352 : const TupleTableSlotOps *tts_ops, uint16 flags)
1353 : {
1354 : Size basesz,
1355 : allocsz;
1356 : TupleTableSlot *slot;
1357 :
1358 23126045 : basesz = tts_ops->base_slot_size;
1359 :
1360 : /* Ensure callers don't have any way to set transient flags permanently */
1361 23126045 : flags &= ~TTS_FLAGS_TRANSIENT;
1362 :
1363 : /*
1364 : * When a fixed descriptor is specified, we can reduce overhead by
1365 : * allocating the entire slot in one go.
1366 : *
1367 : * We round the size of tts_isnull up to the next highest multiple of 8.
1368 : * This is needed as populate_isnull_array() operates on 8 elements at a
1369 : * time when converting a tuple's NULL bitmap into a boolean array.
1370 : */
1371 23126045 : if (tupleDesc)
1372 22687379 : allocsz = MAXALIGN(basesz) +
1373 22687379 : MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
1374 22687379 : TYPEALIGN(8, tupleDesc->natts * sizeof(bool));
1375 : else
1376 438666 : allocsz = basesz;
1377 :
1378 23126045 : slot = palloc0(allocsz);
1379 : /* const for optimization purposes, OK to modify at allocation time */
1380 23126045 : *((const TupleTableSlotOps **) &slot->tts_ops) = tts_ops;
1381 23126045 : slot->type = T_TupleTableSlot;
1382 23126045 : slot->tts_flags = TTS_FLAG_EMPTY | flags;
1383 23126045 : if (tupleDesc != NULL)
1384 22687379 : slot->tts_flags |= TTS_FLAG_FIXED;
1385 23126045 : slot->tts_tupleDescriptor = tupleDesc;
1386 23126045 : slot->tts_mcxt = CurrentMemoryContext;
1387 23126045 : slot->tts_nvalid = 0;
1388 :
1389 23126045 : if (tupleDesc != NULL)
1390 : {
1391 22687379 : slot->tts_values = (Datum *)
1392 : (((char *) slot)
1393 22687379 : + MAXALIGN(basesz));
1394 :
1395 22687379 : slot->tts_isnull = (bool *)
1396 : (((char *) slot)
1397 22687379 : + MAXALIGN(basesz)
1398 22687379 : + MAXALIGN(tupleDesc->natts * sizeof(Datum)));
1399 :
1400 22687379 : PinTupleDesc(tupleDesc);
1401 :
1402 : /*
1403 : * Precalculate the maximum guaranteed attribute that has to exist in
1404 : * every tuple which gets deformed into this slot. When the
1405 : * TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS flag is enabled, we simply take
1406 : * the precalculated value from the tupleDesc, otherwise the
1407 : * optimization is disabled, and we set the value to 0.
1408 : */
1409 22687379 : if ((flags & TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS) != 0)
1410 688262 : slot->tts_first_nonguaranteed = tupleDesc->firstNonGuaranteedAttr;
1411 : else
1412 21999117 : slot->tts_first_nonguaranteed = 0;
1413 : }
1414 :
1415 : /*
1416 : * And allow slot type specific initialization.
1417 : */
1418 23126045 : slot->tts_ops->init(slot);
1419 :
1420 23126045 : return slot;
1421 : }
1422 :
1423 : /* --------------------------------
1424 : * ExecAllocTableSlot
1425 : *
1426 : * Create a tuple table slot within a tuple table (which is just a List).
1427 : * --------------------------------
1428 : */
1429 : TupleTableSlot *
1430 2545790 : ExecAllocTableSlot(List **tupleTable, TupleDesc desc,
1431 : const TupleTableSlotOps *tts_ops, uint16 flags)
1432 : {
1433 2545790 : TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops, flags);
1434 :
1435 2545790 : *tupleTable = lappend(*tupleTable, slot);
1436 :
1437 2545790 : return slot;
1438 : }
1439 :
1440 : /* --------------------------------
1441 : * ExecResetTupleTable
1442 : *
1443 : * This releases any resources (buffer pins, tupdesc refcounts)
1444 : * held by the tuple table, and optionally releases the memory
1445 : * occupied by the tuple table data structure.
1446 : * It is expected that this routine be called by ExecEndPlan().
1447 : * --------------------------------
1448 : */
1449 : void
1450 1300230 : ExecResetTupleTable(List *tupleTable, /* tuple table */
1451 : bool shouldFree) /* true if we should free memory */
1452 : {
1453 : ListCell *lc;
1454 :
1455 4370452 : foreach(lc, tupleTable)
1456 : {
1457 3070222 : TupleTableSlot *slot = lfirst_node(TupleTableSlot, lc);
1458 :
1459 : /* Always release resources and reset the slot to empty */
1460 3070222 : ExecClearTuple(slot);
1461 3070222 : slot->tts_ops->release(slot);
1462 3070222 : if (slot->tts_tupleDescriptor)
1463 : {
1464 3070186 : ReleaseTupleDesc(slot->tts_tupleDescriptor);
1465 3070186 : slot->tts_tupleDescriptor = NULL;
1466 : }
1467 :
1468 : /* If shouldFree, release memory occupied by the slot itself */
1469 3070222 : if (shouldFree)
1470 : {
1471 406469 : if (!TTS_FIXED(slot))
1472 : {
1473 0 : if (slot->tts_values)
1474 0 : pfree(slot->tts_values);
1475 0 : if (slot->tts_isnull)
1476 0 : pfree(slot->tts_isnull);
1477 : }
1478 406469 : pfree(slot);
1479 : }
1480 : }
1481 :
1482 : /* If shouldFree, release the list structure */
1483 1300230 : if (shouldFree)
1484 406383 : list_free(tupleTable);
1485 1300230 : }
1486 :
1487 : /* --------------------------------
1488 : * MakeSingleTupleTableSlot
1489 : *
1490 : * This is a convenience routine for operations that need a standalone
1491 : * TupleTableSlot not gotten from the main executor tuple table. It makes
1492 : * a single slot of given TupleTableSlotType and initializes it to use the
1493 : * given tuple descriptor.
1494 : * --------------------------------
1495 : */
1496 : TupleTableSlot *
1497 20580140 : MakeSingleTupleTableSlot(TupleDesc tupdesc,
1498 : const TupleTableSlotOps *tts_ops)
1499 : {
1500 20580140 : TupleTableSlot *slot = MakeTupleTableSlot(tupdesc, tts_ops, 0);
1501 :
1502 20580140 : return slot;
1503 : }
1504 :
1505 : /* --------------------------------
1506 : * ExecDropSingleTupleTableSlot
1507 : *
1508 : * Release a TupleTableSlot made with MakeSingleTupleTableSlot.
1509 : * DON'T use this on a slot that's part of a tuple table list!
1510 : * --------------------------------
1511 : */
1512 : void
1513 19992758 : ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
1514 : {
1515 : /* This should match ExecResetTupleTable's processing of one slot */
1516 : Assert(IsA(slot, TupleTableSlot));
1517 19992758 : ExecClearTuple(slot);
1518 19992758 : slot->tts_ops->release(slot);
1519 19992758 : if (slot->tts_tupleDescriptor)
1520 19992758 : ReleaseTupleDesc(slot->tts_tupleDescriptor);
1521 19992758 : if (!TTS_FIXED(slot))
1522 : {
1523 0 : if (slot->tts_values)
1524 0 : pfree(slot->tts_values);
1525 0 : if (slot->tts_isnull)
1526 0 : pfree(slot->tts_isnull);
1527 : }
1528 19992758 : pfree(slot);
1529 19992758 : }
1530 :
1531 :
1532 : /* ----------------------------------------------------------------
1533 : * tuple table slot accessor functions
1534 : * ----------------------------------------------------------------
1535 : */
1536 :
1537 : /* --------------------------------
1538 : * ExecSetSlotDescriptor
1539 : *
1540 : * This function is used to set the tuple descriptor associated
1541 : * with the slot's tuple. The passed descriptor must have lifespan
1542 : * at least equal to the slot's. If it is a reference-counted descriptor
1543 : * then the reference count is incremented for as long as the slot holds
1544 : * a reference.
1545 : * --------------------------------
1546 : */
1547 : void
1548 438630 : ExecSetSlotDescriptor(TupleTableSlot *slot, /* slot to change */
1549 : TupleDesc tupdesc) /* new tuple descriptor */
1550 : {
1551 : Assert(!TTS_FIXED(slot));
1552 :
1553 : /* For safety, make sure slot is empty before changing it */
1554 438630 : ExecClearTuple(slot);
1555 :
1556 : /*
1557 : * Release any old descriptor. Also release old Datum/isnull arrays if
1558 : * present (we don't bother to check if they could be re-used).
1559 : */
1560 438630 : if (slot->tts_tupleDescriptor)
1561 0 : ReleaseTupleDesc(slot->tts_tupleDescriptor);
1562 :
1563 438630 : if (slot->tts_values)
1564 0 : pfree(slot->tts_values);
1565 438630 : if (slot->tts_isnull)
1566 0 : pfree(slot->tts_isnull);
1567 :
1568 : /*
1569 : * Install the new descriptor; if it's refcounted, bump its refcount.
1570 : */
1571 438630 : slot->tts_tupleDescriptor = tupdesc;
1572 438630 : PinTupleDesc(tupdesc);
1573 :
1574 : /*
1575 : * Allocate Datum/isnull arrays of the appropriate size. These must have
1576 : * the same lifetime as the slot, so allocate in the slot's own context.
1577 : */
1578 438630 : slot->tts_values = (Datum *)
1579 438630 : MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(Datum));
1580 :
1581 : /*
1582 : * We round the size of tts_isnull up to the next highest multiple of 8.
1583 : * This is needed as populate_isnull_array() operates on 8 elements at a
1584 : * time when converting a tuple's NULL bitmap into a boolean array.
1585 : */
1586 438630 : slot->tts_isnull = (bool *)
1587 438630 : MemoryContextAlloc(slot->tts_mcxt, TYPEALIGN(8, tupdesc->natts * sizeof(bool)));
1588 438630 : }
1589 :
1590 : /* --------------------------------
1591 : * ExecStoreHeapTuple
1592 : *
1593 : * This function is used to store an on-the-fly physical tuple into a specified
1594 : * slot in the tuple table.
1595 : *
1596 : * tuple: tuple to store
1597 : * slot: TTSOpsHeapTuple type slot to store it in
1598 : * shouldFree: true if ExecClearTuple should pfree() the tuple
1599 : * when done with it
1600 : *
1601 : * shouldFree is normally set 'true' for tuples constructed on-the-fly. But it
1602 : * can be 'false' when the referenced tuple is held in a tuple table slot
1603 : * belonging to a lower-level executor Proc node. In this case the lower-level
1604 : * slot retains ownership and responsibility for eventually releasing the
1605 : * tuple. When this method is used, we must be certain that the upper-level
1606 : * Proc node will lose interest in the tuple sooner than the lower-level one
1607 : * does! If you're not certain, copy the lower-level tuple with heap_copytuple
1608 : * and let the upper-level table slot assume ownership of the copy!
1609 : *
1610 : * Return value is just the passed-in slot pointer.
1611 : *
1612 : * If the target slot is not guaranteed to be TTSOpsHeapTuple type slot, use
1613 : * the, more expensive, ExecForceStoreHeapTuple().
1614 : * --------------------------------
1615 : */
1616 : TupleTableSlot *
1617 2810198 : ExecStoreHeapTuple(HeapTuple tuple,
1618 : TupleTableSlot *slot,
1619 : bool shouldFree)
1620 : {
1621 : /*
1622 : * sanity checks
1623 : */
1624 : Assert(tuple != NULL);
1625 : Assert(slot != NULL);
1626 : Assert(slot->tts_tupleDescriptor != NULL);
1627 :
1628 2810198 : if (unlikely(!TTS_IS_HEAPTUPLE(slot)))
1629 0 : elog(ERROR, "trying to store a heap tuple into wrong type of slot");
1630 2810198 : tts_heap_store_tuple(slot, tuple, shouldFree);
1631 :
1632 2810198 : slot->tts_tableOid = tuple->t_tableOid;
1633 :
1634 2810198 : return slot;
1635 : }
1636 :
1637 : /* --------------------------------
1638 : * ExecStoreBufferHeapTuple
1639 : *
1640 : * This function is used to store an on-disk physical tuple from a buffer
1641 : * into a specified slot in the tuple table.
1642 : *
1643 : * tuple: tuple to store
1644 : * slot: TTSOpsBufferHeapTuple type slot to store it in
1645 : * buffer: disk buffer if tuple is in a disk page, else InvalidBuffer
1646 : *
1647 : * The tuple table code acquires a pin on the buffer which is held until the
1648 : * slot is cleared, so that the tuple won't go away on us.
1649 : *
1650 : * Return value is just the passed-in slot pointer.
1651 : *
1652 : * If the target slot is not guaranteed to be TTSOpsBufferHeapTuple type slot,
1653 : * use the, more expensive, ExecForceStoreHeapTuple().
1654 : * --------------------------------
1655 : */
1656 : TupleTableSlot *
1657 105720586 : ExecStoreBufferHeapTuple(HeapTuple tuple,
1658 : TupleTableSlot *slot,
1659 : Buffer buffer)
1660 : {
1661 : /*
1662 : * sanity checks
1663 : */
1664 : Assert(tuple != NULL);
1665 : Assert(slot != NULL);
1666 : Assert(slot->tts_tupleDescriptor != NULL);
1667 : Assert(BufferIsValid(buffer));
1668 :
1669 105720586 : if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1670 0 : elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1671 105720586 : tts_buffer_heap_store_tuple(slot, tuple, buffer, false);
1672 :
1673 105720586 : slot->tts_tableOid = tuple->t_tableOid;
1674 :
1675 105720586 : return slot;
1676 : }
1677 :
1678 : /*
1679 : * Like ExecStoreBufferHeapTuple, but transfer an existing pin from the caller
1680 : * to the slot, i.e. the caller doesn't need to, and may not, release the pin.
1681 : */
1682 : TupleTableSlot *
1683 1155902 : ExecStorePinnedBufferHeapTuple(HeapTuple tuple,
1684 : TupleTableSlot *slot,
1685 : Buffer buffer)
1686 : {
1687 : /*
1688 : * sanity checks
1689 : */
1690 : Assert(tuple != NULL);
1691 : Assert(slot != NULL);
1692 : Assert(slot->tts_tupleDescriptor != NULL);
1693 : Assert(BufferIsValid(buffer));
1694 :
1695 1155902 : if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1696 0 : elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1697 1155902 : tts_buffer_heap_store_tuple(slot, tuple, buffer, true);
1698 :
1699 1155902 : slot->tts_tableOid = tuple->t_tableOid;
1700 :
1701 1155902 : return slot;
1702 : }
1703 :
1704 : /*
1705 : * Store a minimal tuple into TTSOpsMinimalTuple type slot.
1706 : *
1707 : * If the target slot is not guaranteed to be TTSOpsMinimalTuple type slot,
1708 : * use the, more expensive, ExecForceStoreMinimalTuple().
1709 : */
1710 : TupleTableSlot *
1711 39811804 : ExecStoreMinimalTuple(MinimalTuple mtup,
1712 : TupleTableSlot *slot,
1713 : bool shouldFree)
1714 : {
1715 : /*
1716 : * sanity checks
1717 : */
1718 : Assert(mtup != NULL);
1719 : Assert(slot != NULL);
1720 : Assert(slot->tts_tupleDescriptor != NULL);
1721 :
1722 39811804 : if (unlikely(!TTS_IS_MINIMALTUPLE(slot)))
1723 0 : elog(ERROR, "trying to store a minimal tuple into wrong type of slot");
1724 39811804 : tts_minimal_store_tuple(slot, mtup, shouldFree);
1725 :
1726 39811804 : return slot;
1727 : }
1728 :
1729 : /*
1730 : * Store a HeapTuple into any kind of slot, performing conversion if
1731 : * necessary.
1732 : */
1733 : void
1734 1137049 : ExecForceStoreHeapTuple(HeapTuple tuple,
1735 : TupleTableSlot *slot,
1736 : bool shouldFree)
1737 : {
1738 1137049 : if (TTS_IS_HEAPTUPLE(slot))
1739 : {
1740 263 : ExecStoreHeapTuple(tuple, slot, shouldFree);
1741 : }
1742 1136786 : else if (TTS_IS_BUFFERTUPLE(slot))
1743 : {
1744 : MemoryContext oldContext;
1745 48027 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
1746 :
1747 48027 : ExecClearTuple(slot);
1748 48027 : slot->tts_flags &= ~TTS_FLAG_EMPTY;
1749 48027 : oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
1750 48027 : bslot->base.tuple = heap_copytuple(tuple);
1751 48027 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
1752 48027 : MemoryContextSwitchTo(oldContext);
1753 :
1754 48027 : if (shouldFree)
1755 46824 : pfree(tuple);
1756 : }
1757 : else
1758 : {
1759 1088759 : ExecClearTuple(slot);
1760 1088759 : heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
1761 : slot->tts_values, slot->tts_isnull);
1762 1088759 : ExecStoreVirtualTuple(slot);
1763 :
1764 1088759 : if (shouldFree)
1765 : {
1766 136575 : ExecMaterializeSlot(slot);
1767 136575 : pfree(tuple);
1768 : }
1769 : }
1770 1137049 : }
1771 :
1772 : /*
1773 : * Store a MinimalTuple into any kind of slot, performing conversion if
1774 : * necessary.
1775 : */
1776 : void
1777 4731831 : ExecForceStoreMinimalTuple(MinimalTuple mtup,
1778 : TupleTableSlot *slot,
1779 : bool shouldFree)
1780 : {
1781 4731831 : if (TTS_IS_MINIMALTUPLE(slot))
1782 : {
1783 2972818 : tts_minimal_store_tuple(slot, mtup, shouldFree);
1784 : }
1785 : else
1786 : {
1787 : HeapTupleData htup;
1788 :
1789 1759013 : ExecClearTuple(slot);
1790 :
1791 1759013 : htup.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
1792 1759013 : htup.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
1793 1759013 : heap_deform_tuple(&htup, slot->tts_tupleDescriptor,
1794 : slot->tts_values, slot->tts_isnull);
1795 1759013 : ExecStoreVirtualTuple(slot);
1796 :
1797 1759013 : if (shouldFree)
1798 : {
1799 958860 : ExecMaterializeSlot(slot);
1800 958860 : pfree(mtup);
1801 : }
1802 : }
1803 4731831 : }
1804 :
1805 : /* --------------------------------
1806 : * ExecStoreVirtualTuple
1807 : * Mark a slot as containing a virtual tuple.
1808 : *
1809 : * The protocol for loading a slot with virtual tuple data is:
1810 : * * Call ExecClearTuple to mark the slot empty.
1811 : * * Store data into the Datum/isnull arrays.
1812 : * * Call ExecStoreVirtualTuple to mark the slot valid.
1813 : * This is a bit unclean but it avoids one round of data copying.
1814 : * --------------------------------
1815 : */
1816 : TupleTableSlot *
1817 17991478 : ExecStoreVirtualTuple(TupleTableSlot *slot)
1818 : {
1819 : /*
1820 : * sanity checks
1821 : */
1822 : Assert(slot != NULL);
1823 : Assert(slot->tts_tupleDescriptor != NULL);
1824 : Assert(TTS_EMPTY(slot));
1825 :
1826 17991478 : slot->tts_flags &= ~TTS_FLAG_EMPTY;
1827 17991478 : slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
1828 :
1829 17991478 : return slot;
1830 : }
1831 :
1832 : /* --------------------------------
1833 : * ExecStoreAllNullTuple
1834 : * Set up the slot to contain a null in every column.
1835 : *
1836 : * At first glance this might sound just like ExecClearTuple, but it's
1837 : * entirely different: the slot ends up full, not empty.
1838 : * --------------------------------
1839 : */
1840 : TupleTableSlot *
1841 29492 : ExecStoreAllNullTuple(TupleTableSlot *slot)
1842 : {
1843 : /*
1844 : * sanity checks
1845 : */
1846 : Assert(slot != NULL);
1847 : Assert(slot->tts_tupleDescriptor != NULL);
1848 :
1849 : /* Clear any old contents */
1850 29492 : ExecClearTuple(slot);
1851 :
1852 : /*
1853 : * Fill all the columns of the virtual tuple with nulls
1854 : */
1855 214177 : MemSet(slot->tts_values, 0,
1856 : slot->tts_tupleDescriptor->natts * sizeof(Datum));
1857 29492 : memset(slot->tts_isnull, true,
1858 29492 : slot->tts_tupleDescriptor->natts * sizeof(bool));
1859 :
1860 29492 : return ExecStoreVirtualTuple(slot);
1861 : }
1862 :
1863 : /*
1864 : * Store a HeapTuple in datum form, into a slot. That always requires
1865 : * deforming it and storing it in virtual form.
1866 : *
1867 : * Until the slot is materialized, the contents of the slot depend on the
1868 : * datum.
1869 : */
1870 : void
1871 9 : ExecStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
1872 : {
1873 9 : HeapTupleData tuple = {0};
1874 : HeapTupleHeader td;
1875 :
1876 9 : td = DatumGetHeapTupleHeader(data);
1877 :
1878 9 : tuple.t_len = HeapTupleHeaderGetDatumLength(td);
1879 9 : tuple.t_self = td->t_ctid;
1880 9 : tuple.t_data = td;
1881 :
1882 9 : ExecClearTuple(slot);
1883 :
1884 9 : heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
1885 : slot->tts_values, slot->tts_isnull);
1886 9 : ExecStoreVirtualTuple(slot);
1887 9 : }
1888 :
1889 : /*
1890 : * ExecFetchSlotHeapTuple - fetch HeapTuple representing the slot's content
1891 : *
1892 : * The returned HeapTuple represents the slot's content as closely as
1893 : * possible.
1894 : *
1895 : * If materialize is true, the contents of the slots will be made independent
1896 : * from the underlying storage (i.e. all buffer pins are released, memory is
1897 : * allocated in the slot's context).
1898 : *
1899 : * If shouldFree is not-NULL it'll be set to true if the returned tuple has
1900 : * been allocated in the calling memory context, and must be freed by the
1901 : * caller (via explicit pfree() or a memory context reset).
1902 : *
1903 : * NB: If materialize is true, modifications of the returned tuple are
1904 : * allowed. But it depends on the type of the slot whether such modifications
1905 : * will also affect the slot's contents. While that is not the nicest
1906 : * behaviour, all such modifications are in the process of being removed.
1907 : */
1908 : HeapTuple
1909 28953100 : ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
1910 : {
1911 : /*
1912 : * sanity checks
1913 : */
1914 : Assert(slot != NULL);
1915 : Assert(!TTS_EMPTY(slot));
1916 :
1917 : /* Materialize the tuple so that the slot "owns" it, if requested. */
1918 28953100 : if (materialize)
1919 12159204 : slot->tts_ops->materialize(slot);
1920 :
1921 28953100 : if (slot->tts_ops->get_heap_tuple == NULL)
1922 : {
1923 1939653 : if (shouldFree)
1924 1939653 : *shouldFree = true;
1925 1939653 : return slot->tts_ops->copy_heap_tuple(slot);
1926 : }
1927 : else
1928 : {
1929 27013447 : if (shouldFree)
1930 24663487 : *shouldFree = false;
1931 27013447 : return slot->tts_ops->get_heap_tuple(slot);
1932 : }
1933 : }
1934 :
1935 : /* --------------------------------
1936 : * ExecFetchSlotMinimalTuple
1937 : * Fetch the slot's minimal physical tuple.
1938 : *
1939 : * If the given tuple table slot can hold a minimal tuple, indicated by a
1940 : * non-NULL get_minimal_tuple callback, the function returns the minimal
1941 : * tuple returned by that callback. It assumes that the minimal tuple
1942 : * returned by the callback is "owned" by the slot i.e. the slot is
1943 : * responsible for freeing the memory consumed by the tuple. Hence it sets
1944 : * *shouldFree to false, indicating that the caller should not free the
1945 : * memory consumed by the minimal tuple. In this case the returned minimal
1946 : * tuple should be considered as read-only.
1947 : *
1948 : * If that callback is not supported, it calls copy_minimal_tuple callback
1949 : * which is expected to return a copy of minimal tuple representing the
1950 : * contents of the slot. In this case *shouldFree is set to true,
1951 : * indicating the caller that it should free the memory consumed by the
1952 : * minimal tuple. In this case the returned minimal tuple may be written
1953 : * up.
1954 : * --------------------------------
1955 : */
1956 : MinimalTuple
1957 14258902 : ExecFetchSlotMinimalTuple(TupleTableSlot *slot,
1958 : bool *shouldFree)
1959 : {
1960 : /*
1961 : * sanity checks
1962 : */
1963 : Assert(slot != NULL);
1964 : Assert(!TTS_EMPTY(slot));
1965 :
1966 14258902 : if (slot->tts_ops->get_minimal_tuple)
1967 : {
1968 3317514 : if (shouldFree)
1969 3317514 : *shouldFree = false;
1970 3317514 : return slot->tts_ops->get_minimal_tuple(slot);
1971 : }
1972 : else
1973 : {
1974 10941388 : if (shouldFree)
1975 10941388 : *shouldFree = true;
1976 10941388 : return slot->tts_ops->copy_minimal_tuple(slot, 0);
1977 : }
1978 : }
1979 :
1980 : /* --------------------------------
1981 : * ExecFetchSlotHeapTupleDatum
1982 : * Fetch the slot's tuple as a composite-type Datum.
1983 : *
1984 : * The result is always freshly palloc'd in the caller's memory context.
1985 : * --------------------------------
1986 : */
1987 : Datum
1988 40645 : ExecFetchSlotHeapTupleDatum(TupleTableSlot *slot)
1989 : {
1990 : HeapTuple tup;
1991 : TupleDesc tupdesc;
1992 : bool shouldFree;
1993 : Datum ret;
1994 :
1995 : /* Fetch slot's contents in regular-physical-tuple form */
1996 40645 : tup = ExecFetchSlotHeapTuple(slot, false, &shouldFree);
1997 40645 : tupdesc = slot->tts_tupleDescriptor;
1998 :
1999 : /* Convert to Datum form */
2000 40645 : ret = heap_copy_tuple_as_datum(tup, tupdesc);
2001 :
2002 40645 : if (shouldFree)
2003 40501 : pfree(tup);
2004 :
2005 40645 : return ret;
2006 : }
2007 :
2008 : /* ----------------------------------------------------------------
2009 : * convenience initialization routines
2010 : * ----------------------------------------------------------------
2011 : */
2012 :
2013 : /* ----------------
2014 : * ExecInitResultTypeTL
2015 : *
2016 : * Initialize result type, using the plan node's targetlist.
2017 : * ----------------
2018 : */
2019 : void
2020 1676819 : ExecInitResultTypeTL(PlanState *planstate)
2021 : {
2022 1676819 : TupleDesc tupDesc = ExecTypeFromTL(planstate->plan->targetlist);
2023 :
2024 1676819 : planstate->ps_ResultTupleDesc = tupDesc;
2025 1676819 : }
2026 :
2027 : /* --------------------------------
2028 : * ExecInit{Result,Scan,Extra}TupleSlot[TL]
2029 : *
2030 : * These are convenience routines to initialize the specified slot
2031 : * in nodes inheriting the appropriate state. ExecInitExtraTupleSlot
2032 : * is used for initializing special-purpose slots.
2033 : * --------------------------------
2034 : */
2035 :
2036 : /* ----------------
2037 : * ExecInitResultTupleSlotTL
2038 : *
2039 : * Initialize result tuple slot, using the tuple descriptor previously
2040 : * computed with ExecInitResultTypeTL().
2041 : * ----------------
2042 : */
2043 : void
2044 1001331 : ExecInitResultSlot(PlanState *planstate, const TupleTableSlotOps *tts_ops)
2045 : {
2046 : TupleTableSlot *slot;
2047 :
2048 1001331 : slot = ExecAllocTableSlot(&planstate->state->es_tupleTable,
2049 : planstate->ps_ResultTupleDesc, tts_ops, 0);
2050 1001331 : planstate->ps_ResultTupleSlot = slot;
2051 :
2052 1001331 : planstate->resultopsfixed = planstate->ps_ResultTupleDesc != NULL;
2053 1001331 : planstate->resultops = tts_ops;
2054 1001331 : planstate->resultopsset = true;
2055 1001331 : }
2056 :
2057 : /* ----------------
2058 : * ExecInitResultTupleSlotTL
2059 : *
2060 : * Initialize result tuple slot, using the plan node's targetlist.
2061 : * ----------------
2062 : */
2063 : void
2064 424055 : ExecInitResultTupleSlotTL(PlanState *planstate,
2065 : const TupleTableSlotOps *tts_ops)
2066 : {
2067 424055 : ExecInitResultTypeTL(planstate);
2068 424055 : ExecInitResultSlot(planstate, tts_ops);
2069 424055 : }
2070 :
2071 : /* ----------------
2072 : * ExecInitScanTupleSlot
2073 : * ----------------
2074 : */
2075 : void
2076 866363 : ExecInitScanTupleSlot(EState *estate, ScanState *scanstate,
2077 : TupleDesc tupledesc, const TupleTableSlotOps *tts_ops,
2078 : uint16 flags)
2079 : {
2080 866363 : scanstate->ss_ScanTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable,
2081 : tupledesc, tts_ops, flags);
2082 866363 : scanstate->ps.scandesc = tupledesc;
2083 866363 : scanstate->ps.scanopsfixed = tupledesc != NULL;
2084 866363 : scanstate->ps.scanops = tts_ops;
2085 866363 : scanstate->ps.scanopsset = true;
2086 866363 : }
2087 :
2088 : /* ----------------
2089 : * ExecInitExtraTupleSlot
2090 : *
2091 : * Return a newly created slot. If tupledesc is non-NULL the slot will have
2092 : * that as its fixed tupledesc. Otherwise the caller needs to use
2093 : * ExecSetSlotDescriptor() to set the descriptor before use.
2094 : * ----------------
2095 : */
2096 : TupleTableSlot *
2097 660878 : ExecInitExtraTupleSlot(EState *estate,
2098 : TupleDesc tupledesc,
2099 : const TupleTableSlotOps *tts_ops)
2100 : {
2101 660878 : return ExecAllocTableSlot(&estate->es_tupleTable, tupledesc, tts_ops, 0);
2102 : }
2103 :
2104 : /* ----------------
2105 : * ExecInitNullTupleSlot
2106 : *
2107 : * Build a slot containing an all-nulls tuple of the given type.
2108 : * This is used as a substitute for an input tuple when performing an
2109 : * outer join.
2110 : * ----------------
2111 : */
2112 : TupleTableSlot *
2113 28537 : ExecInitNullTupleSlot(EState *estate, TupleDesc tupType,
2114 : const TupleTableSlotOps *tts_ops)
2115 : {
2116 28537 : TupleTableSlot *slot = ExecInitExtraTupleSlot(estate, tupType, tts_ops);
2117 :
2118 28537 : return ExecStoreAllNullTuple(slot);
2119 : }
2120 :
2121 : /* ---------------------------------------------------------------
2122 : * Routines for setting/accessing attributes in a slot.
2123 : * ---------------------------------------------------------------
2124 : */
2125 :
2126 : /*
2127 : * Fill in missing values for a TupleTableSlot.
2128 : *
2129 : * This is only exposed because it's needed for JIT compiled tuple
2130 : * deforming. That exception aside, there should be no callers outside of this
2131 : * file.
2132 : */
2133 : void
2134 4831 : slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum)
2135 : {
2136 4831 : AttrMissing *attrmiss = NULL;
2137 :
2138 : /* Check for invalid attnums */
2139 4831 : if (unlikely(lastAttNum > slot->tts_tupleDescriptor->natts))
2140 0 : elog(ERROR, "invalid attribute number %d", lastAttNum);
2141 :
2142 4831 : if (slot->tts_tupleDescriptor->constr)
2143 3130 : attrmiss = slot->tts_tupleDescriptor->constr->missing;
2144 :
2145 4831 : if (!attrmiss)
2146 : {
2147 : /* no missing values array at all, so just fill everything in as NULL */
2148 3831 : for (int attnum = startAttNum; attnum < lastAttNum; attnum++)
2149 : {
2150 2020 : slot->tts_values[attnum] = (Datum) 0;
2151 2020 : slot->tts_isnull[attnum] = true;
2152 : }
2153 : }
2154 : else
2155 : {
2156 : /* use attrmiss to set the missing values */
2157 7003 : for (int attnum = startAttNum; attnum < lastAttNum; attnum++)
2158 : {
2159 3983 : slot->tts_values[attnum] = attrmiss[attnum].am_value;
2160 3983 : slot->tts_isnull[attnum] = !attrmiss[attnum].am_present;
2161 : }
2162 : }
2163 4831 : }
2164 :
2165 : /*
2166 : * slot_getsomeattrs_int
2167 : * external function to call getsomeattrs() for use in JIT
2168 : */
2169 : void
2170 111884 : slot_getsomeattrs_int(TupleTableSlot *slot, int attnum)
2171 : {
2172 : /* Check for caller errors */
2173 : Assert(slot->tts_nvalid < attnum); /* checked in slot_getsomeattrs */
2174 : Assert(attnum > 0);
2175 :
2176 : /* Fetch as many attributes as possible from the underlying tuple. */
2177 111884 : slot->tts_ops->getsomeattrs(slot, attnum);
2178 :
2179 : /*
2180 : * Avoid putting new code here as that would prevent the compiler from
2181 : * using the sibling call optimization for the above function.
2182 : */
2183 111884 : }
2184 :
2185 : /* ----------------------------------------------------------------
2186 : * ExecTypeFromTL
2187 : *
2188 : * Generate a tuple descriptor for the result tuple of a targetlist.
2189 : * (A parse/plan tlist must be passed, not an ExprState tlist.)
2190 : * Note that resjunk columns, if any, are included in the result.
2191 : *
2192 : * Currently there are about 4 different places where we create
2193 : * TupleDescriptors. They should all be merged, or perhaps
2194 : * be rewritten to call BuildDesc().
2195 : * ----------------------------------------------------------------
2196 : */
2197 : TupleDesc
2198 1696840 : ExecTypeFromTL(List *targetList)
2199 : {
2200 1696840 : return ExecTypeFromTLInternal(targetList, false);
2201 : }
2202 :
2203 : /* ----------------------------------------------------------------
2204 : * ExecCleanTypeFromTL
2205 : *
2206 : * Same as above, but resjunk columns are omitted from the result.
2207 : * ----------------------------------------------------------------
2208 : */
2209 : TupleDesc
2210 474018 : ExecCleanTypeFromTL(List *targetList)
2211 : {
2212 474018 : return ExecTypeFromTLInternal(targetList, true);
2213 : }
2214 :
2215 : static TupleDesc
2216 2170858 : ExecTypeFromTLInternal(List *targetList, bool skipjunk)
2217 : {
2218 : TupleDesc typeInfo;
2219 : ListCell *l;
2220 : int len;
2221 2170858 : int cur_resno = 1;
2222 :
2223 2170858 : if (skipjunk)
2224 474018 : len = ExecCleanTargetListLength(targetList);
2225 : else
2226 1696840 : len = ExecTargetListLength(targetList);
2227 2170858 : typeInfo = CreateTemplateTupleDesc(len);
2228 :
2229 8594347 : foreach(l, targetList)
2230 : {
2231 6423489 : TargetEntry *tle = lfirst(l);
2232 :
2233 6423489 : if (skipjunk && tle->resjunk)
2234 421907 : continue;
2235 18004746 : TupleDescInitEntry(typeInfo,
2236 : cur_resno,
2237 6001582 : tle->resname,
2238 6001582 : exprType((Node *) tle->expr),
2239 6001582 : exprTypmod((Node *) tle->expr),
2240 : 0);
2241 6001582 : TupleDescInitEntryCollation(typeInfo,
2242 : cur_resno,
2243 6001582 : exprCollation((Node *) tle->expr));
2244 6001582 : cur_resno++;
2245 : }
2246 :
2247 2170858 : TupleDescFinalize(typeInfo);
2248 :
2249 2170858 : return typeInfo;
2250 : }
2251 :
2252 : /*
2253 : * ExecTypeFromExprList - build a tuple descriptor from a list of Exprs
2254 : *
2255 : * This is roughly like ExecTypeFromTL, but we work from bare expressions
2256 : * not TargetEntrys. No names are attached to the tupledesc's columns.
2257 : */
2258 : TupleDesc
2259 9586 : ExecTypeFromExprList(List *exprList)
2260 : {
2261 : TupleDesc typeInfo;
2262 : ListCell *lc;
2263 9586 : int cur_resno = 1;
2264 :
2265 9586 : typeInfo = CreateTemplateTupleDesc(list_length(exprList));
2266 :
2267 26690 : foreach(lc, exprList)
2268 : {
2269 17104 : Node *e = lfirst(lc);
2270 :
2271 17104 : TupleDescInitEntry(typeInfo,
2272 : cur_resno,
2273 : NULL,
2274 : exprType(e),
2275 : exprTypmod(e),
2276 : 0);
2277 17104 : TupleDescInitEntryCollation(typeInfo,
2278 : cur_resno,
2279 : exprCollation(e));
2280 17104 : cur_resno++;
2281 : }
2282 :
2283 9586 : TupleDescFinalize(typeInfo);
2284 :
2285 9586 : return typeInfo;
2286 : }
2287 :
2288 : /*
2289 : * ExecTypeSetColNames - set column names in a RECORD TupleDesc
2290 : *
2291 : * Column names must be provided as an alias list (list of String nodes).
2292 : */
2293 : void
2294 2808 : ExecTypeSetColNames(TupleDesc typeInfo, List *namesList)
2295 : {
2296 2808 : int colno = 0;
2297 : ListCell *lc;
2298 :
2299 : /* It's only OK to change col names in a not-yet-blessed RECORD type */
2300 : Assert(typeInfo->tdtypeid == RECORDOID);
2301 : Assert(typeInfo->tdtypmod < 0);
2302 :
2303 9734 : foreach(lc, namesList)
2304 : {
2305 6926 : char *cname = strVal(lfirst(lc));
2306 : Form_pg_attribute attr;
2307 :
2308 : /* Guard against too-long names list (probably can't happen) */
2309 6926 : if (colno >= typeInfo->natts)
2310 0 : break;
2311 6926 : attr = TupleDescAttr(typeInfo, colno);
2312 6926 : colno++;
2313 :
2314 : /*
2315 : * Do nothing for empty aliases or dropped columns (these cases
2316 : * probably can't arise in RECORD types, either)
2317 : */
2318 6926 : if (cname[0] == '\0' || attr->attisdropped)
2319 16 : continue;
2320 :
2321 : /* OK, assign the column name */
2322 6910 : namestrcpy(&(attr->attname), cname);
2323 : }
2324 2808 : }
2325 :
2326 : /*
2327 : * BlessTupleDesc - make a completed tuple descriptor useful for SRFs
2328 : *
2329 : * Rowtype Datums returned by a function must contain valid type information.
2330 : * This happens "for free" if the tupdesc came from a relcache entry, but
2331 : * not if we have manufactured a tupdesc for a transient RECORD datatype.
2332 : * In that case we have to notify typcache.c of the existence of the type.
2333 : *
2334 : * TupleDescFinalize() must be called on the TupleDesc before calling this
2335 : * function.
2336 : */
2337 : TupleDesc
2338 90556 : BlessTupleDesc(TupleDesc tupdesc)
2339 : {
2340 : /* Did someone forget to call TupleDescFinalize()? */
2341 : Assert(tupdesc->firstNonCachedOffsetAttr >= 0);
2342 :
2343 90556 : if (tupdesc->tdtypeid == RECORDOID &&
2344 87879 : tupdesc->tdtypmod < 0)
2345 55675 : assign_record_type_typmod(tupdesc);
2346 :
2347 90556 : return tupdesc; /* just for notational convenience */
2348 : }
2349 :
2350 : /*
2351 : * TupleDescGetAttInMetadata - Build an AttInMetadata structure based on the
2352 : * supplied TupleDesc. AttInMetadata can be used in conjunction with C strings
2353 : * to produce a properly formed tuple.
2354 : */
2355 : AttInMetadata *
2356 14350 : TupleDescGetAttInMetadata(TupleDesc tupdesc)
2357 : {
2358 14350 : int natts = tupdesc->natts;
2359 : int i;
2360 : Oid atttypeid;
2361 : Oid attinfuncid;
2362 : FmgrInfo *attinfuncinfo;
2363 : Oid *attioparams;
2364 : int32 *atttypmods;
2365 : AttInMetadata *attinmeta;
2366 :
2367 14350 : attinmeta = palloc_object(AttInMetadata);
2368 :
2369 : /* "Bless" the tupledesc so that we can make rowtype datums with it */
2370 14350 : attinmeta->tupdesc = BlessTupleDesc(tupdesc);
2371 :
2372 : /*
2373 : * Gather info needed later to call the "in" function for each attribute
2374 : */
2375 14350 : attinfuncinfo = (FmgrInfo *) palloc0(natts * sizeof(FmgrInfo));
2376 14350 : attioparams = (Oid *) palloc0(natts * sizeof(Oid));
2377 14350 : atttypmods = (int32 *) palloc0(natts * sizeof(int32));
2378 :
2379 74365 : for (i = 0; i < natts; i++)
2380 : {
2381 60015 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
2382 :
2383 : /* Ignore dropped attributes */
2384 60015 : if (!att->attisdropped)
2385 : {
2386 59900 : atttypeid = att->atttypid;
2387 59900 : getTypeInputInfo(atttypeid, &attinfuncid, &attioparams[i]);
2388 59900 : fmgr_info(attinfuncid, &attinfuncinfo[i]);
2389 59900 : atttypmods[i] = att->atttypmod;
2390 : }
2391 : }
2392 14350 : attinmeta->attinfuncs = attinfuncinfo;
2393 14350 : attinmeta->attioparams = attioparams;
2394 14350 : attinmeta->atttypmods = atttypmods;
2395 :
2396 14350 : return attinmeta;
2397 : }
2398 :
2399 : /*
2400 : * BuildTupleFromCStrings - build a HeapTuple given user data in C string form.
2401 : * values is an array of C strings, one for each attribute of the return tuple.
2402 : * A NULL string pointer indicates we want to create a NULL field.
2403 : */
2404 : HeapTuple
2405 981455 : BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
2406 : {
2407 981455 : TupleDesc tupdesc = attinmeta->tupdesc;
2408 981455 : int natts = tupdesc->natts;
2409 : Datum *dvalues;
2410 : bool *nulls;
2411 : int i;
2412 : HeapTuple tuple;
2413 :
2414 981455 : dvalues = (Datum *) palloc(natts * sizeof(Datum));
2415 981455 : nulls = (bool *) palloc(natts * sizeof(bool));
2416 :
2417 : /*
2418 : * Call the "in" function for each non-dropped attribute, even for nulls,
2419 : * to support domains.
2420 : */
2421 14645040 : for (i = 0; i < natts; i++)
2422 : {
2423 13663586 : if (!TupleDescCompactAttr(tupdesc, i)->attisdropped)
2424 : {
2425 : /* Non-dropped attributes */
2426 27327171 : dvalues[i] = InputFunctionCall(&attinmeta->attinfuncs[i],
2427 13663586 : values[i],
2428 13663586 : attinmeta->attioparams[i],
2429 13663586 : attinmeta->atttypmods[i]);
2430 13663585 : if (values[i] != NULL)
2431 9428284 : nulls[i] = false;
2432 : else
2433 4235301 : nulls[i] = true;
2434 : }
2435 : else
2436 : {
2437 : /* Handle dropped attributes by setting to NULL */
2438 0 : dvalues[i] = (Datum) 0;
2439 0 : nulls[i] = true;
2440 : }
2441 : }
2442 :
2443 : /*
2444 : * Form a tuple
2445 : */
2446 981454 : tuple = heap_form_tuple(tupdesc, dvalues, nulls);
2447 :
2448 : /*
2449 : * Release locally palloc'd space. XXX would probably be good to pfree
2450 : * values of pass-by-reference datums, as well.
2451 : */
2452 981454 : pfree(dvalues);
2453 981454 : pfree(nulls);
2454 :
2455 981454 : return tuple;
2456 : }
2457 :
2458 : /*
2459 : * HeapTupleHeaderGetDatum - convert a HeapTupleHeader pointer to a Datum.
2460 : *
2461 : * This must *not* get applied to an on-disk tuple; the tuple should be
2462 : * freshly made by heap_form_tuple or some wrapper routine for it (such as
2463 : * BuildTupleFromCStrings). Be sure also that the tupledesc used to build
2464 : * the tuple has a properly "blessed" rowtype.
2465 : *
2466 : * Formerly this was a macro equivalent to PointerGetDatum, relying on the
2467 : * fact that heap_form_tuple fills in the appropriate tuple header fields
2468 : * for a composite Datum. However, we now require that composite Datums not
2469 : * contain any external TOAST pointers. We do not want heap_form_tuple itself
2470 : * to enforce that; more specifically, the rule applies only to actual Datums
2471 : * and not to HeapTuple structures. Therefore, HeapTupleHeaderGetDatum is
2472 : * now a function that detects whether there are externally-toasted fields
2473 : * and constructs a new tuple with inlined fields if so. We still need
2474 : * heap_form_tuple to insert the Datum header fields, because otherwise this
2475 : * code would have no way to obtain a tupledesc for the tuple.
2476 : *
2477 : * Note that if we do build a new tuple, it's palloc'd in the current
2478 : * memory context. Beware of code that changes context between the initial
2479 : * heap_form_tuple/etc call and calling HeapTuple(Header)GetDatum.
2480 : *
2481 : * For performance-critical callers, it could be worthwhile to take extra
2482 : * steps to ensure that there aren't TOAST pointers in the output of
2483 : * heap_form_tuple to begin with. It's likely however that the costs of the
2484 : * typcache lookup and tuple disassembly/reassembly are swamped by TOAST
2485 : * dereference costs, so that the benefits of such extra effort would be
2486 : * minimal.
2487 : *
2488 : * XXX it would likely be better to create wrapper functions that produce
2489 : * a composite Datum from the field values in one step. However, there's
2490 : * enough code using the existing APIs that we couldn't get rid of this
2491 : * hack anytime soon.
2492 : */
2493 : Datum
2494 1491792 : HeapTupleHeaderGetDatum(HeapTupleHeader tuple)
2495 : {
2496 : Datum result;
2497 : TupleDesc tupDesc;
2498 :
2499 : /* No work if there are no external TOAST pointers in the tuple */
2500 1491792 : if (!HeapTupleHeaderHasExternal(tuple))
2501 1491784 : return PointerGetDatum(tuple);
2502 :
2503 : /* Use the type data saved by heap_form_tuple to look up the rowtype */
2504 8 : tupDesc = lookup_rowtype_tupdesc(HeapTupleHeaderGetTypeId(tuple),
2505 : HeapTupleHeaderGetTypMod(tuple));
2506 :
2507 : /* And do the flattening */
2508 8 : result = toast_flatten_tuple_to_datum(tuple,
2509 : HeapTupleHeaderGetDatumLength(tuple),
2510 : tupDesc);
2511 :
2512 8 : ReleaseTupleDesc(tupDesc);
2513 :
2514 8 : return result;
2515 : }
2516 :
2517 :
2518 : /*
2519 : * Functions for sending tuples to the frontend (or other specified destination)
2520 : * as though it is a SELECT result. These are used by utility commands that
2521 : * need to project directly to the destination and don't need or want full
2522 : * table function capability. Currently used by EXPLAIN and SHOW ALL.
2523 : */
2524 : TupOutputState *
2525 19329 : begin_tup_output_tupdesc(DestReceiver *dest,
2526 : TupleDesc tupdesc,
2527 : const TupleTableSlotOps *tts_ops)
2528 : {
2529 : TupOutputState *tstate;
2530 :
2531 19329 : tstate = palloc_object(TupOutputState);
2532 :
2533 19329 : tstate->slot = MakeSingleTupleTableSlot(tupdesc, tts_ops);
2534 19329 : tstate->dest = dest;
2535 :
2536 19329 : tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);
2537 :
2538 19329 : return tstate;
2539 : }
2540 :
2541 : /*
2542 : * write a single tuple
2543 : */
2544 : void
2545 114432 : do_tup_output(TupOutputState *tstate, const Datum *values, const bool *isnull)
2546 : {
2547 114432 : TupleTableSlot *slot = tstate->slot;
2548 114432 : int natts = slot->tts_tupleDescriptor->natts;
2549 :
2550 : /* make sure the slot is clear */
2551 114432 : ExecClearTuple(slot);
2552 :
2553 : /* insert data */
2554 114432 : memcpy(slot->tts_values, values, natts * sizeof(Datum));
2555 114432 : memcpy(slot->tts_isnull, isnull, natts * sizeof(bool));
2556 :
2557 : /* mark slot as containing a virtual tuple */
2558 114432 : ExecStoreVirtualTuple(slot);
2559 :
2560 : /* send the tuple to the receiver */
2561 114432 : (void) tstate->dest->receiveSlot(slot, tstate->dest);
2562 :
2563 : /* clean up */
2564 114432 : ExecClearTuple(slot);
2565 114432 : }
2566 :
2567 : /*
2568 : * write a chunk of text, breaking at newline characters
2569 : *
2570 : * Should only be used with a single-TEXT-attribute tupdesc.
2571 : */
2572 : void
2573 15996 : do_text_output_multiline(TupOutputState *tstate, const char *txt)
2574 : {
2575 : Datum values[1];
2576 15996 : bool isnull[1] = {false};
2577 :
2578 126354 : while (*txt)
2579 : {
2580 : const char *eol;
2581 : int len;
2582 :
2583 110358 : eol = strchr(txt, '\n');
2584 110358 : if (eol)
2585 : {
2586 110358 : len = eol - txt;
2587 110358 : eol++;
2588 : }
2589 : else
2590 : {
2591 0 : len = strlen(txt);
2592 0 : eol = txt + len;
2593 : }
2594 :
2595 110358 : values[0] = PointerGetDatum(cstring_to_text_with_len(txt, len));
2596 110358 : do_tup_output(tstate, values, isnull);
2597 110358 : pfree(DatumGetPointer(values[0]));
2598 110358 : txt = eol;
2599 : }
2600 15996 : }
2601 :
2602 : void
2603 19329 : end_tup_output(TupOutputState *tstate)
2604 : {
2605 19329 : tstate->dest->rShutdown(tstate->dest);
2606 : /* note that destroying the dest is not ours to do */
2607 19329 : ExecDropSingleTupleTableSlot(tstate->slot);
2608 19329 : pfree(tstate);
2609 19329 : }
|
