TLA 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-2023, 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 "catalog/pg_type.h"
64 : #include "funcapi.h"
65 : #include "nodes/nodeFuncs.h"
66 : #include "storage/bufmgr.h"
67 : #include "utils/builtins.h"
68 : #include "utils/expandeddatum.h"
69 : #include "utils/lsyscache.h"
70 : #include "utils/typcache.h"
71 :
72 : static TupleDesc ExecTypeFromTLInternal(List *targetList,
73 : bool skipjunk);
74 : static pg_attribute_always_inline void slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp,
75 : int natts);
76 : static inline void tts_buffer_heap_store_tuple(TupleTableSlot *slot,
77 : HeapTuple tuple,
78 : Buffer buffer,
79 : bool transfer_pin);
80 : static void tts_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, bool shouldFree);
81 :
82 :
83 : const TupleTableSlotOps TTSOpsVirtual;
84 : const TupleTableSlotOps TTSOpsHeapTuple;
85 : const TupleTableSlotOps TTSOpsMinimalTuple;
86 : const TupleTableSlotOps TTSOpsBufferHeapTuple;
87 :
88 :
89 : /*
90 : * TupleTableSlotOps implementations.
91 : */
92 :
93 : /*
94 : * TupleTableSlotOps implementation for VirtualTupleTableSlot.
95 : */
96 : static void
97 CBC 588860 : tts_virtual_init(TupleTableSlot *slot)
98 : {
99 588860 : }
100 :
101 : static void
102 577451 : tts_virtual_release(TupleTableSlot *slot)
103 : {
104 577451 : }
105 :
106 : static void
107 40183402 : tts_virtual_clear(TupleTableSlot *slot)
108 : {
109 40183402 : if (unlikely(TTS_SHOULDFREE(slot)))
110 : {
111 872835 : VirtualTupleTableSlot *vslot = (VirtualTupleTableSlot *) slot;
112 :
113 872835 : pfree(vslot->data);
114 872835 : vslot->data = NULL;
115 :
116 872835 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
117 : }
118 :
119 40183402 : slot->tts_nvalid = 0;
120 40183402 : slot->tts_flags |= TTS_FLAG_EMPTY;
121 40183402 : ItemPointerSetInvalid(&slot->tts_tid);
122 40183402 : }
123 :
124 : /*
125 : * VirtualTupleTableSlots always have fully populated tts_values and
126 : * tts_isnull arrays. So this function should never be called.
127 : */
128 : static void
129 UBC 0 : tts_virtual_getsomeattrs(TupleTableSlot *slot, int natts)
130 : {
131 0 : elog(ERROR, "getsomeattrs is not required to be called on a virtual tuple table slot");
132 : }
133 :
134 : /*
135 : * VirtualTupleTableSlots never provide system attributes (except those
136 : * handled generically, such as tableoid). We generally shouldn't get
137 : * here, but provide a user-friendly message if we do.
138 : */
139 : static Datum
140 CBC 6 : tts_virtual_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
141 : {
142 6 : Assert(!TTS_EMPTY(slot));
143 :
144 6 : ereport(ERROR,
145 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
146 : errmsg("cannot retrieve a system column in this context")));
147 :
148 : return 0; /* silence compiler warnings */
149 : }
150 :
151 : /*
152 : * To materialize a virtual slot all the datums that aren't passed by value
153 : * have to be copied into the slot's memory context. To do so, compute the
154 : * required size, and allocate enough memory to store all attributes. That's
155 : * good for cache hit ratio, but more importantly requires only memory
156 : * allocation/deallocation.
157 : */
158 : static void
159 2138818 : tts_virtual_materialize(TupleTableSlot *slot)
160 : {
161 2138818 : VirtualTupleTableSlot *vslot = (VirtualTupleTableSlot *) slot;
162 2138818 : TupleDesc desc = slot->tts_tupleDescriptor;
163 2138818 : Size sz = 0;
164 : char *data;
165 :
166 : /* already materialized */
167 2138818 : if (TTS_SHOULDFREE(slot))
168 191837 : return;
169 :
170 : /* compute size of memory required */
171 6044915 : for (int natt = 0; natt < desc->natts; natt++)
172 : {
173 4097934 : Form_pg_attribute att = TupleDescAttr(desc, natt);
174 : Datum val;
175 :
176 4097934 : if (att->attbyval || slot->tts_isnull[natt])
177 3184533 : continue;
178 :
179 913401 : val = slot->tts_values[natt];
180 :
181 913401 : if (att->attlen == -1 &&
182 617926 : VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(val)))
183 : {
184 : /*
185 : * We want to flatten the expanded value so that the materialized
186 : * slot doesn't depend on it.
187 : */
188 UBC 0 : sz = att_align_nominal(sz, att->attalign);
189 0 : sz += EOH_get_flat_size(DatumGetEOHP(val));
190 : }
191 : else
192 : {
193 CBC 913401 : sz = att_align_nominal(sz, att->attalign);
194 913401 : sz = att_addlength_datum(sz, att->attlen, val);
195 : }
196 : }
197 :
198 : /* all data is byval */
199 1946981 : if (sz == 0)
200 1074063 : return;
201 :
202 : /* allocate memory */
203 872918 : vslot->data = data = MemoryContextAlloc(slot->tts_mcxt, sz);
204 872918 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
205 :
206 : /* and copy all attributes into the pre-allocated space */
207 3348112 : for (int natt = 0; natt < desc->natts; natt++)
208 : {
209 2475194 : Form_pg_attribute att = TupleDescAttr(desc, natt);
210 : Datum val;
211 :
212 2475194 : if (att->attbyval || slot->tts_isnull[natt])
213 1561793 : continue;
214 :
215 913401 : val = slot->tts_values[natt];
216 :
217 913401 : if (att->attlen == -1 &&
218 617926 : VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(val)))
219 UBC 0 : {
220 : Size data_length;
221 :
222 : /*
223 : * We want to flatten the expanded value so that the materialized
224 : * slot doesn't depend on it.
225 : */
226 0 : ExpandedObjectHeader *eoh = DatumGetEOHP(val);
227 :
228 0 : data = (char *) att_align_nominal(data,
229 : att->attalign);
230 0 : data_length = EOH_get_flat_size(eoh);
231 0 : EOH_flatten_into(eoh, data, data_length);
232 :
233 0 : slot->tts_values[natt] = PointerGetDatum(data);
234 0 : data += data_length;
235 : }
236 : else
237 : {
238 CBC 913401 : Size data_length = 0;
239 :
240 913401 : data = (char *) att_align_nominal(data, att->attalign);
241 913401 : data_length = att_addlength_datum(data_length, att->attlen, val);
242 :
243 913401 : memcpy(data, DatumGetPointer(val), data_length);
244 :
245 913401 : slot->tts_values[natt] = PointerGetDatum(data);
246 913401 : data += data_length;
247 : }
248 : }
249 : }
250 :
251 : static void
252 70477 : tts_virtual_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
253 : {
254 70477 : TupleDesc srcdesc = srcslot->tts_tupleDescriptor;
255 :
256 70477 : Assert(srcdesc->natts <= dstslot->tts_tupleDescriptor->natts);
257 :
258 70477 : tts_virtual_clear(dstslot);
259 :
260 70477 : slot_getallattrs(srcslot);
261 :
262 145187 : for (int natt = 0; natt < srcdesc->natts; natt++)
263 : {
264 74710 : dstslot->tts_values[natt] = srcslot->tts_values[natt];
265 74710 : dstslot->tts_isnull[natt] = srcslot->tts_isnull[natt];
266 : }
267 :
268 70477 : dstslot->tts_nvalid = srcdesc->natts;
269 70477 : dstslot->tts_flags &= ~TTS_FLAG_EMPTY;
270 :
271 : /* make sure storage doesn't depend on external memory */
272 70477 : tts_virtual_materialize(dstslot);
273 70477 : }
274 :
275 : static HeapTuple
276 7068537 : tts_virtual_copy_heap_tuple(TupleTableSlot *slot)
277 : {
278 7068537 : Assert(!TTS_EMPTY(slot));
279 :
280 7068537 : return heap_form_tuple(slot->tts_tupleDescriptor,
281 : slot->tts_values,
282 : slot->tts_isnull);
283 : }
284 :
285 : static MinimalTuple
286 13270380 : tts_virtual_copy_minimal_tuple(TupleTableSlot *slot)
287 : {
288 13270380 : Assert(!TTS_EMPTY(slot));
289 :
290 13270380 : return heap_form_minimal_tuple(slot->tts_tupleDescriptor,
291 : slot->tts_values,
292 : slot->tts_isnull);
293 : }
294 :
295 :
296 : /*
297 : * TupleTableSlotOps implementation for HeapTupleTableSlot.
298 : */
299 :
300 : static void
301 5239628 : tts_heap_init(TupleTableSlot *slot)
302 : {
303 5239628 : }
304 :
305 : static void
306 5239231 : tts_heap_release(TupleTableSlot *slot)
307 : {
308 5239231 : }
309 :
310 : static void
311 11572437 : tts_heap_clear(TupleTableSlot *slot)
312 : {
313 11572437 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
314 :
315 : /* Free the memory for the heap tuple if it's allowed. */
316 11572437 : if (TTS_SHOULDFREE(slot))
317 : {
318 2309132 : heap_freetuple(hslot->tuple);
319 2309132 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
320 : }
321 :
322 11572437 : slot->tts_nvalid = 0;
323 11572437 : slot->tts_flags |= TTS_FLAG_EMPTY;
324 11572437 : ItemPointerSetInvalid(&slot->tts_tid);
325 11572437 : hslot->off = 0;
326 11572437 : hslot->tuple = NULL;
327 11572437 : }
328 :
329 : static void
330 11676807 : tts_heap_getsomeattrs(TupleTableSlot *slot, int natts)
331 : {
332 11676807 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
333 :
334 11676807 : Assert(!TTS_EMPTY(slot));
335 :
336 11676807 : slot_deform_heap_tuple(slot, hslot->tuple, &hslot->off, natts);
337 11676807 : }
338 :
339 : static Datum
340 UBC 0 : tts_heap_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
341 : {
342 0 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
343 :
344 0 : Assert(!TTS_EMPTY(slot));
345 :
346 : /*
347 : * In some code paths it's possible to get here with a non-materialized
348 : * slot, in which case we can't retrieve system columns.
349 : */
350 0 : if (!hslot->tuple)
351 0 : ereport(ERROR,
352 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
353 : errmsg("cannot retrieve a system column in this context")));
354 :
355 0 : return heap_getsysattr(hslot->tuple, attnum,
356 : slot->tts_tupleDescriptor, isnull);
357 : }
358 :
359 : static void
360 CBC 4286930 : tts_heap_materialize(TupleTableSlot *slot)
361 : {
362 4286930 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
363 : MemoryContext oldContext;
364 :
365 4286930 : Assert(!TTS_EMPTY(slot));
366 :
367 : /* If slot has its tuple already materialized, nothing to do. */
368 4286930 : if (TTS_SHOULDFREE(slot))
369 2178839 : return;
370 :
371 2108091 : oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
372 :
373 : /*
374 : * Have to deform from scratch, otherwise tts_values[] entries could point
375 : * into the non-materialized tuple (which might be gone when accessed).
376 : */
377 2108091 : slot->tts_nvalid = 0;
378 2108091 : hslot->off = 0;
379 :
380 2108091 : if (!hslot->tuple)
381 2108084 : hslot->tuple = heap_form_tuple(slot->tts_tupleDescriptor,
382 : slot->tts_values,
383 : slot->tts_isnull);
384 : else
385 : {
386 : /*
387 : * The tuple contained in this slot is not allocated in the memory
388 : * context of the given slot (else it would have TTS_FLAG_SHOULDFREE
389 : * set). Copy the tuple into the given slot's memory context.
390 : */
391 7 : hslot->tuple = heap_copytuple(hslot->tuple);
392 : }
393 :
394 2108091 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
395 :
396 2108091 : MemoryContextSwitchTo(oldContext);
397 : }
398 :
399 : static void
400 140898 : tts_heap_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
401 : {
402 : HeapTuple tuple;
403 : MemoryContext oldcontext;
404 :
405 140898 : oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
406 140898 : tuple = ExecCopySlotHeapTuple(srcslot);
407 140898 : MemoryContextSwitchTo(oldcontext);
408 :
409 140898 : ExecStoreHeapTuple(tuple, dstslot, true);
410 140898 : }
411 :
412 : static HeapTuple
413 4215951 : tts_heap_get_heap_tuple(TupleTableSlot *slot)
414 : {
415 4215951 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
416 :
417 4215951 : Assert(!TTS_EMPTY(slot));
418 4215951 : if (!hslot->tuple)
419 UBC 0 : tts_heap_materialize(slot);
420 :
421 CBC 4215951 : return hslot->tuple;
422 : }
423 :
424 : static HeapTuple
425 70343 : tts_heap_copy_heap_tuple(TupleTableSlot *slot)
426 : {
427 70343 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
428 :
429 70343 : Assert(!TTS_EMPTY(slot));
430 70343 : if (!hslot->tuple)
431 UBC 0 : tts_heap_materialize(slot);
432 :
433 CBC 70343 : return heap_copytuple(hslot->tuple);
434 : }
435 :
436 : static MinimalTuple
437 2711 : tts_heap_copy_minimal_tuple(TupleTableSlot *slot)
438 : {
439 2711 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
440 :
441 2711 : if (!hslot->tuple)
442 19 : tts_heap_materialize(slot);
443 :
444 2711 : return minimal_tuple_from_heap_tuple(hslot->tuple);
445 : }
446 :
447 : static void
448 4222627 : tts_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, bool shouldFree)
449 : {
450 4222627 : HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
451 :
452 4222627 : tts_heap_clear(slot);
453 :
454 4222627 : slot->tts_nvalid = 0;
455 4222627 : hslot->tuple = tuple;
456 4222627 : hslot->off = 0;
457 4222627 : slot->tts_flags &= ~(TTS_FLAG_EMPTY | TTS_FLAG_SHOULDFREE);
458 4222627 : slot->tts_tid = tuple->t_self;
459 :
460 4222627 : if (shouldFree)
461 201050 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
462 4222627 : }
463 :
464 :
465 : /*
466 : * TupleTableSlotOps implementation for MinimalTupleTableSlot.
467 : */
468 :
469 : static void
470 211882 : tts_minimal_init(TupleTableSlot *slot)
471 : {
472 211882 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
473 :
474 : /*
475 : * Initialize the heap tuple pointer to access attributes of the minimal
476 : * tuple contained in the slot as if its a heap tuple.
477 : */
478 211882 : mslot->tuple = &mslot->minhdr;
479 211882 : }
480 :
481 : static void
482 194488 : tts_minimal_release(TupleTableSlot *slot)
483 : {
484 194488 : }
485 :
486 : static void
487 33384260 : tts_minimal_clear(TupleTableSlot *slot)
488 : {
489 33384260 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
490 :
491 33384260 : if (TTS_SHOULDFREE(slot))
492 : {
493 7778642 : heap_free_minimal_tuple(mslot->mintuple);
494 7778642 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
495 : }
496 :
497 33384260 : slot->tts_nvalid = 0;
498 33384260 : slot->tts_flags |= TTS_FLAG_EMPTY;
499 33384260 : ItemPointerSetInvalid(&slot->tts_tid);
500 33384260 : mslot->off = 0;
501 33384260 : mslot->mintuple = NULL;
502 33384260 : }
503 :
504 : static void
505 22396059 : tts_minimal_getsomeattrs(TupleTableSlot *slot, int natts)
506 : {
507 22396059 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
508 :
509 22396059 : Assert(!TTS_EMPTY(slot));
510 :
511 22396059 : slot_deform_heap_tuple(slot, mslot->tuple, &mslot->off, natts);
512 22396059 : }
513 :
514 : static Datum
515 UBC 0 : tts_minimal_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
516 : {
517 0 : Assert(!TTS_EMPTY(slot));
518 :
519 0 : ereport(ERROR,
520 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
521 : errmsg("cannot retrieve a system column in this context")));
522 :
523 : return 0; /* silence compiler warnings */
524 : }
525 :
526 : static void
527 CBC 785209 : tts_minimal_materialize(TupleTableSlot *slot)
528 : {
529 785209 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
530 : MemoryContext oldContext;
531 :
532 785209 : Assert(!TTS_EMPTY(slot));
533 :
534 : /* If slot has its tuple already materialized, nothing to do. */
535 785209 : if (TTS_SHOULDFREE(slot))
536 72006 : return;
537 :
538 713203 : oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
539 :
540 : /*
541 : * Have to deform from scratch, otherwise tts_values[] entries could point
542 : * into the non-materialized tuple (which might be gone when accessed).
543 : */
544 713203 : slot->tts_nvalid = 0;
545 713203 : mslot->off = 0;
546 :
547 713203 : if (!mslot->mintuple)
548 : {
549 657675 : mslot->mintuple = heap_form_minimal_tuple(slot->tts_tupleDescriptor,
550 : slot->tts_values,
551 : slot->tts_isnull);
552 : }
553 : else
554 : {
555 : /*
556 : * The minimal tuple contained in this slot is not allocated in the
557 : * memory context of the given slot (else it would have
558 : * TTS_FLAG_SHOULDFREE set). Copy the minimal tuple into the given
559 : * slot's memory context.
560 : */
561 GIC 55528 : mslot->mintuple = heap_copy_minimal_tuple(mslot->mintuple);
562 ECB : }
563 :
564 GIC 713203 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
565 ECB :
566 GIC 713203 : Assert(mslot->tuple == &mslot->minhdr);
567 ECB :
568 GIC 713203 : mslot->minhdr.t_len = mslot->mintuple->t_len + MINIMAL_TUPLE_OFFSET;
569 CBC 713203 : mslot->minhdr.t_data = (HeapTupleHeader) ((char *) mslot->mintuple - MINIMAL_TUPLE_OFFSET);
570 ECB :
571 GIC 713203 : MemoryContextSwitchTo(oldContext);
572 ECB : }
573 :
574 : static void
575 GIC 531821 : tts_minimal_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
576 ECB : {
577 : MemoryContext oldcontext;
578 : MinimalTuple mintuple;
579 :
580 GIC 531821 : oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
581 CBC 531821 : mintuple = ExecCopySlotMinimalTuple(srcslot);
582 531821 : MemoryContextSwitchTo(oldcontext);
583 ECB :
584 GIC 531821 : ExecStoreMinimalTuple(mintuple, dstslot, true);
585 CBC 531821 : }
586 ECB :
587 : static MinimalTuple
588 GIC 2447307 : tts_minimal_get_minimal_tuple(TupleTableSlot *slot)
589 ECB : {
590 GIC 2447307 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
591 ECB :
592 GIC 2447307 : if (!mslot->mintuple)
593 LBC 0 : tts_minimal_materialize(slot);
594 EUB :
595 GIC 2447307 : return mslot->mintuple;
596 ECB : }
597 :
598 : static HeapTuple
599 GIC 495682 : tts_minimal_copy_heap_tuple(TupleTableSlot *slot)
600 ECB : {
601 GIC 495682 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
602 ECB :
603 GIC 495682 : if (!mslot->mintuple)
604 CBC 734 : tts_minimal_materialize(slot);
605 ECB :
606 GIC 495682 : return heap_tuple_from_minimal_tuple(mslot->mintuple);
607 ECB : }
608 :
609 : static MinimalTuple
610 GIC 1322209 : tts_minimal_copy_minimal_tuple(TupleTableSlot *slot)
611 ECB : {
612 GIC 1322209 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
613 ECB :
614 GIC 1322209 : if (!mslot->mintuple)
615 CBC 598596 : tts_minimal_materialize(slot);
616 ECB :
617 GIC 1322209 : return heap_copy_minimal_tuple(mslot->mintuple);
618 ECB : }
619 :
620 : static void
621 GIC 27639388 : tts_minimal_store_tuple(TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
622 ECB : {
623 GIC 27639388 : MinimalTupleTableSlot *mslot = (MinimalTupleTableSlot *) slot;
624 ECB :
625 GIC 27639388 : tts_minimal_clear(slot);
626 ECB :
627 GIC 27639388 : Assert(!TTS_SHOULDFREE(slot));
628 CBC 27639388 : Assert(TTS_EMPTY(slot));
629 ECB :
630 GIC 27639388 : slot->tts_flags &= ~TTS_FLAG_EMPTY;
631 CBC 27639388 : slot->tts_nvalid = 0;
632 27639388 : mslot->off = 0;
633 ECB :
634 GIC 27639388 : mslot->mintuple = mtup;
635 CBC 27639388 : Assert(mslot->tuple == &mslot->minhdr);
636 27639388 : mslot->minhdr.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
637 27639388 : mslot->minhdr.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
638 ECB : /* no need to set t_self or t_tableOid since we won't allow access */
639 :
640 GIC 27639388 : if (shouldFree)
641 CBC 7065907 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
642 27639388 : }
643 ECB :
644 :
645 : /*
646 : * TupleTableSlotOps implementation for BufferHeapTupleTableSlot.
647 : */
648 :
649 : static void
650 GIC 15861968 : tts_buffer_heap_init(TupleTableSlot *slot)
651 ECB : {
652 GIC 15861968 : }
653 ECB :
654 : static void
655 GIC 15857121 : tts_buffer_heap_release(TupleTableSlot *slot)
656 ECB : {
657 GIC 15857121 : }
658 ECB :
659 : static void
660 GIC 27431568 : tts_buffer_heap_clear(TupleTableSlot *slot)
661 ECB : {
662 GIC 27431568 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
663 ECB :
664 : /*
665 : * Free the memory for heap tuple if allowed. A tuple coming from buffer
666 : * can never be freed. But we may have materialized a tuple from buffer.
667 : * Such a tuple can be freed.
668 : */
669 GIC 27431568 : if (TTS_SHOULDFREE(slot))
670 ECB : {
671 : /* We should have unpinned the buffer while materializing the tuple. */
672 GIC 7105962 : Assert(!BufferIsValid(bslot->buffer));
673 ECB :
674 GIC 7105962 : heap_freetuple(bslot->base.tuple);
675 CBC 7105962 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
676 ECB : }
677 :
678 GIC 27431568 : if (BufferIsValid(bslot->buffer))
679 CBC 6951583 : ReleaseBuffer(bslot->buffer);
680 ECB :
681 GIC 27431568 : slot->tts_nvalid = 0;
682 CBC 27431568 : slot->tts_flags |= TTS_FLAG_EMPTY;
683 27431568 : ItemPointerSetInvalid(&slot->tts_tid);
684 27431568 : bslot->base.tuple = NULL;
685 27431568 : bslot->base.off = 0;
686 27431568 : bslot->buffer = InvalidBuffer;
687 27431568 : }
688 ECB :
689 : static void
690 GIC 71856093 : tts_buffer_heap_getsomeattrs(TupleTableSlot *slot, int natts)
691 ECB : {
692 GIC 71856093 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
693 ECB :
694 GIC 71856093 : Assert(!TTS_EMPTY(slot));
695 ECB :
696 GIC 71856093 : slot_deform_heap_tuple(slot, bslot->base.tuple, &bslot->base.off, natts);
697 CBC 71856093 : }
698 ECB :
699 : static Datum
700 GIC 630 : tts_buffer_heap_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
701 ECB : {
702 GIC 630 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
703 ECB :
704 GIC 630 : Assert(!TTS_EMPTY(slot));
705 ECB :
706 : /*
707 : * In some code paths it's possible to get here with a non-materialized
708 : * slot, in which case we can't retrieve system columns.
709 : */
710 GIC 630 : if (!bslot->base.tuple)
711 LBC 0 : ereport(ERROR,
712 EUB : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
713 : errmsg("cannot retrieve a system column in this context")));
714 :
715 GIC 630 : return heap_getsysattr(bslot->base.tuple, attnum,
716 ECB : slot->tts_tupleDescriptor, isnull);
717 : }
718 :
719 : static void
720 GIC 14171478 : tts_buffer_heap_materialize(TupleTableSlot *slot)
721 ECB : {
722 GIC 14171478 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
723 ECB : MemoryContext oldContext;
724 :
725 GIC 14171478 : Assert(!TTS_EMPTY(slot));
726 ECB :
727 : /* If slot has its tuple already materialized, nothing to do. */
728 GIC 14171478 : if (TTS_SHOULDFREE(slot))
729 CBC 12581619 : return;
730 ECB :
731 GIC 1589859 : oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
732 ECB :
733 : /*
734 : * Have to deform from scratch, otherwise tts_values[] entries could point
735 : * into the non-materialized tuple (which might be gone when accessed).
736 : */
737 GIC 1589859 : bslot->base.off = 0;
738 CBC 1589859 : slot->tts_nvalid = 0;
739 ECB :
740 GIC 1589859 : if (!bslot->base.tuple)
741 ECB : {
742 : /*
743 : * Normally BufferHeapTupleTableSlot should have a tuple + buffer
744 : * associated with it, unless it's materialized (which would've
745 : * returned above). But when it's useful to allow storing virtual
746 : * tuples in a buffer slot, which then also needs to be
747 : * materializable.
748 : */
749 GIC 1393945 : bslot->base.tuple = heap_form_tuple(slot->tts_tupleDescriptor,
750 ECB : slot->tts_values,
751 : slot->tts_isnull);
752 : }
753 : else
754 : {
755 GIC 195914 : bslot->base.tuple = heap_copytuple(bslot->base.tuple);
756 ECB :
757 : /*
758 : * A heap tuple stored in a BufferHeapTupleTableSlot should have a
759 : * buffer associated with it, unless it's materialized or virtual.
760 : */
761 GIC 195914 : if (likely(BufferIsValid(bslot->buffer)))
762 CBC 195914 : ReleaseBuffer(bslot->buffer);
763 195914 : bslot->buffer = InvalidBuffer;
764 ECB : }
765 :
766 : /*
767 : * We don't set TTS_FLAG_SHOULDFREE until after releasing the buffer, if
768 : * any. This avoids having a transient state that would fall foul of our
769 : * assertions that a slot with TTS_FLAG_SHOULDFREE doesn't own a buffer.
770 : * In the unlikely event that ReleaseBuffer() above errors out, we'd
771 : * effectively leak the copied tuple, but that seems fairly harmless.
772 : */
773 GIC 1589859 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
774 ECB :
775 GIC 1589859 : MemoryContextSwitchTo(oldContext);
776 ECB : }
777 :
778 : static void
779 GIC 5682685 : tts_buffer_heap_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
780 ECB : {
781 GIC 5682685 : BufferHeapTupleTableSlot *bsrcslot = (BufferHeapTupleTableSlot *) srcslot;
782 CBC 5682685 : BufferHeapTupleTableSlot *bdstslot = (BufferHeapTupleTableSlot *) dstslot;
783 ECB :
784 : /*
785 : * If the source slot is of a different kind, or is a buffer slot that has
786 : * been materialized / is virtual, make a new copy of the tuple. Otherwise
787 : * make a new reference to the in-buffer tuple.
788 : */
789 GIC 5682685 : if (dstslot->tts_ops != srcslot->tts_ops ||
790 CBC 4377 : TTS_SHOULDFREE(srcslot) ||
791 4375 : !bsrcslot->base.tuple)
792 5678310 : {
793 ECB : MemoryContext oldContext;
794 :
795 GIC 5678310 : ExecClearTuple(dstslot);
796 CBC 5678310 : dstslot->tts_flags &= ~TTS_FLAG_EMPTY;
797 5678310 : oldContext = MemoryContextSwitchTo(dstslot->tts_mcxt);
798 5678310 : bdstslot->base.tuple = ExecCopySlotHeapTuple(srcslot);
799 5678310 : dstslot->tts_flags |= TTS_FLAG_SHOULDFREE;
800 5678310 : MemoryContextSwitchTo(oldContext);
801 ECB : }
802 : else
803 : {
804 GIC 4375 : Assert(BufferIsValid(bsrcslot->buffer));
805 ECB :
806 GIC 4375 : tts_buffer_heap_store_tuple(dstslot, bsrcslot->base.tuple,
807 ECB : bsrcslot->buffer, false);
808 :
809 : /*
810 : * The HeapTupleData portion of the source tuple might be shorter
811 : * lived than the destination slot. Therefore copy the HeapTuple into
812 : * our slot's tupdata, which is guaranteed to live long enough (but
813 : * will still point into the buffer).
814 : */
815 GIC 4375 : memcpy(&bdstslot->base.tupdata, bdstslot->base.tuple, sizeof(HeapTupleData));
816 CBC 4375 : bdstslot->base.tuple = &bdstslot->base.tupdata;
817 ECB : }
818 GIC 5682685 : }
819 ECB :
820 : static HeapTuple
821 GIC 21901000 : tts_buffer_heap_get_heap_tuple(TupleTableSlot *slot)
822 ECB : {
823 GIC 21901000 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
824 ECB :
825 GIC 21901000 : Assert(!TTS_EMPTY(slot));
826 ECB :
827 GIC 21901000 : if (!bslot->base.tuple)
828 LBC 0 : tts_buffer_heap_materialize(slot);
829 EUB :
830 GIC 21901000 : return bslot->base.tuple;
831 ECB : }
832 :
833 : static HeapTuple
834 GIC 10126320 : tts_buffer_heap_copy_heap_tuple(TupleTableSlot *slot)
835 ECB : {
836 GIC 10126320 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
837 ECB :
838 GIC 10126320 : Assert(!TTS_EMPTY(slot));
839 ECB :
840 GIC 10126320 : if (!bslot->base.tuple)
841 LBC 0 : tts_buffer_heap_materialize(slot);
842 EUB :
843 GIC 10126320 : return heap_copytuple(bslot->base.tuple);
844 ECB : }
845 :
846 : static MinimalTuple
847 GIC 1264956 : tts_buffer_heap_copy_minimal_tuple(TupleTableSlot *slot)
848 ECB : {
849 GIC 1264956 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
850 ECB :
851 GIC 1264956 : Assert(!TTS_EMPTY(slot));
852 ECB :
853 GIC 1264956 : if (!bslot->base.tuple)
854 LBC 0 : tts_buffer_heap_materialize(slot);
855 EUB :
856 GIC 1264956 : return minimal_tuple_from_heap_tuple(bslot->base.tuple);
857 ECB : }
858 :
859 : static inline void
860 GIC 84347418 : tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple,
861 ECB : Buffer buffer, bool transfer_pin)
862 : {
863 GIC 84347418 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
864 ECB :
865 GIC 84347418 : if (TTS_SHOULDFREE(slot))
866 ECB : {
867 : /* materialized slot shouldn't have a buffer to release */
868 GIC 196748 : Assert(!BufferIsValid(bslot->buffer));
869 ECB :
870 GIC 196748 : heap_freetuple(bslot->base.tuple);
871 CBC 196748 : slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
872 ECB : }
873 :
874 GIC 84347418 : slot->tts_flags &= ~TTS_FLAG_EMPTY;
875 CBC 84347418 : slot->tts_nvalid = 0;
876 84347418 : bslot->base.tuple = tuple;
877 84347418 : bslot->base.off = 0;
878 84347418 : slot->tts_tid = tuple->t_self;
879 ECB :
880 : /*
881 : * If tuple is on a disk page, keep the page pinned as long as we hold a
882 : * pointer into it. We assume the caller already has such a pin. If
883 : * transfer_pin is true, we'll transfer that pin to this slot, if not
884 : * we'll pin it again ourselves.
885 : *
886 : * This is coded to optimize the case where the slot previously held a
887 : * tuple on the same disk page: in that case releasing and re-acquiring
888 : * the pin is a waste of cycles. This is a common situation during
889 : * seqscans, so it's worth troubling over.
890 : */
891 GIC 84347418 : if (bslot->buffer != buffer)
892 ECB : {
893 GIC 10138239 : if (BufferIsValid(bslot->buffer))
894 CBC 2988509 : ReleaseBuffer(bslot->buffer);
895 ECB :
896 GIC 10138239 : bslot->buffer = buffer;
897 ECB :
898 GIC 10138239 : if (!transfer_pin && BufferIsValid(buffer))
899 CBC 10036077 : IncrBufferRefCount(buffer);
900 ECB : }
901 GIC 74209179 : else if (transfer_pin && BufferIsValid(buffer))
902 ECB : {
903 : /*
904 : * In transfer_pin mode the caller won't know about the same-page
905 : * optimization, so we gotta release its pin.
906 : */
907 GIC 176142 : ReleaseBuffer(buffer);
908 ECB : }
909 GIC 84347418 : }
910 ECB :
911 : /*
912 : * slot_deform_heap_tuple
913 : * Given a TupleTableSlot, extract data from the slot's physical tuple
914 : * into its Datum/isnull arrays. Data is extracted up through the
915 : * natts'th column (caller must ensure this is a legal column number).
916 : *
917 : * This is essentially an incremental version of heap_deform_tuple:
918 : * on each call we extract attributes up to the one needed, without
919 : * re-computing information about previously extracted attributes.
920 : * slot->tts_nvalid is the number of attributes already extracted.
921 : *
922 : * This is marked as always inline, so the different offp for different types
923 : * of slots gets optimized away.
924 : */
925 : static pg_attribute_always_inline void
926 GIC 105928959 : slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp,
927 ECB : int natts)
928 : {
929 GIC 105928959 : TupleDesc tupleDesc = slot->tts_tupleDescriptor;
930 CBC 105928959 : Datum *values = slot->tts_values;
931 105928959 : bool *isnull = slot->tts_isnull;
932 105928959 : HeapTupleHeader tup = tuple->t_data;
933 105928959 : bool hasnulls = HeapTupleHasNulls(tuple);
934 ECB : int attnum;
935 : char *tp; /* ptr to tuple data */
936 : uint32 off; /* offset in tuple data */
937 GIC 105928959 : bits8 *bp = tup->t_bits; /* ptr to null bitmap in tuple */
938 ECB : bool slow; /* can we use/set attcacheoff? */
939 :
940 : /* We can only fetch as many attributes as the tuple has. */
941 GIC 105928959 : natts = Min(HeapTupleHeaderGetNatts(tuple->t_data), natts);
942 ECB :
943 : /*
944 : * Check whether the first call for this tuple, and initialize or restore
945 : * loop state.
946 : */
947 GIC 105928959 : attnum = slot->tts_nvalid;
948 CBC 105928959 : if (attnum == 0)
949 ECB : {
950 : /* Start from the first attribute */
951 GIC 81521166 : off = 0;
952 CBC 81521166 : slow = false;
953 ECB : }
954 : else
955 : {
956 : /* Restore state from previous execution */
957 GIC 24407793 : off = *offp;
958 CBC 24407793 : slow = TTS_SLOW(slot);
959 ECB : }
960 :
961 GIC 105928959 : tp = (char *) tup + tup->t_hoff;
962 ECB :
963 GIC 463264645 : for (; attnum < natts; attnum++)
964 ECB : {
965 GIC 357335686 : Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
966 ECB :
967 GIC 357335686 : if (hasnulls && att_isnull(attnum, bp))
968 ECB : {
969 GIC 23036629 : values[attnum] = (Datum) 0;
970 CBC 23036629 : isnull[attnum] = true;
971 23036629 : slow = true; /* can't use attcacheoff anymore */
972 23036629 : continue;
973 ECB : }
974 :
975 GIC 334299057 : isnull[attnum] = false;
976 ECB :
977 GIC 334299057 : if (!slow && thisatt->attcacheoff >= 0)
978 CBC 316344358 : off = thisatt->attcacheoff;
979 17954699 : else if (thisatt->attlen == -1)
980 ECB : {
981 : /*
982 : * We can only cache the offset for a varlena attribute if the
983 : * offset is already suitably aligned, so that there would be no
984 : * pad bytes in any case: then the offset will be valid for either
985 : * an aligned or unaligned value.
986 : */
987 GIC 7463437 : if (!slow &&
988 CBC 413955 : off == att_align_nominal(off, thisatt->attalign))
989 33122 : thisatt->attcacheoff = off;
990 ECB : else
991 : {
992 GIC 7016360 : off = att_align_pointer(off, thisatt->attalign, -1,
993 ECB : tp + off);
994 GIC 7016360 : slow = true;
995 ECB : }
996 : }
997 : else
998 : {
999 : /* not varlena, so safe to use att_align_nominal */
1000 GIC 10905217 : off = att_align_nominal(off, thisatt->attalign);
1001 ECB :
1002 GIC 10905217 : if (!slow)
1003 CBC 263483 : thisatt->attcacheoff = off;
1004 ECB : }
1005 :
1006 GIC 334299057 : values[attnum] = fetchatt(thisatt, tp + off);
1007 ECB :
1008 GIC 334299057 : off = att_addlength_pointer(off, thisatt->attlen, tp + off);
1009 ECB :
1010 GIC 334299057 : if (thisatt->attlen <= 0)
1011 CBC 24873783 : slow = true; /* can't use attcacheoff anymore */
1012 ECB : }
1013 :
1014 : /*
1015 : * Save state for next execution
1016 : */
1017 GIC 105928959 : slot->tts_nvalid = attnum;
1018 CBC 105928959 : *offp = off;
1019 105928959 : if (slow)
1020 21414853 : slot->tts_flags |= TTS_FLAG_SLOW;
1021 ECB : else
1022 GIC 84514106 : slot->tts_flags &= ~TTS_FLAG_SLOW;
1023 CBC 105928959 : }
1024 ECB :
1025 :
1026 : const TupleTableSlotOps TTSOpsVirtual = {
1027 : .base_slot_size = sizeof(VirtualTupleTableSlot),
1028 : .init = tts_virtual_init,
1029 : .release = tts_virtual_release,
1030 : .clear = tts_virtual_clear,
1031 : .getsomeattrs = tts_virtual_getsomeattrs,
1032 : .getsysattr = tts_virtual_getsysattr,
1033 : .materialize = tts_virtual_materialize,
1034 : .copyslot = tts_virtual_copyslot,
1035 :
1036 : /*
1037 : * A virtual tuple table slot can not "own" a heap tuple or a minimal
1038 : * tuple.
1039 : */
1040 : .get_heap_tuple = NULL,
1041 : .get_minimal_tuple = NULL,
1042 : .copy_heap_tuple = tts_virtual_copy_heap_tuple,
1043 : .copy_minimal_tuple = tts_virtual_copy_minimal_tuple
1044 : };
1045 :
1046 : const TupleTableSlotOps TTSOpsHeapTuple = {
1047 : .base_slot_size = sizeof(HeapTupleTableSlot),
1048 : .init = tts_heap_init,
1049 : .release = tts_heap_release,
1050 : .clear = tts_heap_clear,
1051 : .getsomeattrs = tts_heap_getsomeattrs,
1052 : .getsysattr = tts_heap_getsysattr,
1053 : .materialize = tts_heap_materialize,
1054 : .copyslot = tts_heap_copyslot,
1055 : .get_heap_tuple = tts_heap_get_heap_tuple,
1056 :
1057 : /* A heap tuple table slot can not "own" a minimal tuple. */
1058 : .get_minimal_tuple = NULL,
1059 : .copy_heap_tuple = tts_heap_copy_heap_tuple,
1060 : .copy_minimal_tuple = tts_heap_copy_minimal_tuple
1061 : };
1062 :
1063 : const TupleTableSlotOps TTSOpsMinimalTuple = {
1064 : .base_slot_size = sizeof(MinimalTupleTableSlot),
1065 : .init = tts_minimal_init,
1066 : .release = tts_minimal_release,
1067 : .clear = tts_minimal_clear,
1068 : .getsomeattrs = tts_minimal_getsomeattrs,
1069 : .getsysattr = tts_minimal_getsysattr,
1070 : .materialize = tts_minimal_materialize,
1071 : .copyslot = tts_minimal_copyslot,
1072 :
1073 : /* A minimal tuple table slot can not "own" a heap tuple. */
1074 : .get_heap_tuple = NULL,
1075 : .get_minimal_tuple = tts_minimal_get_minimal_tuple,
1076 : .copy_heap_tuple = tts_minimal_copy_heap_tuple,
1077 : .copy_minimal_tuple = tts_minimal_copy_minimal_tuple
1078 : };
1079 :
1080 : const TupleTableSlotOps TTSOpsBufferHeapTuple = {
1081 : .base_slot_size = sizeof(BufferHeapTupleTableSlot),
1082 : .init = tts_buffer_heap_init,
1083 : .release = tts_buffer_heap_release,
1084 : .clear = tts_buffer_heap_clear,
1085 : .getsomeattrs = tts_buffer_heap_getsomeattrs,
1086 : .getsysattr = tts_buffer_heap_getsysattr,
1087 : .materialize = tts_buffer_heap_materialize,
1088 : .copyslot = tts_buffer_heap_copyslot,
1089 : .get_heap_tuple = tts_buffer_heap_get_heap_tuple,
1090 :
1091 : /* A buffer heap tuple table slot can not "own" a minimal tuple. */
1092 : .get_minimal_tuple = NULL,
1093 : .copy_heap_tuple = tts_buffer_heap_copy_heap_tuple,
1094 : .copy_minimal_tuple = tts_buffer_heap_copy_minimal_tuple
1095 : };
1096 :
1097 :
1098 : /* ----------------------------------------------------------------
1099 : * tuple table create/delete functions
1100 : * ----------------------------------------------------------------
1101 : */
1102 :
1103 : /* --------------------------------
1104 : * MakeTupleTableSlot
1105 : *
1106 : * Basic routine to make an empty TupleTableSlot of given
1107 : * TupleTableSlotType. If tupleDesc is specified the slot's descriptor is
1108 : * fixed for its lifetime, gaining some efficiency. If that's
1109 : * undesirable, pass NULL.
1110 : * --------------------------------
1111 : */
1112 : TupleTableSlot *
1113 GIC 21902338 : MakeTupleTableSlot(TupleDesc tupleDesc,
1114 ECB : const TupleTableSlotOps *tts_ops)
1115 : {
1116 : Size basesz,
1117 : allocsz;
1118 : TupleTableSlot *slot;
1119 :
1120 GIC 21902338 : basesz = tts_ops->base_slot_size;
1121 ECB :
1122 : /*
1123 : * When a fixed descriptor is specified, we can reduce overhead by
1124 : * allocating the entire slot in one go.
1125 : */
1126 GIC 21902338 : if (tupleDesc)
1127 CBC 21883201 : allocsz = MAXALIGN(basesz) +
1128 21883201 : MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
1129 21883201 : MAXALIGN(tupleDesc->natts * sizeof(bool));
1130 ECB : else
1131 GIC 19137 : allocsz = basesz;
1132 ECB :
1133 GIC 21902338 : slot = palloc0(allocsz);
1134 ECB : /* const for optimization purposes, OK to modify at allocation time */
1135 GIC 21902338 : *((const TupleTableSlotOps **) &slot->tts_ops) = tts_ops;
1136 CBC 21902338 : slot->type = T_TupleTableSlot;
1137 21902338 : slot->tts_flags |= TTS_FLAG_EMPTY;
1138 21902338 : if (tupleDesc != NULL)
1139 21883201 : slot->tts_flags |= TTS_FLAG_FIXED;
1140 21902338 : slot->tts_tupleDescriptor = tupleDesc;
1141 21902338 : slot->tts_mcxt = CurrentMemoryContext;
1142 21902338 : slot->tts_nvalid = 0;
1143 ECB :
1144 GIC 21902338 : if (tupleDesc != NULL)
1145 ECB : {
1146 GIC 21883201 : slot->tts_values = (Datum *)
1147 ECB : (((char *) slot)
1148 GIC 21883201 : + MAXALIGN(basesz));
1149 CBC 21883201 : slot->tts_isnull = (bool *)
1150 ECB : (((char *) slot)
1151 GIC 21883201 : + MAXALIGN(basesz)
1152 CBC 21883201 : + MAXALIGN(tupleDesc->natts * sizeof(Datum)));
1153 ECB :
1154 GIC 21883201 : PinTupleDesc(tupleDesc);
1155 ECB : }
1156 :
1157 : /*
1158 : * And allow slot type specific initialization.
1159 : */
1160 GIC 21902338 : slot->tts_ops->init(slot);
1161 ECB :
1162 GIC 21902338 : return slot;
1163 ECB : }
1164 :
1165 : /* --------------------------------
1166 : * ExecAllocTableSlot
1167 : *
1168 : * Create a tuple table slot within a tuple table (which is just a List).
1169 : * --------------------------------
1170 : */
1171 : TupleTableSlot *
1172 GIC 862306 : ExecAllocTableSlot(List **tupleTable, TupleDesc desc,
1173 ECB : const TupleTableSlotOps *tts_ops)
1174 : {
1175 GIC 862306 : TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops);
1176 ECB :
1177 GIC 862306 : *tupleTable = lappend(*tupleTable, slot);
1178 ECB :
1179 GIC 862306 : return slot;
1180 ECB : }
1181 :
1182 : /* --------------------------------
1183 : * ExecResetTupleTable
1184 : *
1185 : * This releases any resources (buffer pins, tupdesc refcounts)
1186 : * held by the tuple table, and optionally releases the memory
1187 : * occupied by the tuple table data structure.
1188 : * It is expected that this routine be called by ExecEndPlan().
1189 : * --------------------------------
1190 : */
1191 : void
1192 GIC 405257 : ExecResetTupleTable(List *tupleTable, /* tuple table */
1193 ECB : bool shouldFree) /* true if we should free memory */
1194 : {
1195 : ListCell *lc;
1196 :
1197 GIC 1391558 : foreach(lc, tupleTable)
1198 ECB : {
1199 GIC 986301 : TupleTableSlot *slot = lfirst_node(TupleTableSlot, lc);
1200 ECB :
1201 : /* Always release resources and reset the slot to empty */
1202 GIC 986301 : ExecClearTuple(slot);
1203 CBC 986301 : slot->tts_ops->release(slot);
1204 986301 : if (slot->tts_tupleDescriptor)
1205 ECB : {
1206 GIC 986274 : ReleaseTupleDesc(slot->tts_tupleDescriptor);
1207 CBC 986274 : slot->tts_tupleDescriptor = NULL;
1208 ECB : }
1209 :
1210 : /* If shouldFree, release memory occupied by the slot itself */
1211 GIC 986301 : if (shouldFree)
1212 ECB : {
1213 GIC 2581 : if (!TTS_FIXED(slot))
1214 ECB : {
1215 UIC 0 : if (slot->tts_values)
1216 UBC 0 : pfree(slot->tts_values);
1217 0 : if (slot->tts_isnull)
1218 0 : pfree(slot->tts_isnull);
1219 EUB : }
1220 GIC 2581 : pfree(slot);
1221 ECB : }
1222 : }
1223 :
1224 : /* If shouldFree, release the list structure */
1225 GIC 405257 : if (shouldFree)
1226 CBC 2550 : list_free(tupleTable);
1227 405257 : }
1228 ECB :
1229 : /* --------------------------------
1230 : * MakeSingleTupleTableSlot
1231 : *
1232 : * This is a convenience routine for operations that need a standalone
1233 : * TupleTableSlot not gotten from the main executor tuple table. It makes
1234 : * a single slot of given TupleTableSlotType and initializes it to use the
1235 : * given tuple descriptor.
1236 : * --------------------------------
1237 : */
1238 : TupleTableSlot *
1239 GIC 21039960 : MakeSingleTupleTableSlot(TupleDesc tupdesc,
1240 ECB : const TupleTableSlotOps *tts_ops)
1241 : {
1242 GIC 21039960 : TupleTableSlot *slot = MakeTupleTableSlot(tupdesc, tts_ops);
1243 ECB :
1244 GIC 21039960 : return slot;
1245 ECB : }
1246 :
1247 : /* --------------------------------
1248 : * ExecDropSingleTupleTableSlot
1249 : *
1250 : * Release a TupleTableSlot made with MakeSingleTupleTableSlot.
1251 : * DON'T use this on a slot that's part of a tuple table list!
1252 : * --------------------------------
1253 : */
1254 : void
1255 GIC 20881990 : ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
1256 ECB : {
1257 : /* This should match ExecResetTupleTable's processing of one slot */
1258 GIC 20881990 : Assert(IsA(slot, TupleTableSlot));
1259 CBC 20881990 : ExecClearTuple(slot);
1260 20881990 : slot->tts_ops->release(slot);
1261 20881990 : if (slot->tts_tupleDescriptor)
1262 20881990 : ReleaseTupleDesc(slot->tts_tupleDescriptor);
1263 20881990 : if (!TTS_FIXED(slot))
1264 ECB : {
1265 UIC 0 : if (slot->tts_values)
1266 UBC 0 : pfree(slot->tts_values);
1267 0 : if (slot->tts_isnull)
1268 0 : pfree(slot->tts_isnull);
1269 EUB : }
1270 GIC 20881990 : pfree(slot);
1271 CBC 20881990 : }
1272 ECB :
1273 :
1274 : /* ----------------------------------------------------------------
1275 : * tuple table slot accessor functions
1276 : * ----------------------------------------------------------------
1277 : */
1278 :
1279 : /* --------------------------------
1280 : * ExecSetSlotDescriptor
1281 : *
1282 : * This function is used to set the tuple descriptor associated
1283 : * with the slot's tuple. The passed descriptor must have lifespan
1284 : * at least equal to the slot's. If it is a reference-counted descriptor
1285 : * then the reference count is incremented for as long as the slot holds
1286 : * a reference.
1287 : * --------------------------------
1288 : */
1289 : void
1290 GIC 19110 : ExecSetSlotDescriptor(TupleTableSlot *slot, /* slot to change */
1291 ECB : TupleDesc tupdesc) /* new tuple descriptor */
1292 : {
1293 GIC 19110 : Assert(!TTS_FIXED(slot));
1294 ECB :
1295 : /* For safety, make sure slot is empty before changing it */
1296 GIC 19110 : ExecClearTuple(slot);
1297 ECB :
1298 : /*
1299 : * Release any old descriptor. Also release old Datum/isnull arrays if
1300 : * present (we don't bother to check if they could be re-used).
1301 : */
1302 GIC 19110 : if (slot->tts_tupleDescriptor)
1303 LBC 0 : ReleaseTupleDesc(slot->tts_tupleDescriptor);
1304 EUB :
1305 GIC 19110 : if (slot->tts_values)
1306 LBC 0 : pfree(slot->tts_values);
1307 GBC 19110 : if (slot->tts_isnull)
1308 LBC 0 : pfree(slot->tts_isnull);
1309 EUB :
1310 : /*
1311 : * Install the new descriptor; if it's refcounted, bump its refcount.
1312 : */
1313 GIC 19110 : slot->tts_tupleDescriptor = tupdesc;
1314 CBC 19110 : PinTupleDesc(tupdesc);
1315 ECB :
1316 : /*
1317 : * Allocate Datum/isnull arrays of the appropriate size. These must have
1318 : * the same lifetime as the slot, so allocate in the slot's own context.
1319 : */
1320 GIC 19110 : slot->tts_values = (Datum *)
1321 CBC 19110 : MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(Datum));
1322 19110 : slot->tts_isnull = (bool *)
1323 19110 : MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(bool));
1324 19110 : }
1325 ECB :
1326 : /* --------------------------------
1327 : * ExecStoreHeapTuple
1328 : *
1329 : * This function is used to store an on-the-fly physical tuple into a specified
1330 : * slot in the tuple table.
1331 : *
1332 : * tuple: tuple to store
1333 : * slot: TTSOpsHeapTuple type slot to store it in
1334 : * shouldFree: true if ExecClearTuple should pfree() the tuple
1335 : * when done with it
1336 : *
1337 : * shouldFree is normally set 'true' for tuples constructed on-the-fly. But it
1338 : * can be 'false' when the referenced tuple is held in a tuple table slot
1339 : * belonging to a lower-level executor Proc node. In this case the lower-level
1340 : * slot retains ownership and responsibility for eventually releasing the
1341 : * tuple. When this method is used, we must be certain that the upper-level
1342 : * Proc node will lose interest in the tuple sooner than the lower-level one
1343 : * does! If you're not certain, copy the lower-level tuple with heap_copytuple
1344 : * and let the upper-level table slot assume ownership of the copy!
1345 : *
1346 : * Return value is just the passed-in slot pointer.
1347 : *
1348 : * If the target slot is not guaranteed to be TTSOpsHeapTuple type slot, use
1349 : * the, more expensive, ExecForceStoreHeapTuple().
1350 : * --------------------------------
1351 : */
1352 : TupleTableSlot *
1353 GIC 4222627 : ExecStoreHeapTuple(HeapTuple tuple,
1354 ECB : TupleTableSlot *slot,
1355 : bool shouldFree)
1356 : {
1357 : /*
1358 : * sanity checks
1359 : */
1360 GIC 4222627 : Assert(tuple != NULL);
1361 CBC 4222627 : Assert(slot != NULL);
1362 4222627 : Assert(slot->tts_tupleDescriptor != NULL);
1363 ECB :
1364 GIC 4222627 : if (unlikely(!TTS_IS_HEAPTUPLE(slot)))
1365 LBC 0 : elog(ERROR, "trying to store a heap tuple into wrong type of slot");
1366 GBC 4222627 : tts_heap_store_tuple(slot, tuple, shouldFree);
1367 ECB :
1368 GIC 4222627 : slot->tts_tableOid = tuple->t_tableOid;
1369 ECB :
1370 GIC 4222627 : return slot;
1371 ECB : }
1372 :
1373 : /* --------------------------------
1374 : * ExecStoreBufferHeapTuple
1375 : *
1376 : * This function is used to store an on-disk physical tuple from a buffer
1377 : * into a specified slot in the tuple table.
1378 : *
1379 : * tuple: tuple to store
1380 : * slot: TTSOpsBufferHeapTuple type slot to store it in
1381 : * buffer: disk buffer if tuple is in a disk page, else InvalidBuffer
1382 : *
1383 : * The tuple table code acquires a pin on the buffer which is held until the
1384 : * slot is cleared, so that the tuple won't go away on us.
1385 : *
1386 : * Return value is just the passed-in slot pointer.
1387 : *
1388 : * If the target slot is not guaranteed to be TTSOpsBufferHeapTuple type slot,
1389 : * use the, more expensive, ExecForceStoreHeapTuple().
1390 : * --------------------------------
1391 : */
1392 : TupleTableSlot *
1393 GIC 84064739 : ExecStoreBufferHeapTuple(HeapTuple tuple,
1394 ECB : TupleTableSlot *slot,
1395 : Buffer buffer)
1396 : {
1397 : /*
1398 : * sanity checks
1399 : */
1400 GIC 84064739 : Assert(tuple != NULL);
1401 CBC 84064739 : Assert(slot != NULL);
1402 84064739 : Assert(slot->tts_tupleDescriptor != NULL);
1403 84064739 : Assert(BufferIsValid(buffer));
1404 ECB :
1405 GIC 84064739 : if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1406 LBC 0 : elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1407 GBC 84064739 : tts_buffer_heap_store_tuple(slot, tuple, buffer, false);
1408 ECB :
1409 GIC 84064739 : slot->tts_tableOid = tuple->t_tableOid;
1410 ECB :
1411 GIC 84064739 : return slot;
1412 ECB : }
1413 :
1414 : /*
1415 : * Like ExecStoreBufferHeapTuple, but transfer an existing pin from the caller
1416 : * to the slot, i.e. the caller doesn't need to, and may not, release the pin.
1417 : */
1418 : TupleTableSlot *
1419 GIC 278304 : ExecStorePinnedBufferHeapTuple(HeapTuple tuple,
1420 ECB : TupleTableSlot *slot,
1421 : Buffer buffer)
1422 : {
1423 : /*
1424 : * sanity checks
1425 : */
1426 GIC 278304 : Assert(tuple != NULL);
1427 CBC 278304 : Assert(slot != NULL);
1428 278304 : Assert(slot->tts_tupleDescriptor != NULL);
1429 278304 : Assert(BufferIsValid(buffer));
1430 ECB :
1431 GIC 278304 : if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1432 LBC 0 : elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1433 GBC 278304 : tts_buffer_heap_store_tuple(slot, tuple, buffer, true);
1434 ECB :
1435 GIC 278304 : slot->tts_tableOid = tuple->t_tableOid;
1436 ECB :
1437 GIC 278304 : return slot;
1438 ECB : }
1439 :
1440 : /*
1441 : * Store a minimal tuple into TTSOpsMinimalTuple type slot.
1442 : *
1443 : * If the target slot is not guaranteed to be TTSOpsMinimalTuple type slot,
1444 : * use the, more expensive, ExecForceStoreMinimalTuple().
1445 : */
1446 : TupleTableSlot *
1447 GIC 25428750 : ExecStoreMinimalTuple(MinimalTuple mtup,
1448 ECB : TupleTableSlot *slot,
1449 : bool shouldFree)
1450 : {
1451 : /*
1452 : * sanity checks
1453 : */
1454 GIC 25428750 : Assert(mtup != NULL);
1455 CBC 25428750 : Assert(slot != NULL);
1456 25428750 : Assert(slot->tts_tupleDescriptor != NULL);
1457 ECB :
1458 GIC 25428750 : if (unlikely(!TTS_IS_MINIMALTUPLE(slot)))
1459 LBC 0 : elog(ERROR, "trying to store a minimal tuple into wrong type of slot");
1460 GBC 25428750 : tts_minimal_store_tuple(slot, mtup, shouldFree);
1461 ECB :
1462 GIC 25428750 : return slot;
1463 ECB : }
1464 :
1465 : /*
1466 : * Store a HeapTuple into any kind of slot, performing conversion if
1467 : * necessary.
1468 : */
1469 : void
1470 GIC 889090 : ExecForceStoreHeapTuple(HeapTuple tuple,
1471 ECB : TupleTableSlot *slot,
1472 : bool shouldFree)
1473 : {
1474 GIC 889090 : if (TTS_IS_HEAPTUPLE(slot))
1475 ECB : {
1476 GIC 213 : ExecStoreHeapTuple(tuple, slot, shouldFree);
1477 ECB : }
1478 GIC 888877 : else if (TTS_IS_BUFFERTUPLE(slot))
1479 ECB : {
1480 : MemoryContext oldContext;
1481 GIC 36008 : BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
1482 ECB :
1483 GIC 36008 : ExecClearTuple(slot);
1484 CBC 36008 : slot->tts_flags &= ~TTS_FLAG_EMPTY;
1485 36008 : oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
1486 36008 : bslot->base.tuple = heap_copytuple(tuple);
1487 36008 : slot->tts_flags |= TTS_FLAG_SHOULDFREE;
1488 36008 : MemoryContextSwitchTo(oldContext);
1489 ECB :
1490 GIC 36008 : if (shouldFree)
1491 CBC 35044 : pfree(tuple);
1492 ECB : }
1493 : else
1494 : {
1495 GIC 852869 : ExecClearTuple(slot);
1496 CBC 852869 : heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
1497 ECB : slot->tts_values, slot->tts_isnull);
1498 GIC 852869 : ExecStoreVirtualTuple(slot);
1499 ECB :
1500 GIC 852869 : if (shouldFree)
1501 ECB : {
1502 GIC 133799 : ExecMaterializeSlot(slot);
1503 CBC 133799 : pfree(tuple);
1504 ECB : }
1505 : }
1506 GIC 889090 : }
1507 ECB :
1508 : /*
1509 : * Store a MinimalTuple into any kind of slot, performing conversion if
1510 : * necessary.
1511 : */
1512 : void
1513 GIC 3545746 : ExecForceStoreMinimalTuple(MinimalTuple mtup,
1514 ECB : TupleTableSlot *slot,
1515 : bool shouldFree)
1516 : {
1517 GIC 3545746 : if (TTS_IS_MINIMALTUPLE(slot))
1518 ECB : {
1519 GIC 2210638 : tts_minimal_store_tuple(slot, mtup, shouldFree);
1520 ECB : }
1521 : else
1522 : {
1523 : HeapTupleData htup;
1524 :
1525 GIC 1335108 : ExecClearTuple(slot);
1526 ECB :
1527 GIC 1335108 : htup.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
1528 CBC 1335108 : htup.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
1529 1335108 : heap_deform_tuple(&htup, slot->tts_tupleDescriptor,
1530 ECB : slot->tts_values, slot->tts_isnull);
1531 GIC 1335108 : ExecStoreVirtualTuple(slot);
1532 ECB :
1533 GIC 1335108 : if (shouldFree)
1534 ECB : {
1535 GIC 735096 : ExecMaterializeSlot(slot);
1536 CBC 735096 : pfree(mtup);
1537 ECB : }
1538 : }
1539 GIC 3545746 : }
1540 ECB :
1541 : /* --------------------------------
1542 : * ExecStoreVirtualTuple
1543 : * Mark a slot as containing a virtual tuple.
1544 : *
1545 : * The protocol for loading a slot with virtual tuple data is:
1546 : * * Call ExecClearTuple to mark the slot empty.
1547 : * * Store data into the Datum/isnull arrays.
1548 : * * Call ExecStoreVirtualTuple to mark the slot valid.
1549 : * This is a bit unclean but it avoids one round of data copying.
1550 : * --------------------------------
1551 : */
1552 : TupleTableSlot *
1553 GIC 13213313 : ExecStoreVirtualTuple(TupleTableSlot *slot)
1554 ECB : {
1555 : /*
1556 : * sanity checks
1557 : */
1558 GIC 13213313 : Assert(slot != NULL);
1559 CBC 13213313 : Assert(slot->tts_tupleDescriptor != NULL);
1560 13213313 : Assert(TTS_EMPTY(slot));
1561 ECB :
1562 GIC 13213313 : slot->tts_flags &= ~TTS_FLAG_EMPTY;
1563 CBC 13213313 : slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
1564 ECB :
1565 GIC 13213313 : return slot;
1566 ECB : }
1567 :
1568 : /* --------------------------------
1569 : * ExecStoreAllNullTuple
1570 : * Set up the slot to contain a null in every column.
1571 : *
1572 : * At first glance this might sound just like ExecClearTuple, but it's
1573 : * entirely different: the slot ends up full, not empty.
1574 : * --------------------------------
1575 : */
1576 : TupleTableSlot *
1577 GIC 311223 : ExecStoreAllNullTuple(TupleTableSlot *slot)
1578 ECB : {
1579 : /*
1580 : * sanity checks
1581 : */
1582 GIC 311223 : Assert(slot != NULL);
1583 CBC 311223 : Assert(slot->tts_tupleDescriptor != NULL);
1584 ECB :
1585 : /* Clear any old contents */
1586 GIC 311223 : ExecClearTuple(slot);
1587 ECB :
1588 : /*
1589 : * Fill all the columns of the virtual tuple with nulls
1590 : */
1591 GIC 5192225 : MemSet(slot->tts_values, 0,
1592 ECB : slot->tts_tupleDescriptor->natts * sizeof(Datum));
1593 GIC 311223 : memset(slot->tts_isnull, true,
1594 CBC 311223 : slot->tts_tupleDescriptor->natts * sizeof(bool));
1595 ECB :
1596 GIC 311223 : return ExecStoreVirtualTuple(slot);
1597 ECB : }
1598 :
1599 : /*
1600 : * Store a HeapTuple in datum form, into a slot. That always requires
1601 : * deforming it and storing it in virtual form.
1602 : *
1603 : * Until the slot is materialized, the contents of the slot depend on the
1604 : * datum.
1605 : */
1606 : void
1607 GIC 3 : ExecStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
1608 ECB : {
1609 GIC 3 : HeapTupleData tuple = {0};
1610 ECB : HeapTupleHeader td;
1611 :
1612 GIC 3 : td = DatumGetHeapTupleHeader(data);
1613 ECB :
1614 GIC 3 : tuple.t_len = HeapTupleHeaderGetDatumLength(td);
1615 CBC 3 : tuple.t_self = td->t_ctid;
1616 3 : tuple.t_data = td;
1617 ECB :
1618 GIC 3 : ExecClearTuple(slot);
1619 ECB :
1620 GIC 3 : heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
1621 ECB : slot->tts_values, slot->tts_isnull);
1622 GIC 3 : ExecStoreVirtualTuple(slot);
1623 CBC 3 : }
1624 ECB :
1625 : /*
1626 : * ExecFetchSlotHeapTuple - fetch HeapTuple representing the slot's content
1627 : *
1628 : * The returned HeapTuple represents the slot's content as closely as
1629 : * possible.
1630 : *
1631 : * If materialize is true, the contents of the slots will be made independent
1632 : * from the underlying storage (i.e. all buffer pins are released, memory is
1633 : * allocated in the slot's context).
1634 : *
1635 : * If shouldFree is not-NULL it'll be set to true if the returned tuple has
1636 : * been allocated in the calling memory context, and must be freed by the
1637 : * caller (via explicit pfree() or a memory context reset).
1638 : *
1639 : * NB: If materialize is true, modifications of the returned tuple are
1640 : * allowed. But it depends on the type of the slot whether such modifications
1641 : * will also affect the slot's contents. While that is not the nicest
1642 : * behaviour, all such modifications are in the process of being removed.
1643 : */
1644 : HeapTuple
1645 GIC 27537058 : ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
1646 ECB : {
1647 : /*
1648 : * sanity checks
1649 : */
1650 GIC 27537058 : Assert(slot != NULL);
1651 CBC 27537058 : Assert(!TTS_EMPTY(slot));
1652 ECB :
1653 : /* Materialize the tuple so that the slot "owns" it, if requested. */
1654 GIC 27537058 : if (materialize)
1655 CBC 12470909 : slot->tts_ops->materialize(slot);
1656 ECB :
1657 GIC 27537058 : if (slot->tts_ops->get_heap_tuple == NULL)
1658 ECB : {
1659 GIC 1420107 : if (shouldFree)
1660 CBC 1420107 : *shouldFree = true;
1661 1420107 : return slot->tts_ops->copy_heap_tuple(slot);
1662 ECB : }
1663 : else
1664 : {
1665 GIC 26116951 : if (shouldFree)
1666 CBC 22449785 : *shouldFree = false;
1667 26116951 : return slot->tts_ops->get_heap_tuple(slot);
1668 ECB : }
1669 : }
1670 :
1671 : /* --------------------------------
1672 : * ExecFetchSlotMinimalTuple
1673 : * Fetch the slot's minimal physical tuple.
1674 : *
1675 : * If the given tuple table slot can hold a minimal tuple, indicated by a
1676 : * non-NULL get_minimal_tuple callback, the function returns the minimal
1677 : * tuple returned by that callback. It assumes that the minimal tuple
1678 : * returned by the callback is "owned" by the slot i.e. the slot is
1679 : * responsible for freeing the memory consumed by the tuple. Hence it sets
1680 : * *shouldFree to false, indicating that the caller should not free the
1681 : * memory consumed by the minimal tuple. In this case the returned minimal
1682 : * tuple should be considered as read-only.
1683 : *
1684 : * If that callback is not supported, it calls copy_minimal_tuple callback
1685 : * which is expected to return a copy of minimal tuple representing the
1686 : * contents of the slot. In this case *shouldFree is set to true,
1687 : * indicating the caller that it should free the memory consumed by the
1688 : * minimal tuple. In this case the returned minimal tuple may be written
1689 : * up.
1690 : * --------------------------------
1691 : */
1692 : MinimalTuple
1693 GIC 11018182 : ExecFetchSlotMinimalTuple(TupleTableSlot *slot,
1694 ECB : bool *shouldFree)
1695 : {
1696 : /*
1697 : * sanity checks
1698 : */
1699 GIC 11018182 : Assert(slot != NULL);
1700 CBC 11018182 : Assert(!TTS_EMPTY(slot));
1701 ECB :
1702 GIC 11018182 : if (slot->tts_ops->get_minimal_tuple)
1703 ECB : {
1704 GIC 2447307 : if (shouldFree)
1705 CBC 2447307 : *shouldFree = false;
1706 2447307 : return slot->tts_ops->get_minimal_tuple(slot);
1707 ECB : }
1708 : else
1709 : {
1710 GIC 8570875 : if (shouldFree)
1711 CBC 8570875 : *shouldFree = true;
1712 8570875 : return slot->tts_ops->copy_minimal_tuple(slot);
1713 ECB : }
1714 : }
1715 :
1716 : /* --------------------------------
1717 : * ExecFetchSlotHeapTupleDatum
1718 : * Fetch the slot's tuple as a composite-type Datum.
1719 : *
1720 : * The result is always freshly palloc'd in the caller's memory context.
1721 : * --------------------------------
1722 : */
1723 : Datum
1724 GIC 30417 : ExecFetchSlotHeapTupleDatum(TupleTableSlot *slot)
1725 ECB : {
1726 : HeapTuple tup;
1727 : TupleDesc tupdesc;
1728 : bool shouldFree;
1729 : Datum ret;
1730 :
1731 : /* Fetch slot's contents in regular-physical-tuple form */
1732 GIC 30417 : tup = ExecFetchSlotHeapTuple(slot, false, &shouldFree);
1733 CBC 30417 : tupdesc = slot->tts_tupleDescriptor;
1734 ECB :
1735 : /* Convert to Datum form */
1736 GIC 30417 : ret = heap_copy_tuple_as_datum(tup, tupdesc);
1737 ECB :
1738 GIC 30417 : if (shouldFree)
1739 CBC 30417 : pfree(tup);
1740 ECB :
1741 GIC 30417 : return ret;
1742 ECB : }
1743 :
1744 : /* ----------------------------------------------------------------
1745 : * convenience initialization routines
1746 : * ----------------------------------------------------------------
1747 : */
1748 :
1749 : /* ----------------
1750 : * ExecInitResultTypeTL
1751 : *
1752 : * Initialize result type, using the plan node's targetlist.
1753 : * ----------------
1754 : */
1755 : void
1756 GIC 557413 : ExecInitResultTypeTL(PlanState *planstate)
1757 ECB : {
1758 GIC 557413 : TupleDesc tupDesc = ExecTypeFromTL(planstate->plan->targetlist);
1759 ECB :
1760 GIC 557413 : planstate->ps_ResultTupleDesc = tupDesc;
1761 CBC 557413 : }
1762 ECB :
1763 : /* --------------------------------
1764 : * ExecInit{Result,Scan,Extra}TupleSlot[TL]
1765 : *
1766 : * These are convenience routines to initialize the specified slot
1767 : * in nodes inheriting the appropriate state. ExecInitExtraTupleSlot
1768 : * is used for initializing special-purpose slots.
1769 : * --------------------------------
1770 : */
1771 :
1772 : /* ----------------
1773 : * ExecInitResultTupleSlotTL
1774 : *
1775 : * Initialize result tuple slot, using the tuple descriptor previously
1776 : * computed with ExecInitResultTypeTL().
1777 : * ----------------
1778 : */
1779 : void
1780 GIC 377971 : ExecInitResultSlot(PlanState *planstate, const TupleTableSlotOps *tts_ops)
1781 ECB : {
1782 : TupleTableSlot *slot;
1783 :
1784 GIC 377971 : slot = ExecAllocTableSlot(&planstate->state->es_tupleTable,
1785 ECB : planstate->ps_ResultTupleDesc, tts_ops);
1786 GIC 377971 : planstate->ps_ResultTupleSlot = slot;
1787 ECB :
1788 GIC 377971 : planstate->resultopsfixed = planstate->ps_ResultTupleDesc != NULL;
1789 CBC 377971 : planstate->resultops = tts_ops;
1790 377971 : planstate->resultopsset = true;
1791 377971 : }
1792 ECB :
1793 : /* ----------------
1794 : * ExecInitResultTupleSlotTL
1795 : *
1796 : * Initialize result tuple slot, using the plan node's targetlist.
1797 : * ----------------
1798 : */
1799 : void
1800 GIC 277097 : ExecInitResultTupleSlotTL(PlanState *planstate,
1801 ECB : const TupleTableSlotOps *tts_ops)
1802 : {
1803 GIC 277097 : ExecInitResultTypeTL(planstate);
1804 CBC 277097 : ExecInitResultSlot(planstate, tts_ops);
1805 277097 : }
1806 ECB :
1807 : /* ----------------
1808 : * ExecInitScanTupleSlot
1809 : * ----------------
1810 : */
1811 : void
1812 GIC 260872 : ExecInitScanTupleSlot(EState *estate, ScanState *scanstate,
1813 ECB : TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
1814 : {
1815 GIC 260872 : scanstate->ss_ScanTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable,
1816 ECB : tupledesc, tts_ops);
1817 GIC 260872 : scanstate->ps.scandesc = tupledesc;
1818 CBC 260872 : scanstate->ps.scanopsfixed = tupledesc != NULL;
1819 260872 : scanstate->ps.scanops = tts_ops;
1820 260872 : scanstate->ps.scanopsset = true;
1821 260872 : }
1822 ECB :
1823 : /* ----------------
1824 : * ExecInitExtraTupleSlot
1825 : *
1826 : * Return a newly created slot. If tupledesc is non-NULL the slot will have
1827 : * that as its fixed tupledesc. Otherwise the caller needs to use
1828 : * ExecSetSlotDescriptor() to set the descriptor before use.
1829 : * ----------------
1830 : */
1831 : TupleTableSlot *
1832 GIC 212749 : ExecInitExtraTupleSlot(EState *estate,
1833 ECB : TupleDesc tupledesc,
1834 : const TupleTableSlotOps *tts_ops)
1835 : {
1836 GIC 212749 : return ExecAllocTableSlot(&estate->es_tupleTable, tupledesc, tts_ops);
1837 ECB : }
1838 :
1839 : /* ----------------
1840 : * ExecInitNullTupleSlot
1841 : *
1842 : * Build a slot containing an all-nulls tuple of the given type.
1843 : * This is used as a substitute for an input tuple when performing an
1844 : * outer join.
1845 : * ----------------
1846 : */
1847 : TupleTableSlot *
1848 GIC 16768 : ExecInitNullTupleSlot(EState *estate, TupleDesc tupType,
1849 ECB : const TupleTableSlotOps *tts_ops)
1850 : {
1851 GIC 16768 : TupleTableSlot *slot = ExecInitExtraTupleSlot(estate, tupType, tts_ops);
1852 ECB :
1853 GIC 16768 : return ExecStoreAllNullTuple(slot);
1854 ECB : }
1855 :
1856 : /* ---------------------------------------------------------------
1857 : * Routines for setting/accessing attributes in a slot.
1858 : * ---------------------------------------------------------------
1859 : */
1860 :
1861 : /*
1862 : * Fill in missing values for a TupleTableSlot.
1863 : *
1864 : * This is only exposed because it's needed for JIT compiled tuple
1865 : * deforming. That exception aside, there should be no callers outside of this
1866 : * file.
1867 : */
1868 : void
1869 GIC 2829 : slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum)
1870 ECB : {
1871 GIC 2829 : AttrMissing *attrmiss = NULL;
1872 ECB :
1873 GIC 2829 : if (slot->tts_tupleDescriptor->constr)
1874 CBC 2253 : attrmiss = slot->tts_tupleDescriptor->constr->missing;
1875 ECB :
1876 GIC 2829 : if (!attrmiss)
1877 ECB : {
1878 : /* no missing values array at all, so just fill everything in as NULL */
1879 GIC 615 : memset(slot->tts_values + startAttNum, 0,
1880 CBC 615 : (lastAttNum - startAttNum) * sizeof(Datum));
1881 615 : memset(slot->tts_isnull + startAttNum, 1,
1882 615 : (lastAttNum - startAttNum) * sizeof(bool));
1883 ECB : }
1884 : else
1885 : {
1886 : int missattnum;
1887 :
1888 : /* if there is a missing values array we must process them one by one */
1889 GIC 2214 : for (missattnum = startAttNum;
1890 CBC 5124 : missattnum < lastAttNum;
1891 2910 : missattnum++)
1892 ECB : {
1893 GIC 2910 : slot->tts_values[missattnum] = attrmiss[missattnum].am_value;
1894 CBC 2910 : slot->tts_isnull[missattnum] = !attrmiss[missattnum].am_present;
1895 ECB : }
1896 : }
1897 GIC 2829 : }
1898 ECB :
1899 : /*
1900 : * slot_getsomeattrs_int - workhorse for slot_getsomeattrs()
1901 : */
1902 : void
1903 GIC 105171780 : slot_getsomeattrs_int(TupleTableSlot *slot, int attnum)
1904 ECB : {
1905 : /* Check for caller errors */
1906 GIC 105171780 : Assert(slot->tts_nvalid < attnum); /* checked in slot_getsomeattrs */
1907 CBC 105171780 : Assert(attnum > 0);
1908 ECB :
1909 GIC 105171780 : if (unlikely(attnum > slot->tts_tupleDescriptor->natts))
1910 LBC 0 : elog(ERROR, "invalid attribute number %d", attnum);
1911 EUB :
1912 : /* Fetch as many attributes as possible from the underlying tuple. */
1913 GIC 105171780 : slot->tts_ops->getsomeattrs(slot, attnum);
1914 ECB :
1915 : /*
1916 : * If the underlying tuple doesn't have enough attributes, tuple
1917 : * descriptor must have the missing attributes.
1918 : */
1919 GIC 105171780 : if (unlikely(slot->tts_nvalid < attnum))
1920 ECB : {
1921 GIC 2829 : slot_getmissingattrs(slot, slot->tts_nvalid, attnum);
1922 CBC 2829 : slot->tts_nvalid = attnum;
1923 ECB : }
1924 GIC 105171780 : }
1925 ECB :
1926 : /* ----------------------------------------------------------------
1927 : * ExecTypeFromTL
1928 : *
1929 : * Generate a tuple descriptor for the result tuple of a targetlist.
1930 : * (A parse/plan tlist must be passed, not an ExprState tlist.)
1931 : * Note that resjunk columns, if any, are included in the result.
1932 : *
1933 : * Currently there are about 4 different places where we create
1934 : * TupleDescriptors. They should all be merged, or perhaps
1935 : * be rewritten to call BuildDesc().
1936 : * ----------------------------------------------------------------
1937 : */
1938 : TupleDesc
1939 GIC 569995 : ExecTypeFromTL(List *targetList)
1940 ECB : {
1941 GIC 569995 : return ExecTypeFromTLInternal(targetList, false);
1942 ECB : }
1943 :
1944 : /* ----------------------------------------------------------------
1945 : * ExecCleanTypeFromTL
1946 : *
1947 : * Same as above, but resjunk columns are omitted from the result.
1948 : * ----------------------------------------------------------------
1949 : */
1950 : TupleDesc
1951 GIC 42793 : ExecCleanTypeFromTL(List *targetList)
1952 ECB : {
1953 GIC 42793 : return ExecTypeFromTLInternal(targetList, true);
1954 ECB : }
1955 :
1956 : static TupleDesc
1957 GIC 612788 : ExecTypeFromTLInternal(List *targetList, bool skipjunk)
1958 ECB : {
1959 : TupleDesc typeInfo;
1960 : ListCell *l;
1961 : int len;
1962 GIC 612788 : int cur_resno = 1;
1963 ECB :
1964 GIC 612788 : if (skipjunk)
1965 CBC 42793 : len = ExecCleanTargetListLength(targetList);
1966 ECB : else
1967 GIC 569995 : len = ExecTargetListLength(targetList);
1968 CBC 612788 : typeInfo = CreateTemplateTupleDesc(len);
1969 ECB :
1970 GIC 2908123 : foreach(l, targetList)
1971 ECB : {
1972 GIC 2295335 : TargetEntry *tle = lfirst(l);
1973 ECB :
1974 GIC 2295335 : if (skipjunk && tle->resjunk)
1975 CBC 12750 : continue;
1976 6847755 : TupleDescInitEntry(typeInfo,
1977 ECB : cur_resno,
1978 GIC 2282585 : tle->resname,
1979 CBC 2282585 : exprType((Node *) tle->expr),
1980 2282585 : exprTypmod((Node *) tle->expr),
1981 ECB : 0);
1982 GIC 2282585 : TupleDescInitEntryCollation(typeInfo,
1983 ECB : cur_resno,
1984 GIC 2282585 : exprCollation((Node *) tle->expr));
1985 CBC 2282585 : cur_resno++;
1986 ECB : }
1987 :
1988 GIC 612788 : return typeInfo;
1989 ECB : }
1990 :
1991 : /*
1992 : * ExecTypeFromExprList - build a tuple descriptor from a list of Exprs
1993 : *
1994 : * This is roughly like ExecTypeFromTL, but we work from bare expressions
1995 : * not TargetEntrys. No names are attached to the tupledesc's columns.
1996 : */
1997 : TupleDesc
1998 GIC 5774 : ExecTypeFromExprList(List *exprList)
1999 ECB : {
2000 : TupleDesc typeInfo;
2001 : ListCell *lc;
2002 GIC 5774 : int cur_resno = 1;
2003 ECB :
2004 GIC 5774 : typeInfo = CreateTemplateTupleDesc(list_length(exprList));
2005 ECB :
2006 GIC 15943 : foreach(lc, exprList)
2007 ECB : {
2008 GIC 10169 : Node *e = lfirst(lc);
2009 ECB :
2010 GIC 10169 : TupleDescInitEntry(typeInfo,
2011 ECB : cur_resno,
2012 : NULL,
2013 : exprType(e),
2014 : exprTypmod(e),
2015 : 0);
2016 GIC 10169 : TupleDescInitEntryCollation(typeInfo,
2017 ECB : cur_resno,
2018 : exprCollation(e));
2019 GIC 10169 : cur_resno++;
2020 ECB : }
2021 :
2022 GIC 5774 : return typeInfo;
2023 ECB : }
2024 :
2025 : /*
2026 : * ExecTypeSetColNames - set column names in a RECORD TupleDesc
2027 : *
2028 : * Column names must be provided as an alias list (list of String nodes).
2029 : */
2030 : void
2031 GIC 1746 : ExecTypeSetColNames(TupleDesc typeInfo, List *namesList)
2032 ECB : {
2033 GIC 1746 : int colno = 0;
2034 ECB : ListCell *lc;
2035 :
2036 : /* It's only OK to change col names in a not-yet-blessed RECORD type */
2037 GIC 1746 : Assert(typeInfo->tdtypeid == RECORDOID);
2038 CBC 1746 : Assert(typeInfo->tdtypmod < 0);
2039 ECB :
2040 GIC 6118 : foreach(lc, namesList)
2041 ECB : {
2042 GIC 4372 : char *cname = strVal(lfirst(lc));
2043 ECB : Form_pg_attribute attr;
2044 :
2045 : /* Guard against too-long names list (probably can't happen) */
2046 GIC 4372 : if (colno >= typeInfo->natts)
2047 LBC 0 : break;
2048 GBC 4372 : attr = TupleDescAttr(typeInfo, colno);
2049 CBC 4372 : colno++;
2050 ECB :
2051 : /*
2052 : * Do nothing for empty aliases or dropped columns (these cases
2053 : * probably can't arise in RECORD types, either)
2054 : */
2055 GIC 4372 : if (cname[0] == '\0' || attr->attisdropped)
2056 CBC 13 : continue;
2057 ECB :
2058 : /* OK, assign the column name */
2059 GIC 4359 : namestrcpy(&(attr->attname), cname);
2060 ECB : }
2061 GIC 1746 : }
2062 ECB :
2063 : /*
2064 : * BlessTupleDesc - make a completed tuple descriptor useful for SRFs
2065 : *
2066 : * Rowtype Datums returned by a function must contain valid type information.
2067 : * This happens "for free" if the tupdesc came from a relcache entry, but
2068 : * not if we have manufactured a tupdesc for a transient RECORD datatype.
2069 : * In that case we have to notify typcache.c of the existence of the type.
2070 : */
2071 : TupleDesc
2072 GIC 31058 : BlessTupleDesc(TupleDesc tupdesc)
2073 ECB : {
2074 GIC 31058 : if (tupdesc->tdtypeid == RECORDOID &&
2075 CBC 29589 : tupdesc->tdtypmod < 0)
2076 12829 : assign_record_type_typmod(tupdesc);
2077 ECB :
2078 GIC 31058 : return tupdesc; /* just for notational convenience */
2079 ECB : }
2080 :
2081 : /*
2082 : * TupleDescGetAttInMetadata - Build an AttInMetadata structure based on the
2083 : * supplied TupleDesc. AttInMetadata can be used in conjunction with C strings
2084 : * to produce a properly formed tuple.
2085 : */
2086 : AttInMetadata *
2087 GIC 2847 : TupleDescGetAttInMetadata(TupleDesc tupdesc)
2088 ECB : {
2089 GIC 2847 : int natts = tupdesc->natts;
2090 ECB : int i;
2091 : Oid atttypeid;
2092 : Oid attinfuncid;
2093 : FmgrInfo *attinfuncinfo;
2094 : Oid *attioparams;
2095 : int32 *atttypmods;
2096 : AttInMetadata *attinmeta;
2097 :
2098 GIC 2847 : attinmeta = (AttInMetadata *) palloc(sizeof(AttInMetadata));
2099 ECB :
2100 : /* "Bless" the tupledesc so that we can make rowtype datums with it */
2101 GIC 2847 : attinmeta->tupdesc = BlessTupleDesc(tupdesc);
2102 ECB :
2103 : /*
2104 : * Gather info needed later to call the "in" function for each attribute
2105 : */
2106 GIC 2847 : attinfuncinfo = (FmgrInfo *) palloc0(natts * sizeof(FmgrInfo));
2107 CBC 2847 : attioparams = (Oid *) palloc0(natts * sizeof(Oid));
2108 2847 : atttypmods = (int32 *) palloc0(natts * sizeof(int32));
2109 ECB :
2110 GIC 26587 : for (i = 0; i < natts; i++)
2111 ECB : {
2112 GIC 23740 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
2113 ECB :
2114 : /* Ignore dropped attributes */
2115 GIC 23740 : if (!att->attisdropped)
2116 ECB : {
2117 GIC 23627 : atttypeid = att->atttypid;
2118 CBC 23627 : getTypeInputInfo(atttypeid, &attinfuncid, &attioparams[i]);
2119 23627 : fmgr_info(attinfuncid, &attinfuncinfo[i]);
2120 23627 : atttypmods[i] = att->atttypmod;
2121 ECB : }
2122 : }
2123 GIC 2847 : attinmeta->attinfuncs = attinfuncinfo;
2124 CBC 2847 : attinmeta->attioparams = attioparams;
2125 2847 : attinmeta->atttypmods = atttypmods;
2126 ECB :
2127 GIC 2847 : return attinmeta;
2128 ECB : }
2129 :
2130 : /*
2131 : * BuildTupleFromCStrings - build a HeapTuple given user data in C string form.
2132 : * values is an array of C strings, one for each attribute of the return tuple.
2133 : * A NULL string pointer indicates we want to create a NULL field.
2134 : */
2135 : HeapTuple
2136 GIC 407734 : BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
2137 ECB : {
2138 GIC 407734 : TupleDesc tupdesc = attinmeta->tupdesc;
2139 CBC 407734 : int natts = tupdesc->natts;
2140 ECB : Datum *dvalues;
2141 : bool *nulls;
2142 : int i;
2143 : HeapTuple tuple;
2144 :
2145 GIC 407734 : dvalues = (Datum *) palloc(natts * sizeof(Datum));
2146 CBC 407734 : nulls = (bool *) palloc(natts * sizeof(bool));
2147 ECB :
2148 : /*
2149 : * Call the "in" function for each non-dropped attribute, even for nulls,
2150 : * to support domains.
2151 : */
2152 GIC 7209235 : for (i = 0; i < natts; i++)
2153 ECB : {
2154 GIC 6801502 : if (!TupleDescAttr(tupdesc, i)->attisdropped)
2155 ECB : {
2156 : /* Non-dropped attributes */
2157 GIC 13603003 : dvalues[i] = InputFunctionCall(&attinmeta->attinfuncs[i],
2158 CBC 6801502 : values[i],
2159 6801502 : attinmeta->attioparams[i],
2160 6801502 : attinmeta->atttypmods[i]);
2161 6801501 : if (values[i] != NULL)
2162 4601822 : nulls[i] = false;
2163 ECB : else
2164 GIC 2199679 : nulls[i] = true;
2165 ECB : }
2166 : else
2167 : {
2168 : /* Handle dropped attributes by setting to NULL */
2169 UIC 0 : dvalues[i] = (Datum) 0;
2170 UBC 0 : nulls[i] = true;
2171 EUB : }
2172 : }
2173 :
2174 : /*
2175 : * Form a tuple
2176 : */
2177 GIC 407733 : tuple = heap_form_tuple(tupdesc, dvalues, nulls);
2178 ECB :
2179 : /*
2180 : * Release locally palloc'd space. XXX would probably be good to pfree
2181 : * values of pass-by-reference datums, as well.
2182 : */
2183 GIC 407733 : pfree(dvalues);
2184 CBC 407733 : pfree(nulls);
2185 ECB :
2186 GIC 407733 : return tuple;
2187 ECB : }
2188 :
2189 : /*
2190 : * HeapTupleHeaderGetDatum - convert a HeapTupleHeader pointer to a Datum.
2191 : *
2192 : * This must *not* get applied to an on-disk tuple; the tuple should be
2193 : * freshly made by heap_form_tuple or some wrapper routine for it (such as
2194 : * BuildTupleFromCStrings). Be sure also that the tupledesc used to build
2195 : * the tuple has a properly "blessed" rowtype.
2196 : *
2197 : * Formerly this was a macro equivalent to PointerGetDatum, relying on the
2198 : * fact that heap_form_tuple fills in the appropriate tuple header fields
2199 : * for a composite Datum. However, we now require that composite Datums not
2200 : * contain any external TOAST pointers. We do not want heap_form_tuple itself
2201 : * to enforce that; more specifically, the rule applies only to actual Datums
2202 : * and not to HeapTuple structures. Therefore, HeapTupleHeaderGetDatum is
2203 : * now a function that detects whether there are externally-toasted fields
2204 : * and constructs a new tuple with inlined fields if so. We still need
2205 : * heap_form_tuple to insert the Datum header fields, because otherwise this
2206 : * code would have no way to obtain a tupledesc for the tuple.
2207 : *
2208 : * Note that if we do build a new tuple, it's palloc'd in the current
2209 : * memory context. Beware of code that changes context between the initial
2210 : * heap_form_tuple/etc call and calling HeapTuple(Header)GetDatum.
2211 : *
2212 : * For performance-critical callers, it could be worthwhile to take extra
2213 : * steps to ensure that there aren't TOAST pointers in the output of
2214 : * heap_form_tuple to begin with. It's likely however that the costs of the
2215 : * typcache lookup and tuple disassembly/reassembly are swamped by TOAST
2216 : * dereference costs, so that the benefits of such extra effort would be
2217 : * minimal.
2218 : *
2219 : * XXX it would likely be better to create wrapper functions that produce
2220 : * a composite Datum from the field values in one step. However, there's
2221 : * enough code using the existing APIs that we couldn't get rid of this
2222 : * hack anytime soon.
2223 : */
2224 : Datum
2225 GIC 493533 : HeapTupleHeaderGetDatum(HeapTupleHeader tuple)
2226 ECB : {
2227 : Datum result;
2228 : TupleDesc tupDesc;
2229 :
2230 : /* No work if there are no external TOAST pointers in the tuple */
2231 GIC 493533 : if (!HeapTupleHeaderHasExternal(tuple))
2232 CBC 493527 : return PointerGetDatum(tuple);
2233 ECB :
2234 : /* Use the type data saved by heap_form_tuple to look up the rowtype */
2235 GIC 6 : tupDesc = lookup_rowtype_tupdesc(HeapTupleHeaderGetTypeId(tuple),
2236 ECB : HeapTupleHeaderGetTypMod(tuple));
2237 :
2238 : /* And do the flattening */
2239 GIC 6 : result = toast_flatten_tuple_to_datum(tuple,
2240 CBC 6 : HeapTupleHeaderGetDatumLength(tuple),
2241 ECB : tupDesc);
2242 :
2243 GIC 6 : ReleaseTupleDesc(tupDesc);
2244 ECB :
2245 GIC 6 : return result;
2246 ECB : }
2247 :
2248 :
2249 : /*
2250 : * Functions for sending tuples to the frontend (or other specified destination)
2251 : * as though it is a SELECT result. These are used by utility commands that
2252 : * need to project directly to the destination and don't need or want full
2253 : * table function capability. Currently used by EXPLAIN and SHOW ALL.
2254 : */
2255 : TupOutputState *
2256 GIC 12020 : begin_tup_output_tupdesc(DestReceiver *dest,
2257 ECB : TupleDesc tupdesc,
2258 : const TupleTableSlotOps *tts_ops)
2259 : {
2260 : TupOutputState *tstate;
2261 :
2262 GIC 12020 : tstate = (TupOutputState *) palloc(sizeof(TupOutputState));
2263 ECB :
2264 GIC 12020 : tstate->slot = MakeSingleTupleTableSlot(tupdesc, tts_ops);
2265 CBC 12020 : tstate->dest = dest;
2266 ECB :
2267 GIC 12020 : tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);
2268 ECB :
2269 GIC 12020 : return tstate;
2270 ECB : }
2271 :
2272 : /*
2273 : * write a single tuple
2274 : */
2275 : void
2276 GIC 63961 : do_tup_output(TupOutputState *tstate, Datum *values, bool *isnull)
2277 ECB : {
2278 GIC 63961 : TupleTableSlot *slot = tstate->slot;
2279 CBC 63961 : int natts = slot->tts_tupleDescriptor->natts;
2280 ECB :
2281 : /* make sure the slot is clear */
2282 GIC 63961 : ExecClearTuple(slot);
2283 ECB :
2284 : /* insert data */
2285 GIC 63961 : memcpy(slot->tts_values, values, natts * sizeof(Datum));
2286 CBC 63961 : memcpy(slot->tts_isnull, isnull, natts * sizeof(bool));
2287 ECB :
2288 : /* mark slot as containing a virtual tuple */
2289 GIC 63961 : ExecStoreVirtualTuple(slot);
2290 ECB :
2291 : /* send the tuple to the receiver */
2292 GIC 63961 : (void) tstate->dest->receiveSlot(slot, tstate->dest);
2293 ECB :
2294 : /* clean up */
2295 GIC 63961 : ExecClearTuple(slot);
2296 CBC 63961 : }
2297 ECB :
2298 : /*
2299 : * write a chunk of text, breaking at newline characters
2300 : *
2301 : * Should only be used with a single-TEXT-attribute tupdesc.
2302 : */
2303 : void
2304 GIC 9736 : do_text_output_multiline(TupOutputState *tstate, const char *txt)
2305 ECB : {
2306 : Datum values[1];
2307 GIC 9736 : bool isnull[1] = {false};
2308 ECB :
2309 GIC 70752 : while (*txt)
2310 ECB : {
2311 : const char *eol;
2312 : int len;
2313 :
2314 GIC 61016 : eol = strchr(txt, '\n');
2315 CBC 61016 : if (eol)
2316 ECB : {
2317 GIC 61016 : len = eol - txt;
2318 CBC 61016 : eol++;
2319 ECB : }
2320 : else
2321 : {
2322 UIC 0 : len = strlen(txt);
2323 UBC 0 : eol = txt + len;
2324 EUB : }
2325 :
2326 GIC 61016 : values[0] = PointerGetDatum(cstring_to_text_with_len(txt, len));
2327 CBC 61016 : do_tup_output(tstate, values, isnull);
2328 61016 : pfree(DatumGetPointer(values[0]));
2329 61016 : txt = eol;
2330 ECB : }
2331 GIC 9736 : }
2332 ECB :
2333 : void
2334 GIC 12020 : end_tup_output(TupOutputState *tstate)
2335 ECB : {
2336 GIC 12020 : tstate->dest->rShutdown(tstate->dest);
2337 ECB : /* note that destroying the dest is not ours to do */
2338 GIC 12020 : ExecDropSingleTupleTableSlot(tstate->slot);
2339 CBC 12020 : pfree(tstate);
2340 12020 : }
|
