1/*-------------------------------------------------------------------------
2 *
3 * expandedrecord.c
4 * Functions for manipulating composite expanded objects.
5 *
6 * This module supports "expanded objects" (cf. expandeddatum.h) that can
7 * store values of named composite types, domains over named composite types,
8 * and record types (registered or anonymous).
9 *
10 * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
11 * Portions Copyright (c) 1994, Regents of the University of California
12 *
13 *
14 * IDENTIFICATION
15 * src/backend/utils/adt/expandedrecord.c
16 *
17 *-------------------------------------------------------------------------
18 */
19#include "postgres.h"
20
21#include "access/htup_details.h"
22#include "access/tuptoaster.h"
23#include "catalog/heap.h"
24#include "catalog/pg_type.h"
25#include "utils/builtins.h"
26#include "utils/datum.h"
27#include "utils/expandedrecord.h"
28#include "utils/memutils.h"
29#include "utils/typcache.h"
30
31
32/* "Methods" required for an expanded object */
33static Size ER_get_flat_size(ExpandedObjectHeader *eohptr);
34static void ER_flatten_into(ExpandedObjectHeader *eohptr,
35 void *result, Size allocated_size);
36
37static const ExpandedObjectMethods ER_methods =
38{
39 ER_get_flat_size,
40 ER_flatten_into
41};
42
43/* Other local functions */
44static void ER_mc_callback(void *arg);
45static MemoryContext get_short_term_cxt(ExpandedRecordHeader *erh);
46static void build_dummy_expanded_header(ExpandedRecordHeader *main_erh);
47static pg_noinline void check_domain_for_new_field(ExpandedRecordHeader *erh,
48 int fnumber,
49 Datum newValue, bool isnull);
50static pg_noinline void check_domain_for_new_tuple(ExpandedRecordHeader *erh,
51 HeapTuple tuple);
52
53
54/*
55 * Build an expanded record of the specified composite type
56 *
57 * type_id can be RECORDOID, but only if a positive typmod is given.
58 *
59 * The expanded record is initially "empty", having a state logically
60 * equivalent to a NULL composite value (not ROW(NULL, NULL, ...)).
61 * Note that this might not be a valid state for a domain type;
62 * if the caller needs to check that, call
63 * expanded_record_set_tuple(erh, NULL, false, false).
64 *
65 * The expanded object will be a child of parentcontext.
66 */
67ExpandedRecordHeader *
68make_expanded_record_from_typeid(Oid type_id, int32 typmod,
69 MemoryContext parentcontext)
70{
71 ExpandedRecordHeader *erh;
72 int flags = 0;
73 TupleDesc tupdesc;
74 uint64 tupdesc_id;
75 MemoryContext objcxt;
76 char *chunk;
77
78 if (type_id != RECORDOID)
79 {
80 /*
81 * Consult the typcache to see if it's a domain over composite, and in
82 * any case to get the tupdesc and tupdesc identifier.
83 */
84 TypeCacheEntry *typentry;
85
86 typentry = lookup_type_cache(type_id,
87 TYPECACHE_TUPDESC |
88 TYPECACHE_DOMAIN_BASE_INFO);
89 if (typentry->typtype == TYPTYPE_DOMAIN)
90 {
91 flags |= ER_FLAG_IS_DOMAIN;
92 typentry = lookup_type_cache(typentry->domainBaseType,
93 TYPECACHE_TUPDESC);
94 }
95 if (typentry->tupDesc == NULL)
96 ereport(ERROR,
97 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
98 errmsg("type %s is not composite",
99 format_type_be(type_id))));
100 tupdesc = typentry->tupDesc;
101 tupdesc_id = typentry->tupDesc_identifier;
102 }
103 else
104 {
105 /*
106 * For RECORD types, get the tupdesc and identifier from typcache.
107 */
108 tupdesc = lookup_rowtype_tupdesc(type_id, typmod);
109 tupdesc_id = assign_record_type_identifier(type_id, typmod);
110 }
111
112 /*
113 * Allocate private context for expanded object. We use a regular-size
114 * context, not a small one, to improve the odds that we can fit a tupdesc
115 * into it without needing an extra malloc block. (This code path doesn't
116 * ever need to copy a tupdesc into the expanded record, but let's be
117 * consistent with the other ways of making an expanded record.)
118 */
119 objcxt = AllocSetContextCreate(parentcontext,
120 "expanded record",
121 ALLOCSET_DEFAULT_SIZES);
122
123 /*
124 * Since we already know the number of fields in the tupdesc, we can
125 * allocate the dvalues/dnulls arrays along with the record header. This
126 * is useless if we never need those arrays, but it costs almost nothing,
127 * and it will save a palloc cycle if we do need them.
128 */
129 erh = (ExpandedRecordHeader *)
130 MemoryContextAlloc(objcxt, MAXALIGN(sizeof(ExpandedRecordHeader))
131 + tupdesc->natts * (sizeof(Datum) + sizeof(bool)));
132
133 /* Ensure all header fields are initialized to 0/null */
134 memset(erh, 0, sizeof(ExpandedRecordHeader));
135
136 EOH_init_header(&erh->hdr, &ER_methods, objcxt);
137 erh->er_magic = ER_MAGIC;
138
139 /* Set up dvalues/dnulls, with no valid contents as yet */
140 chunk = (char *) erh + MAXALIGN(sizeof(ExpandedRecordHeader));
141 erh->dvalues = (Datum *) chunk;
142 erh->dnulls = (bool *) (chunk + tupdesc->natts * sizeof(Datum));
143 erh->nfields = tupdesc->natts;
144
145 /* Fill in composite-type identification info */
146 erh->er_decltypeid = type_id;
147 erh->er_typeid = tupdesc->tdtypeid;
148 erh->er_typmod = tupdesc->tdtypmod;
149 erh->er_tupdesc_id = tupdesc_id;
150
151 erh->flags = flags;
152
153 /*
154 * If what we got from the typcache is a refcounted tupdesc, we need to
155 * acquire our own refcount on it. We manage the refcount with a memory
156 * context callback rather than assuming that the CurrentResourceOwner is
157 * longer-lived than this expanded object.
158 */
159 if (tupdesc->tdrefcount >= 0)
160 {
161 /* Register callback to release the refcount */
162 erh->er_mcb.func = ER_mc_callback;
163 erh->er_mcb.arg = (void *) erh;
164 MemoryContextRegisterResetCallback(erh->hdr.eoh_context,
165 &erh->er_mcb);
166
167 /* And save the pointer */
168 erh->er_tupdesc = tupdesc;
169 tupdesc->tdrefcount++;
170
171 /* If we called lookup_rowtype_tupdesc, release the pin it took */
172 if (type_id == RECORDOID)
173 DecrTupleDescRefCount(tupdesc);
174 }
175 else
176 {
177 /*
178 * If it's not refcounted, just assume it will outlive the expanded
179 * object. (This can happen for shared record types, for instance.)
180 */
181 erh->er_tupdesc = tupdesc;
182 }
183
184 /*
185 * We don't set ER_FLAG_DVALUES_VALID or ER_FLAG_FVALUE_VALID, so the
186 * record remains logically empty.
187 */
188
189 return erh;
190}
191
192/*
193 * Build an expanded record of the rowtype defined by the tupdesc
194 *
195 * The tupdesc is copied if necessary (i.e., if we can't just bump its
196 * reference count instead).
197 *
198 * The expanded record is initially "empty", having a state logically
199 * equivalent to a NULL composite value (not ROW(NULL, NULL, ...)).
200 *
201 * The expanded object will be a child of parentcontext.
202 */
203ExpandedRecordHeader *
204make_expanded_record_from_tupdesc(TupleDesc tupdesc,
205 MemoryContext parentcontext)
206{
207 ExpandedRecordHeader *erh;
208 uint64 tupdesc_id;
209 MemoryContext objcxt;
210 MemoryContext oldcxt;
211 char *chunk;
212
213 if (tupdesc->tdtypeid != RECORDOID)
214 {
215 /*
216 * If it's a named composite type (not RECORD), we prefer to reference
217 * the typcache's copy of the tupdesc, which is guaranteed to be
218 * refcounted (the given tupdesc might not be). In any case, we need
219 * to consult the typcache to get the correct tupdesc identifier.
220 *
221 * Note that tdtypeid couldn't be a domain type, so we need not
222 * consider that case here.
223 */
224 TypeCacheEntry *typentry;
225
226 typentry = lookup_type_cache(tupdesc->tdtypeid, TYPECACHE_TUPDESC);
227 if (typentry->tupDesc == NULL)
228 ereport(ERROR,
229 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
230 errmsg("type %s is not composite",
231 format_type_be(tupdesc->tdtypeid))));
232 tupdesc = typentry->tupDesc;
233 tupdesc_id = typentry->tupDesc_identifier;
234 }
235 else
236 {
237 /*
238 * For RECORD types, get the appropriate unique identifier (possibly
239 * freshly assigned).
240 */
241 tupdesc_id = assign_record_type_identifier(tupdesc->tdtypeid,
242 tupdesc->tdtypmod);
243 }
244
245 /*
246 * Allocate private context for expanded object. We use a regular-size
247 * context, not a small one, to improve the odds that we can fit a tupdesc
248 * into it without needing an extra malloc block.
249 */
250 objcxt = AllocSetContextCreate(parentcontext,
251 "expanded record",
252 ALLOCSET_DEFAULT_SIZES);
253
254 /*
255 * Since we already know the number of fields in the tupdesc, we can
256 * allocate the dvalues/dnulls arrays along with the record header. This
257 * is useless if we never need those arrays, but it costs almost nothing,
258 * and it will save a palloc cycle if we do need them.
259 */
260 erh = (ExpandedRecordHeader *)
261 MemoryContextAlloc(objcxt, MAXALIGN(sizeof(ExpandedRecordHeader))
262 + tupdesc->natts * (sizeof(Datum) + sizeof(bool)));
263
264 /* Ensure all header fields are initialized to 0/null */
265 memset(erh, 0, sizeof(ExpandedRecordHeader));
266
267 EOH_init_header(&erh->hdr, &ER_methods, objcxt);
268 erh->er_magic = ER_MAGIC;
269
270 /* Set up dvalues/dnulls, with no valid contents as yet */
271 chunk = (char *) erh + MAXALIGN(sizeof(ExpandedRecordHeader));
272 erh->dvalues = (Datum *) chunk;
273 erh->dnulls = (bool *) (chunk + tupdesc->natts * sizeof(Datum));
274 erh->nfields = tupdesc->natts;
275
276 /* Fill in composite-type identification info */
277 erh->er_decltypeid = erh->er_typeid = tupdesc->tdtypeid;
278 erh->er_typmod = tupdesc->tdtypmod;
279 erh->er_tupdesc_id = tupdesc_id;
280
281 /*
282 * Copy tupdesc if needed, but we prefer to bump its refcount if possible.
283 * We manage the refcount with a memory context callback rather than
284 * assuming that the CurrentResourceOwner is longer-lived than this
285 * expanded object.
286 */
287 if (tupdesc->tdrefcount >= 0)
288 {
289 /* Register callback to release the refcount */
290 erh->er_mcb.func = ER_mc_callback;
291 erh->er_mcb.arg = (void *) erh;
292 MemoryContextRegisterResetCallback(erh->hdr.eoh_context,
293 &erh->er_mcb);
294
295 /* And save the pointer */
296 erh->er_tupdesc = tupdesc;
297 tupdesc->tdrefcount++;
298 }
299 else
300 {
301 /* Just copy it */
302 oldcxt = MemoryContextSwitchTo(objcxt);
303 erh->er_tupdesc = CreateTupleDescCopy(tupdesc);
304 erh->flags |= ER_FLAG_TUPDESC_ALLOCED;
305 MemoryContextSwitchTo(oldcxt);
306 }
307
308 /*
309 * We don't set ER_FLAG_DVALUES_VALID or ER_FLAG_FVALUE_VALID, so the
310 * record remains logically empty.
311 */
312
313 return erh;
314}
315
316/*
317 * Build an expanded record of the same rowtype as the given expanded record
318 *
319 * This is faster than either of the above routines because we can bypass
320 * typcache lookup(s).
321 *
322 * The expanded record is initially "empty" --- we do not copy whatever
323 * tuple might be in the source expanded record.
324 *
325 * The expanded object will be a child of parentcontext.
326 */
327ExpandedRecordHeader *
328make_expanded_record_from_exprecord(ExpandedRecordHeader *olderh,
329 MemoryContext parentcontext)
330{
331 ExpandedRecordHeader *erh;
332 TupleDesc tupdesc = expanded_record_get_tupdesc(olderh);
333 MemoryContext objcxt;
334 MemoryContext oldcxt;
335 char *chunk;
336
337 /*
338 * Allocate private context for expanded object. We use a regular-size
339 * context, not a small one, to improve the odds that we can fit a tupdesc
340 * into it without needing an extra malloc block.
341 */
342 objcxt = AllocSetContextCreate(parentcontext,
343 "expanded record",
344 ALLOCSET_DEFAULT_SIZES);
345
346 /*
347 * Since we already know the number of fields in the tupdesc, we can
348 * allocate the dvalues/dnulls arrays along with the record header. This
349 * is useless if we never need those arrays, but it costs almost nothing,
350 * and it will save a palloc cycle if we do need them.
351 */
352 erh = (ExpandedRecordHeader *)
353 MemoryContextAlloc(objcxt, MAXALIGN(sizeof(ExpandedRecordHeader))
354 + tupdesc->natts * (sizeof(Datum) + sizeof(bool)));
355
356 /* Ensure all header fields are initialized to 0/null */
357 memset(erh, 0, sizeof(ExpandedRecordHeader));
358
359 EOH_init_header(&erh->hdr, &ER_methods, objcxt);
360 erh->er_magic = ER_MAGIC;
361
362 /* Set up dvalues/dnulls, with no valid contents as yet */
363 chunk = (char *) erh + MAXALIGN(sizeof(ExpandedRecordHeader));
364 erh->dvalues = (Datum *) chunk;
365 erh->dnulls = (bool *) (chunk + tupdesc->natts * sizeof(Datum));
366 erh->nfields = tupdesc->natts;
367
368 /* Fill in composite-type identification info */
369 erh->er_decltypeid = olderh->er_decltypeid;
370 erh->er_typeid = olderh->er_typeid;
371 erh->er_typmod = olderh->er_typmod;
372 erh->er_tupdesc_id = olderh->er_tupdesc_id;
373
374 /* The only flag bit that transfers over is IS_DOMAIN */
375 erh->flags = olderh->flags & ER_FLAG_IS_DOMAIN;
376
377 /*
378 * Copy tupdesc if needed, but we prefer to bump its refcount if possible.
379 * We manage the refcount with a memory context callback rather than
380 * assuming that the CurrentResourceOwner is longer-lived than this
381 * expanded object.
382 */
383 if (tupdesc->tdrefcount >= 0)
384 {
385 /* Register callback to release the refcount */
386 erh->er_mcb.func = ER_mc_callback;
387 erh->er_mcb.arg = (void *) erh;
388 MemoryContextRegisterResetCallback(erh->hdr.eoh_context,
389 &erh->er_mcb);
390
391 /* And save the pointer */
392 erh->er_tupdesc = tupdesc;
393 tupdesc->tdrefcount++;
394 }
395 else if (olderh->flags & ER_FLAG_TUPDESC_ALLOCED)
396 {
397 /* We need to make our own copy of the tupdesc */
398 oldcxt = MemoryContextSwitchTo(objcxt);
399 erh->er_tupdesc = CreateTupleDescCopy(tupdesc);
400 erh->flags |= ER_FLAG_TUPDESC_ALLOCED;
401 MemoryContextSwitchTo(oldcxt);
402 }
403 else
404 {
405 /*
406 * Assume the tupdesc will outlive this expanded object, just like
407 * we're assuming it will outlive the source object.
408 */
409 erh->er_tupdesc = tupdesc;
410 }
411
412 /*
413 * We don't set ER_FLAG_DVALUES_VALID or ER_FLAG_FVALUE_VALID, so the
414 * record remains logically empty.
415 */
416
417 return erh;
418}
419
420/*
421 * Insert given tuple as the value of the expanded record
422 *
423 * It is caller's responsibility that the tuple matches the record's
424 * previously-assigned rowtype. (However domain constraints, if any,
425 * will be checked here.)
426 *
427 * The tuple is physically copied into the expanded record's local storage
428 * if "copy" is true, otherwise it's caller's responsibility that the tuple
429 * will live as long as the expanded record does.
430 *
431 * Out-of-line field values in the tuple are automatically inlined if
432 * "expand_external" is true, otherwise not. (The combination copy = false,
433 * expand_external = true is not sensible and not supported.)
434 *
435 * Alternatively, tuple can be NULL, in which case we just set the expanded
436 * record to be empty.
437 */
438void
439expanded_record_set_tuple(ExpandedRecordHeader *erh,
440 HeapTuple tuple,
441 bool copy,
442 bool expand_external)
443{
444 int oldflags;
445 HeapTuple oldtuple;
446 char *oldfstartptr;
447 char *oldfendptr;
448 int newflags;
449 HeapTuple newtuple;
450 MemoryContext oldcxt;
451
452 /* Shouldn't ever be trying to assign new data to a dummy header */
453 Assert(!(erh->flags & ER_FLAG_IS_DUMMY));
454
455 /*
456 * Before performing the assignment, see if result will satisfy domain.
457 */
458 if (erh->flags & ER_FLAG_IS_DOMAIN)
459 check_domain_for_new_tuple(erh, tuple);
460
461 /*
462 * If we need to get rid of out-of-line field values, do so, using the
463 * short-term context to avoid leaking whatever cruft the toast fetch
464 * might generate.
465 */
466 if (expand_external && tuple)
467 {
468 /* Assert caller didn't ask for unsupported case */
469 Assert(copy);
470 if (HeapTupleHasExternal(tuple))
471 {
472 oldcxt = MemoryContextSwitchTo(get_short_term_cxt(erh));
473 tuple = toast_flatten_tuple(tuple, erh->er_tupdesc);
474 MemoryContextSwitchTo(oldcxt);
475 }
476 else
477 expand_external = false; /* need not clean up below */
478 }
479
480 /*
481 * Initialize new flags, keeping only non-data status bits.
482 */
483 oldflags = erh->flags;
484 newflags = oldflags & ER_FLAGS_NON_DATA;
485
486 /*
487 * Copy tuple into local storage if needed. We must be sure this succeeds
488 * before we start to modify the expanded record's state.
489 */
490 if (copy && tuple)
491 {
492 oldcxt = MemoryContextSwitchTo(erh->hdr.eoh_context);
493 newtuple = heap_copytuple(tuple);
494 newflags |= ER_FLAG_FVALUE_ALLOCED;
495 MemoryContextSwitchTo(oldcxt);
496
497 /* We can now flush anything that detoasting might have leaked. */
498 if (expand_external)
499 MemoryContextReset(erh->er_short_term_cxt);
500 }
501 else
502 newtuple = tuple;
503
504 /* Make copies of fields we're about to overwrite */
505 oldtuple = erh->fvalue;
506 oldfstartptr = erh->fstartptr;
507 oldfendptr = erh->fendptr;
508
509 /*
510 * It's now safe to update the expanded record's state.
511 */
512 if (newtuple)
513 {
514 /* Save flat representation */
515 erh->fvalue = newtuple;
516 erh->fstartptr = (char *) newtuple->t_data;
517 erh->fendptr = ((char *) newtuple->t_data) + newtuple->t_len;
518 newflags |= ER_FLAG_FVALUE_VALID;
519
520 /* Remember if we have any out-of-line field values */
521 if (HeapTupleHasExternal(newtuple))
522 newflags |= ER_FLAG_HAVE_EXTERNAL;
523 }
524 else
525 {
526 erh->fvalue = NULL;
527 erh->fstartptr = erh->fendptr = NULL;
528 }
529
530 erh->flags = newflags;
531
532 /* Reset flat-size info; we don't bother to make it valid now */
533 erh->flat_size = 0;
534
535 /*
536 * Now, release any storage belonging to old field values. It's safe to
537 * do this because ER_FLAG_DVALUES_VALID is no longer set in erh->flags;
538 * even if we fail partway through, the record is valid, and at worst
539 * we've failed to reclaim some space.
540 */
541 if (oldflags & ER_FLAG_DVALUES_ALLOCED)
542 {
543 TupleDesc tupdesc = erh->er_tupdesc;
544 int i;
545
546 for (i = 0; i < erh->nfields; i++)
547 {
548 if (!erh->dnulls[i] &&
549 !(TupleDescAttr(tupdesc, i)->attbyval))
550 {
551 char *oldValue = (char *) DatumGetPointer(erh->dvalues[i]);
552
553 if (oldValue < oldfstartptr || oldValue >= oldfendptr)
554 pfree(oldValue);
555 }
556 }
557 }
558
559 /* Likewise free the old tuple, if it was locally allocated */
560 if (oldflags & ER_FLAG_FVALUE_ALLOCED)
561 heap_freetuple(oldtuple);
562
563 /* We won't make a new deconstructed representation until/unless needed */
564}
565
566/*
567 * make_expanded_record_from_datum: build expanded record from composite Datum
568 *
569 * This combines the functions of make_expanded_record_from_typeid and
570 * expanded_record_set_tuple. However, we do not force a lookup of the
571 * tupdesc immediately, reasoning that it might never be needed.
572 *
573 * The expanded object will be a child of parentcontext.
574 *
575 * Note: a composite datum cannot self-identify as being of a domain type,
576 * so we need not consider domain cases here.
577 */
578Datum
579make_expanded_record_from_datum(Datum recorddatum, MemoryContext parentcontext)
580{
581 ExpandedRecordHeader *erh;
582 HeapTupleHeader tuphdr;
583 HeapTupleData tmptup;
584 HeapTuple newtuple;
585 MemoryContext objcxt;
586 MemoryContext oldcxt;
587
588 /*
589 * Allocate private context for expanded object. We use a regular-size
590 * context, not a small one, to improve the odds that we can fit a tupdesc
591 * into it without needing an extra malloc block.
592 */
593 objcxt = AllocSetContextCreate(parentcontext,
594 "expanded record",
595 ALLOCSET_DEFAULT_SIZES);
596
597 /* Set up expanded record header, initializing fields to 0/null */
598 erh = (ExpandedRecordHeader *)
599 MemoryContextAllocZero(objcxt, sizeof(ExpandedRecordHeader));
600
601 EOH_init_header(&erh->hdr, &ER_methods, objcxt);
602 erh->er_magic = ER_MAGIC;
603
604 /*
605 * Detoast and copy source record into private context, as a HeapTuple.
606 * (If we actually have to detoast the source, we'll leak some memory in
607 * the caller's context, but it doesn't seem worth worrying about.)
608 */
609 tuphdr = DatumGetHeapTupleHeader(recorddatum);
610
611 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuphdr);
612 ItemPointerSetInvalid(&(tmptup.t_self));
613 tmptup.t_tableOid = InvalidOid;
614 tmptup.t_data = tuphdr;
615
616 oldcxt = MemoryContextSwitchTo(objcxt);
617 newtuple = heap_copytuple(&tmptup);
618 erh->flags |= ER_FLAG_FVALUE_ALLOCED;
619 MemoryContextSwitchTo(oldcxt);
620
621 /* Fill in composite-type identification info */
622 erh->er_decltypeid = erh->er_typeid = HeapTupleHeaderGetTypeId(tuphdr);
623 erh->er_typmod = HeapTupleHeaderGetTypMod(tuphdr);
624
625 /* remember we have a flat representation */
626 erh->fvalue = newtuple;
627 erh->fstartptr = (char *) newtuple->t_data;
628 erh->fendptr = ((char *) newtuple->t_data) + newtuple->t_len;
629 erh->flags |= ER_FLAG_FVALUE_VALID;
630
631 /* Shouldn't need to set ER_FLAG_HAVE_EXTERNAL */
632 Assert(!HeapTupleHeaderHasExternal(tuphdr));
633
634 /*
635 * We won't look up the tupdesc till we have to, nor make a deconstructed
636 * representation. We don't have enough info to fill flat_size and
637 * friends, either.
638 */
639
640 /* return a R/W pointer to the expanded record */
641 return EOHPGetRWDatum(&erh->hdr);
642}
643
644/*
645 * get_flat_size method for expanded records
646 *
647 * Note: call this in a reasonably short-lived memory context, in case of
648 * memory leaks from activities such as detoasting.
649 */
650static Size
651ER_get_flat_size(ExpandedObjectHeader *eohptr)
652{
653 ExpandedRecordHeader *erh = (ExpandedRecordHeader *) eohptr;
654 TupleDesc tupdesc;
655 Size len;
656 Size data_len;
657 int hoff;
658 bool hasnull;
659 int i;
660
661 Assert(erh->er_magic == ER_MAGIC);
662
663 /*
664 * The flat representation has to be a valid composite datum. Make sure
665 * that we have a registered, not anonymous, RECORD type.
666 */
667 if (erh->er_typeid == RECORDOID &&
668 erh->er_typmod < 0)
669 {
670 tupdesc = expanded_record_get_tupdesc(erh);
671 assign_record_type_typmod(tupdesc);
672 erh->er_typmod = tupdesc->tdtypmod;
673 }
674
675 /*
676 * If we have a valid flattened value without out-of-line fields, we can
677 * just use it as-is.
678 */
679 if (erh->flags & ER_FLAG_FVALUE_VALID &&
680 !(erh->flags & ER_FLAG_HAVE_EXTERNAL))
681 return erh->fvalue->t_len;
682
683 /* If we have a cached size value, believe that */
684 if (erh->flat_size)
685 return erh->flat_size;
686
687 /* If we haven't yet deconstructed the tuple, do that */
688 if (!(erh->flags & ER_FLAG_DVALUES_VALID))
689 deconstruct_expanded_record(erh);
690
691 /* Tuple descriptor must be valid by now */
692 tupdesc = erh->er_tupdesc;
693
694 /*
695 * Composite datums mustn't contain any out-of-line values.
696 */
697 if (erh->flags & ER_FLAG_HAVE_EXTERNAL)
698 {
699 for (i = 0; i < erh->nfields; i++)
700 {
701 Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
702
703 if (!erh->dnulls[i] &&
704 !attr->attbyval && attr->attlen == -1 &&
705 VARATT_IS_EXTERNAL(DatumGetPointer(erh->dvalues[i])))
706 {
707 /*
708 * expanded_record_set_field_internal can do the actual work
709 * of detoasting. It needn't recheck domain constraints.
710 */
711 expanded_record_set_field_internal(erh, i + 1,
712 erh->dvalues[i], false,
713 true,
714 false);
715 }
716 }
717
718 /*
719 * We have now removed all external field values, so we can clear the
720 * flag about them. This won't cause ER_flatten_into() to mistakenly
721 * take the fast path, since expanded_record_set_field() will have
722 * cleared ER_FLAG_FVALUE_VALID.
723 */
724 erh->flags &= ~ER_FLAG_HAVE_EXTERNAL;
725 }
726
727 /* Test if we currently have any null values */
728 hasnull = false;
729 for (i = 0; i < erh->nfields; i++)
730 {
731 if (erh->dnulls[i])
732 {
733 hasnull = true;
734 break;
735 }
736 }
737
738 /* Determine total space needed */
739 len = offsetof(HeapTupleHeaderData, t_bits);
740
741 if (hasnull)
742 len += BITMAPLEN(tupdesc->natts);
743
744 hoff = len = MAXALIGN(len); /* align user data safely */
745
746 data_len = heap_compute_data_size(tupdesc, erh->dvalues, erh->dnulls);
747
748 len += data_len;
749
750 /* Cache for next time */
751 erh->flat_size = len;
752 erh->data_len = data_len;
753 erh->hoff = hoff;
754 erh->hasnull = hasnull;
755
756 return len;
757}
758
759/*
760 * flatten_into method for expanded records
761 */
762static void
763ER_flatten_into(ExpandedObjectHeader *eohptr,
764 void *result, Size allocated_size)
765{
766 ExpandedRecordHeader *erh = (ExpandedRecordHeader *) eohptr;
767 HeapTupleHeader tuphdr = (HeapTupleHeader) result;
768 TupleDesc tupdesc;
769
770 Assert(erh->er_magic == ER_MAGIC);
771
772 /* Easy if we have a valid flattened value without out-of-line fields */
773 if (erh->flags & ER_FLAG_FVALUE_VALID &&
774 !(erh->flags & ER_FLAG_HAVE_EXTERNAL))
775 {
776 Assert(allocated_size == erh->fvalue->t_len);
777 memcpy(tuphdr, erh->fvalue->t_data, allocated_size);
778 /* The original flattened value might not have datum header fields */
779 HeapTupleHeaderSetDatumLength(tuphdr, allocated_size);
780 HeapTupleHeaderSetTypeId(tuphdr, erh->er_typeid);
781 HeapTupleHeaderSetTypMod(tuphdr, erh->er_typmod);
782 return;
783 }
784
785 /* Else allocation should match previous get_flat_size result */
786 Assert(allocated_size == erh->flat_size);
787
788 /* We'll need the tuple descriptor */
789 tupdesc = expanded_record_get_tupdesc(erh);
790
791 /* We must ensure that any pad space is zero-filled */
792 memset(tuphdr, 0, allocated_size);
793
794 /* Set up header fields of composite Datum */
795 HeapTupleHeaderSetDatumLength(tuphdr, allocated_size);
796 HeapTupleHeaderSetTypeId(tuphdr, erh->er_typeid);
797 HeapTupleHeaderSetTypMod(tuphdr, erh->er_typmod);
798 /* We also make sure that t_ctid is invalid unless explicitly set */
799 ItemPointerSetInvalid(&(tuphdr->t_ctid));
800
801 HeapTupleHeaderSetNatts(tuphdr, tupdesc->natts);
802 tuphdr->t_hoff = erh->hoff;
803
804 /* And fill the data area from dvalues/dnulls */
805 heap_fill_tuple(tupdesc,
806 erh->dvalues,
807 erh->dnulls,
808 (char *) tuphdr + erh->hoff,
809 erh->data_len,
810 &tuphdr->t_infomask,
811 (erh->hasnull ? tuphdr->t_bits : NULL));
812}
813
814/*
815 * Look up the tupdesc for the expanded record's actual type
816 *
817 * Note: code internal to this module is allowed to just fetch
818 * erh->er_tupdesc if ER_FLAG_DVALUES_VALID is set; otherwise it should call
819 * expanded_record_get_tupdesc. This function is the out-of-line portion
820 * of expanded_record_get_tupdesc.
821 */
822TupleDesc
823expanded_record_fetch_tupdesc(ExpandedRecordHeader *erh)
824{
825 TupleDesc tupdesc;
826
827 /* Easy if we already have it (but caller should have checked already) */
828 if (erh->er_tupdesc)
829 return erh->er_tupdesc;
830
831 /* Lookup the composite type's tupdesc using the typcache */
832 tupdesc = lookup_rowtype_tupdesc(erh->er_typeid, erh->er_typmod);
833
834 /*
835 * If it's a refcounted tupdesc rather than a statically allocated one, we
836 * want to manage the refcount with a memory context callback rather than
837 * assuming that the CurrentResourceOwner is longer-lived than this
838 * expanded object.
839 */
840 if (tupdesc->tdrefcount >= 0)
841 {
842 /* Register callback if we didn't already */
843 if (erh->er_mcb.arg == NULL)
844 {
845 erh->er_mcb.func = ER_mc_callback;
846 erh->er_mcb.arg = (void *) erh;
847 MemoryContextRegisterResetCallback(erh->hdr.eoh_context,
848 &erh->er_mcb);
849 }
850
851 /* Remember our own pointer */
852 erh->er_tupdesc = tupdesc;
853 tupdesc->tdrefcount++;
854
855 /* Release the pin lookup_rowtype_tupdesc acquired */
856 DecrTupleDescRefCount(tupdesc);
857 }
858 else
859 {
860 /* Just remember the pointer */
861 erh->er_tupdesc = tupdesc;
862 }
863
864 /* In either case, fetch the process-global ID for this tupdesc */
865 erh->er_tupdesc_id = assign_record_type_identifier(tupdesc->tdtypeid,
866 tupdesc->tdtypmod);
867
868 return tupdesc;
869}
870
871/*
872 * Get a HeapTuple representing the current value of the expanded record
873 *
874 * If valid, the originally stored tuple is returned, so caller must not
875 * scribble on it. Otherwise, we return a HeapTuple created in the current
876 * memory context. In either case, no attempt has been made to inline
877 * out-of-line toasted values, so the tuple isn't usable as a composite
878 * datum.
879 *
880 * Returns NULL if expanded record is empty.
881 */
882HeapTuple
883expanded_record_get_tuple(ExpandedRecordHeader *erh)
884{
885 /* Easy case if we still have original tuple */
886 if (erh->flags & ER_FLAG_FVALUE_VALID)
887 return erh->fvalue;
888
889 /* Else just build a tuple from datums */
890 if (erh->flags & ER_FLAG_DVALUES_VALID)
891 return heap_form_tuple(erh->er_tupdesc, erh->dvalues, erh->dnulls);
892
893 /* Expanded record is empty */
894 return NULL;
895}
896
897/*
898 * Memory context reset callback for cleaning up external resources
899 */
900static void
901ER_mc_callback(void *arg)
902{
903 ExpandedRecordHeader *erh = (ExpandedRecordHeader *) arg;
904 TupleDesc tupdesc = erh->er_tupdesc;
905
906 /* Release our privately-managed tupdesc refcount, if any */
907 if (tupdesc)
908 {
909 erh->er_tupdesc = NULL; /* just for luck */
910 if (tupdesc->tdrefcount > 0)
911 {
912 if (--tupdesc->tdrefcount == 0)
913 FreeTupleDesc(tupdesc);
914 }
915 }
916}
917
918/*
919 * DatumGetExpandedRecord: get a writable expanded record from an input argument
920 *
921 * Caution: if the input is a read/write pointer, this returns the input
922 * argument; so callers must be sure that their changes are "safe", that is
923 * they cannot leave the record in a corrupt state.
924 */
925ExpandedRecordHeader *
926DatumGetExpandedRecord(Datum d)
927{
928 /* If it's a writable expanded record already, just return it */
929 if (VARATT_IS_EXTERNAL_EXPANDED_RW(DatumGetPointer(d)))
930 {
931 ExpandedRecordHeader *erh = (ExpandedRecordHeader *) DatumGetEOHP(d);
932
933 Assert(erh->er_magic == ER_MAGIC);
934 return erh;
935 }
936
937 /* Else expand the hard way */
938 d = make_expanded_record_from_datum(d, CurrentMemoryContext);
939 return (ExpandedRecordHeader *) DatumGetEOHP(d);
940}
941
942/*
943 * Create the Datum/isnull representation of an expanded record object
944 * if we didn't do so already. After calling this, it's OK to read the
945 * dvalues/dnulls arrays directly, rather than going through get_field.
946 *
947 * Note that if the object is currently empty ("null"), this will change
948 * it to represent a row of nulls.
949 */
950void
951deconstruct_expanded_record(ExpandedRecordHeader *erh)
952{
953 TupleDesc tupdesc;
954 Datum *dvalues;
955 bool *dnulls;
956 int nfields;
957
958 if (erh->flags & ER_FLAG_DVALUES_VALID)
959 return; /* already valid, nothing to do */
960
961 /* We'll need the tuple descriptor */
962 tupdesc = expanded_record_get_tupdesc(erh);
963
964 /*
965 * Allocate arrays in private context, if we don't have them already. We
966 * don't expect to see a change in nfields here, so while we cope if it
967 * happens, we don't bother avoiding a leak of the old arrays (which might
968 * not be separately palloc'd, anyway).
969 */
970 nfields = tupdesc->natts;
971 if (erh->dvalues == NULL || erh->nfields != nfields)
972 {
973 char *chunk;
974
975 /*
976 * To save a palloc cycle, we allocate both the Datum and isnull
977 * arrays in one palloc chunk.
978 */
979 chunk = MemoryContextAlloc(erh->hdr.eoh_context,
980 nfields * (sizeof(Datum) + sizeof(bool)));
981 dvalues = (Datum *) chunk;
982 dnulls = (bool *) (chunk + nfields * sizeof(Datum));
983 erh->dvalues = dvalues;
984 erh->dnulls = dnulls;
985 erh->nfields = nfields;
986 }
987 else
988 {
989 dvalues = erh->dvalues;
990 dnulls = erh->dnulls;
991 }
992
993 if (erh->flags & ER_FLAG_FVALUE_VALID)
994 {
995 /* Deconstruct tuple */
996 heap_deform_tuple(erh->fvalue, tupdesc, dvalues, dnulls);
997 }
998 else
999 {
1000 /* If record was empty, instantiate it as a row of nulls */
1001 memset(dvalues, 0, nfields * sizeof(Datum));
1002 memset(dnulls, true, nfields * sizeof(bool));
1003 }
1004
1005 /* Mark the dvalues as valid */
1006 erh->flags |= ER_FLAG_DVALUES_VALID;
1007}
1008
1009/*
1010 * Look up a record field by name
1011 *
1012 * If there is a field named "fieldname", fill in the contents of finfo
1013 * and return "true". Else return "false" without changing *finfo.
1014 */
1015bool
1016expanded_record_lookup_field(ExpandedRecordHeader *erh, const char *fieldname,
1017 ExpandedRecordFieldInfo *finfo)
1018{
1019 TupleDesc tupdesc;
1020 int fno;
1021 Form_pg_attribute attr;
1022 const FormData_pg_attribute *sysattr;
1023
1024 tupdesc = expanded_record_get_tupdesc(erh);
1025
1026 /* First, check user-defined attributes */
1027 for (fno = 0; fno < tupdesc->natts; fno++)
1028 {
1029 attr = TupleDescAttr(tupdesc, fno);
1030 if (namestrcmp(&attr->attname, fieldname) == 0 &&
1031 !attr->attisdropped)
1032 {
1033 finfo->fnumber = attr->attnum;
1034 finfo->ftypeid = attr->atttypid;
1035 finfo->ftypmod = attr->atttypmod;
1036 finfo->fcollation = attr->attcollation;
1037 return true;
1038 }
1039 }
1040
1041 /* How about system attributes? */
1042 sysattr = SystemAttributeByName(fieldname);
1043 if (sysattr != NULL)
1044 {
1045 finfo->fnumber = sysattr->attnum;
1046 finfo->ftypeid = sysattr->atttypid;
1047 finfo->ftypmod = sysattr->atttypmod;
1048 finfo->fcollation = sysattr->attcollation;
1049 return true;
1050 }
1051
1052 return false;
1053}
1054
1055/*
1056 * Fetch value of record field
1057 *
1058 * expanded_record_get_field is the frontend for this; it handles the
1059 * easy inline-able cases.
1060 */
1061Datum
1062expanded_record_fetch_field(ExpandedRecordHeader *erh, int fnumber,
1063 bool *isnull)
1064{
1065 if (fnumber > 0)
1066 {
1067 /* Empty record has null fields */
1068 if (ExpandedRecordIsEmpty(erh))
1069 {
1070 *isnull = true;
1071 return (Datum) 0;
1072 }
1073 /* Make sure we have deconstructed form */
1074 deconstruct_expanded_record(erh);
1075 /* Out-of-range field number reads as null */
1076 if (unlikely(fnumber > erh->nfields))
1077 {
1078 *isnull = true;
1079 return (Datum) 0;
1080 }
1081 *isnull = erh->dnulls[fnumber - 1];
1082 return erh->dvalues[fnumber - 1];
1083 }
1084 else
1085 {
1086 /* System columns read as null if we haven't got flat tuple */
1087 if (erh->fvalue == NULL)
1088 {
1089 *isnull = true;
1090 return (Datum) 0;
1091 }
1092 /* heap_getsysattr doesn't actually use tupdesc, so just pass null */
1093 return heap_getsysattr(erh->fvalue, fnumber, NULL, isnull);
1094 }
1095}
1096
1097/*
1098 * Set value of record field
1099 *
1100 * If the expanded record is of domain type, the assignment will be rejected
1101 * (without changing the record's state) if the domain's constraints would
1102 * be violated.
1103 *
1104 * If expand_external is true and newValue is an out-of-line value, we'll
1105 * forcibly detoast it so that the record does not depend on external storage.
1106 *
1107 * Internal callers can pass check_constraints = false to skip application
1108 * of domain constraints. External callers should never do that.
1109 */
1110void
1111expanded_record_set_field_internal(ExpandedRecordHeader *erh, int fnumber,
1112 Datum newValue, bool isnull,
1113 bool expand_external,
1114 bool check_constraints)
1115{
1116 TupleDesc tupdesc;
1117 Form_pg_attribute attr;
1118 Datum *dvalues;
1119 bool *dnulls;
1120 char *oldValue;
1121
1122 /*
1123 * Shouldn't ever be trying to assign new data to a dummy header, except
1124 * in the case of an internal call for field inlining.
1125 */
1126 Assert(!(erh->flags & ER_FLAG_IS_DUMMY) || !check_constraints);
1127
1128 /* Before performing the assignment, see if result will satisfy domain */
1129 if ((erh->flags & ER_FLAG_IS_DOMAIN) && check_constraints)
1130 check_domain_for_new_field(erh, fnumber, newValue, isnull);
1131
1132 /* If we haven't yet deconstructed the tuple, do that */
1133 if (!(erh->flags & ER_FLAG_DVALUES_VALID))
1134 deconstruct_expanded_record(erh);
1135
1136 /* Tuple descriptor must be valid by now */
1137 tupdesc = erh->er_tupdesc;
1138 Assert(erh->nfields == tupdesc->natts);
1139
1140 /* Caller error if fnumber is system column or nonexistent column */
1141 if (unlikely(fnumber <= 0 || fnumber > erh->nfields))
1142 elog(ERROR, "cannot assign to field %d of expanded record", fnumber);
1143
1144 /*
1145 * Copy new field value into record's context, and deal with detoasting,
1146 * if needed.
1147 */
1148 attr = TupleDescAttr(tupdesc, fnumber - 1);
1149 if (!isnull && !attr->attbyval)
1150 {
1151 MemoryContext oldcxt;
1152
1153 /* If requested, detoast any external value */
1154 if (expand_external)
1155 {
1156 if (attr->attlen == -1 &&
1157 VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
1158 {
1159 /* Detoasting should be done in short-lived context. */
1160 oldcxt = MemoryContextSwitchTo(get_short_term_cxt(erh));
1161 newValue = PointerGetDatum(heap_tuple_fetch_attr((struct varlena *) DatumGetPointer(newValue)));
1162 MemoryContextSwitchTo(oldcxt);
1163 }
1164 else
1165 expand_external = false; /* need not clean up below */
1166 }
1167
1168 /* Copy value into record's context */
1169 oldcxt = MemoryContextSwitchTo(erh->hdr.eoh_context);
1170 newValue = datumCopy(newValue, false, attr->attlen);
1171 MemoryContextSwitchTo(oldcxt);
1172
1173 /* We can now flush anything that detoasting might have leaked */
1174 if (expand_external)
1175 MemoryContextReset(erh->er_short_term_cxt);
1176
1177 /* Remember that we have field(s) that may need to be pfree'd */
1178 erh->flags |= ER_FLAG_DVALUES_ALLOCED;
1179
1180 /*
1181 * While we're here, note whether it's an external toasted value,
1182 * because that could mean we need to inline it later. (Think not to
1183 * merge this into the previous expand_external logic: datumCopy could
1184 * by itself have made the value non-external.)
1185 */
1186 if (attr->attlen == -1 &&
1187 VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
1188 erh->flags |= ER_FLAG_HAVE_EXTERNAL;
1189 }
1190
1191 /*
1192 * We're ready to make irreversible changes.
1193 */
1194 dvalues = erh->dvalues;
1195 dnulls = erh->dnulls;
1196
1197 /* Flattened value will no longer represent record accurately */
1198 erh->flags &= ~ER_FLAG_FVALUE_VALID;
1199 /* And we don't know the flattened size either */
1200 erh->flat_size = 0;
1201
1202 /* Grab old field value for pfree'ing, if needed. */
1203 if (!attr->attbyval && !dnulls[fnumber - 1])
1204 oldValue = (char *) DatumGetPointer(dvalues[fnumber - 1]);
1205 else
1206 oldValue = NULL;
1207
1208 /* And finally we can insert the new field. */
1209 dvalues[fnumber - 1] = newValue;
1210 dnulls[fnumber - 1] = isnull;
1211
1212 /*
1213 * Free old field if needed; this keeps repeated field replacements from
1214 * bloating the record's storage. If the pfree somehow fails, it won't
1215 * corrupt the record.
1216 *
1217 * If we're updating a dummy header, we can't risk pfree'ing the old
1218 * value, because most likely the expanded record's main header still has
1219 * a pointer to it. This won't result in any sustained memory leak, since
1220 * whatever we just allocated here is in the short-lived domain check
1221 * context.
1222 */
1223 if (oldValue && !(erh->flags & ER_FLAG_IS_DUMMY))
1224 {
1225 /* Don't try to pfree a part of the original flat record */
1226 if (oldValue < erh->fstartptr || oldValue >= erh->fendptr)
1227 pfree(oldValue);
1228 }
1229}
1230
1231/*
1232 * Set all record field(s)
1233 *
1234 * Caller must ensure that the provided datums are of the right types
1235 * to match the record's previously assigned rowtype.
1236 *
1237 * If expand_external is true, we'll forcibly detoast out-of-line field values
1238 * so that the record does not depend on external storage.
1239 *
1240 * Unlike repeated application of expanded_record_set_field(), this does not
1241 * guarantee to leave the expanded record in a non-corrupt state in event
1242 * of an error. Typically it would only be used for initializing a new
1243 * expanded record. Also, because we expect this to be applied at most once
1244 * in the lifespan of an expanded record, we do not worry about any cruft
1245 * that detoasting might leak.
1246 */
1247void
1248expanded_record_set_fields(ExpandedRecordHeader *erh,
1249 const Datum *newValues, const bool *isnulls,
1250 bool expand_external)
1251{
1252 TupleDesc tupdesc;
1253 Datum *dvalues;
1254 bool *dnulls;
1255 int fnumber;
1256 MemoryContext oldcxt;
1257
1258 /* Shouldn't ever be trying to assign new data to a dummy header */
1259 Assert(!(erh->flags & ER_FLAG_IS_DUMMY));
1260
1261 /* If we haven't yet deconstructed the tuple, do that */
1262 if (!(erh->flags & ER_FLAG_DVALUES_VALID))
1263 deconstruct_expanded_record(erh);
1264
1265 /* Tuple descriptor must be valid by now */
1266 tupdesc = erh->er_tupdesc;
1267 Assert(erh->nfields == tupdesc->natts);
1268
1269 /* Flattened value will no longer represent record accurately */
1270 erh->flags &= ~ER_FLAG_FVALUE_VALID;
1271 /* And we don't know the flattened size either */
1272 erh->flat_size = 0;
1273
1274 oldcxt = MemoryContextSwitchTo(erh->hdr.eoh_context);
1275
1276 dvalues = erh->dvalues;
1277 dnulls = erh->dnulls;
1278
1279 for (fnumber = 0; fnumber < erh->nfields; fnumber++)
1280 {
1281 Form_pg_attribute attr = TupleDescAttr(tupdesc, fnumber);
1282 Datum newValue;
1283 bool isnull;
1284
1285 /* Ignore dropped columns */
1286 if (attr->attisdropped)
1287 continue;
1288
1289 newValue = newValues[fnumber];
1290 isnull = isnulls[fnumber];
1291
1292 if (!attr->attbyval)
1293 {
1294 /*
1295 * Copy new field value into record's context, and deal with
1296 * detoasting, if needed.
1297 */
1298 if (!isnull)
1299 {
1300 /* Is it an external toasted value? */
1301 if (attr->attlen == -1 &&
1302 VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
1303 {
1304 if (expand_external)
1305 {
1306 /* Detoast as requested while copying the value */
1307 newValue = PointerGetDatum(heap_tuple_fetch_attr((struct varlena *) DatumGetPointer(newValue)));
1308 }
1309 else
1310 {
1311 /* Just copy the value */
1312 newValue = datumCopy(newValue, false, -1);
1313 /* If it's still external, remember that */
1314 if (VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
1315 erh->flags |= ER_FLAG_HAVE_EXTERNAL;
1316 }
1317 }
1318 else
1319 {
1320 /* Not an external value, just copy it */
1321 newValue = datumCopy(newValue, false, attr->attlen);
1322 }
1323
1324 /* Remember that we have field(s) that need to be pfree'd */
1325 erh->flags |= ER_FLAG_DVALUES_ALLOCED;
1326 }
1327
1328 /*
1329 * Free old field value, if any (not likely, since really we ought
1330 * to be inserting into an empty record).
1331 */
1332 if (unlikely(!dnulls[fnumber]))
1333 {
1334 char *oldValue;
1335
1336 oldValue = (char *) DatumGetPointer(dvalues[fnumber]);
1337 /* Don't try to pfree a part of the original flat record */
1338 if (oldValue < erh->fstartptr || oldValue >= erh->fendptr)
1339 pfree(oldValue);
1340 }
1341 }
1342
1343 /* And finally we can insert the new field. */
1344 dvalues[fnumber] = newValue;
1345 dnulls[fnumber] = isnull;
1346 }
1347
1348 /*
1349 * Because we don't guarantee atomicity of set_fields(), we can just leave
1350 * checking of domain constraints to occur as the final step; if it throws
1351 * an error, too bad.
1352 */
1353 if (erh->flags & ER_FLAG_IS_DOMAIN)
1354 {
1355 /* We run domain_check in a short-lived context to limit cruft */
1356 MemoryContextSwitchTo(get_short_term_cxt(erh));
1357
1358 domain_check(ExpandedRecordGetRODatum(erh), false,
1359 erh->er_decltypeid,
1360 &erh->er_domaininfo,
1361 erh->hdr.eoh_context);
1362 }
1363
1364 MemoryContextSwitchTo(oldcxt);
1365}
1366
1367/*
1368 * Construct (or reset) working memory context for short-term operations.
1369 *
1370 * This context is used for domain check evaluation and for detoasting.
1371 *
1372 * If we don't have a short-lived memory context, make one; if we have one,
1373 * reset it to get rid of any leftover cruft. (It is a tad annoying to need a
1374 * whole context for this, since it will often go unused --- but it's hard to
1375 * avoid memory leaks otherwise. We can make the context small, at least.)
1376 */
1377static MemoryContext
1378get_short_term_cxt(ExpandedRecordHeader *erh)
1379{
1380 if (erh->er_short_term_cxt == NULL)
1381 erh->er_short_term_cxt =
1382 AllocSetContextCreate(erh->hdr.eoh_context,
1383 "expanded record short-term context",
1384 ALLOCSET_SMALL_SIZES);
1385 else
1386 MemoryContextReset(erh->er_short_term_cxt);
1387 return erh->er_short_term_cxt;
1388}
1389
1390/*
1391 * Construct "dummy header" for checking domain constraints.
1392 *
1393 * Since we don't want to modify the state of the expanded record until
1394 * we've validated the constraints, our approach is to set up a dummy
1395 * record header containing the new field value(s) and then pass that to
1396 * domain_check. We retain the dummy header as part of the expanded
1397 * record's state to save palloc cycles, but reinitialize (most of)
1398 * its contents on each use.
1399 */
1400static void
1401build_dummy_expanded_header(ExpandedRecordHeader *main_erh)
1402{
1403 ExpandedRecordHeader *erh;
1404 TupleDesc tupdesc = expanded_record_get_tupdesc(main_erh);
1405
1406 /* Ensure we have a short-lived context */
1407 (void) get_short_term_cxt(main_erh);
1408
1409 /*
1410 * Allocate dummy header on first time through, or in the unlikely event
1411 * that the number of fields changes (in which case we just leak the old
1412 * one). Include space for its field values in the request.
1413 */
1414 erh = main_erh->er_dummy_header;
1415 if (erh == NULL || erh->nfields != tupdesc->natts)
1416 {
1417 char *chunk;
1418
1419 erh = (ExpandedRecordHeader *)
1420 MemoryContextAlloc(main_erh->hdr.eoh_context,
1421 MAXALIGN(sizeof(ExpandedRecordHeader))
1422 + tupdesc->natts * (sizeof(Datum) + sizeof(bool)));
1423
1424 /* Ensure all header fields are initialized to 0/null */
1425 memset(erh, 0, sizeof(ExpandedRecordHeader));
1426
1427 /*
1428 * We set up the dummy header with an indication that its memory
1429 * context is the short-lived context. This is so that, if any
1430 * detoasting of out-of-line values happens due to an attempt to
1431 * extract a composite datum from the dummy header, the detoasted
1432 * stuff will end up in the short-lived context and not cause a leak.
1433 * This is cheating a bit on the expanded-object protocol; but since
1434 * we never pass a R/W pointer to the dummy object to any other code,
1435 * nothing else is authorized to delete or transfer ownership of the
1436 * object's context, so it should be safe enough.
1437 */
1438 EOH_init_header(&erh->hdr, &ER_methods, main_erh->er_short_term_cxt);
1439 erh->er_magic = ER_MAGIC;
1440
1441 /* Set up dvalues/dnulls, with no valid contents as yet */
1442 chunk = (char *) erh + MAXALIGN(sizeof(ExpandedRecordHeader));
1443 erh->dvalues = (Datum *) chunk;
1444 erh->dnulls = (bool *) (chunk + tupdesc->natts * sizeof(Datum));
1445 erh->nfields = tupdesc->natts;
1446
1447 /*
1448 * The fields we just set are assumed to remain constant through
1449 * multiple uses of the dummy header to check domain constraints. All
1450 * other dummy header fields should be explicitly reset below, to
1451 * ensure there's not accidental effects of one check on the next one.
1452 */
1453
1454 main_erh->er_dummy_header = erh;
1455 }
1456
1457 /*
1458 * If anything inquires about the dummy header's declared type, it should
1459 * report the composite base type, not the domain type (since the VALUE in
1460 * a domain check constraint is of the base type not the domain). Hence
1461 * we do not transfer over the IS_DOMAIN flag, nor indeed any of the main
1462 * header's flags, since the dummy header is empty of data at this point.
1463 * But don't forget to mark header as dummy.
1464 */
1465 erh->flags = ER_FLAG_IS_DUMMY;
1466
1467 /* Copy composite-type identification info */
1468 erh->er_decltypeid = erh->er_typeid = main_erh->er_typeid;
1469 erh->er_typmod = main_erh->er_typmod;
1470
1471 /* Dummy header does not need its own tupdesc refcount */
1472 erh->er_tupdesc = tupdesc;
1473 erh->er_tupdesc_id = main_erh->er_tupdesc_id;
1474
1475 /*
1476 * It's tempting to copy over whatever we know about the flat size, but
1477 * there's no point since we're surely about to modify the dummy record's
1478 * field(s). Instead just clear anything left over from a previous usage
1479 * cycle.
1480 */
1481 erh->flat_size = 0;
1482
1483 /* Copy over fvalue if we have it, so that system columns are available */
1484 erh->fvalue = main_erh->fvalue;
1485 erh->fstartptr = main_erh->fstartptr;
1486 erh->fendptr = main_erh->fendptr;
1487}
1488
1489/*
1490 * Precheck domain constraints for a set_field operation
1491 */
1492static pg_noinline void
1493check_domain_for_new_field(ExpandedRecordHeader *erh, int fnumber,
1494 Datum newValue, bool isnull)
1495{
1496 ExpandedRecordHeader *dummy_erh;
1497 MemoryContext oldcxt;
1498
1499 /* Construct dummy header to contain proposed new field set */
1500 build_dummy_expanded_header(erh);
1501 dummy_erh = erh->er_dummy_header;
1502
1503 /*
1504 * If record isn't empty, just deconstruct it (if needed) and copy over
1505 * the existing field values. If it is empty, just fill fields with nulls
1506 * manually --- don't call deconstruct_expanded_record prematurely.
1507 */
1508 if (!ExpandedRecordIsEmpty(erh))
1509 {
1510 deconstruct_expanded_record(erh);
1511 memcpy(dummy_erh->dvalues, erh->dvalues,
1512 dummy_erh->nfields * sizeof(Datum));
1513 memcpy(dummy_erh->dnulls, erh->dnulls,
1514 dummy_erh->nfields * sizeof(bool));
1515 /* There might be some external values in there... */
1516 dummy_erh->flags |= erh->flags & ER_FLAG_HAVE_EXTERNAL;
1517 }
1518 else
1519 {
1520 memset(dummy_erh->dvalues, 0, dummy_erh->nfields * sizeof(Datum));
1521 memset(dummy_erh->dnulls, true, dummy_erh->nfields * sizeof(bool));
1522 }
1523
1524 /* Either way, we now have valid dvalues */
1525 dummy_erh->flags |= ER_FLAG_DVALUES_VALID;
1526
1527 /* Caller error if fnumber is system column or nonexistent column */
1528 if (unlikely(fnumber <= 0 || fnumber > dummy_erh->nfields))
1529 elog(ERROR, "cannot assign to field %d of expanded record", fnumber);
1530
1531 /* Insert proposed new value into dummy field array */
1532 dummy_erh->dvalues[fnumber - 1] = newValue;
1533 dummy_erh->dnulls[fnumber - 1] = isnull;
1534
1535 /*
1536 * The proposed new value might be external, in which case we'd better set
1537 * the flag for that in dummy_erh. (This matters in case something in the
1538 * domain check expressions tries to extract a flat value from the dummy
1539 * header.)
1540 */
1541 if (!isnull)
1542 {
1543 Form_pg_attribute attr = TupleDescAttr(erh->er_tupdesc, fnumber - 1);
1544
1545 if (!attr->attbyval && attr->attlen == -1 &&
1546 VARATT_IS_EXTERNAL(DatumGetPointer(newValue)))
1547 dummy_erh->flags |= ER_FLAG_HAVE_EXTERNAL;
1548 }
1549
1550 /*
1551 * We call domain_check in the short-lived context, so that any cruft
1552 * leaked by expression evaluation can be reclaimed.
1553 */
1554 oldcxt = MemoryContextSwitchTo(erh->er_short_term_cxt);
1555
1556 /*
1557 * And now we can apply the check. Note we use main header's domain cache
1558 * space, so that caching carries across repeated uses.
1559 */
1560 domain_check(ExpandedRecordGetRODatum(dummy_erh), false,
1561 erh->er_decltypeid,
1562 &erh->er_domaininfo,
1563 erh->hdr.eoh_context);
1564
1565 MemoryContextSwitchTo(oldcxt);
1566
1567 /* We might as well clean up cruft immediately. */
1568 MemoryContextReset(erh->er_short_term_cxt);
1569}
1570
1571/*
1572 * Precheck domain constraints for a set_tuple operation
1573 */
1574static pg_noinline void
1575check_domain_for_new_tuple(ExpandedRecordHeader *erh, HeapTuple tuple)
1576{
1577 ExpandedRecordHeader *dummy_erh;
1578 MemoryContext oldcxt;
1579
1580 /* If we're being told to set record to empty, just see if NULL is OK */
1581 if (tuple == NULL)
1582 {
1583 /* We run domain_check in a short-lived context to limit cruft */
1584 oldcxt = MemoryContextSwitchTo(get_short_term_cxt(erh));
1585
1586 domain_check((Datum) 0, true,
1587 erh->er_decltypeid,
1588 &erh->er_domaininfo,
1589 erh->hdr.eoh_context);
1590
1591 MemoryContextSwitchTo(oldcxt);
1592
1593 /* We might as well clean up cruft immediately. */
1594 MemoryContextReset(erh->er_short_term_cxt);
1595
1596 return;
1597 }
1598
1599 /* Construct dummy header to contain replacement tuple */
1600 build_dummy_expanded_header(erh);
1601 dummy_erh = erh->er_dummy_header;
1602
1603 /* Insert tuple, but don't bother to deconstruct its fields for now */
1604 dummy_erh->fvalue = tuple;
1605 dummy_erh->fstartptr = (char *) tuple->t_data;
1606 dummy_erh->fendptr = ((char *) tuple->t_data) + tuple->t_len;
1607 dummy_erh->flags |= ER_FLAG_FVALUE_VALID;
1608
1609 /* Remember if we have any out-of-line field values */
1610 if (HeapTupleHasExternal(tuple))
1611 dummy_erh->flags |= ER_FLAG_HAVE_EXTERNAL;
1612
1613 /*
1614 * We call domain_check in the short-lived context, so that any cruft
1615 * leaked by expression evaluation can be reclaimed.
1616 */
1617 oldcxt = MemoryContextSwitchTo(erh->er_short_term_cxt);
1618
1619 /*
1620 * And now we can apply the check. Note we use main header's domain cache
1621 * space, so that caching carries across repeated uses.
1622 */
1623 domain_check(ExpandedRecordGetRODatum(dummy_erh), false,
1624 erh->er_decltypeid,
1625 &erh->er_domaininfo,
1626 erh->hdr.eoh_context);
1627
1628 MemoryContextSwitchTo(oldcxt);
1629
1630 /* We might as well clean up cruft immediately. */
1631 MemoryContextReset(erh->er_short_term_cxt);
1632}
1633