Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * tupdesc.c
4 : : * POSTGRES tuple descriptor support code
5 : : *
6 : : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/access/common/tupdesc.c
12 : : *
13 : : * NOTES
14 : : * some of the executor utility code such as "ExecTypeFromTL" should be
15 : : * moved here.
16 : : *
17 : : *-------------------------------------------------------------------------
18 : : */
19 : :
20 : : #include "postgres.h"
21 : :
22 : : #include "access/htup_details.h"
23 : : #include "access/toast_compression.h"
24 : : #include "access/tupdesc_details.h"
25 : : #include "catalog/pg_collation.h"
26 : : #include "catalog/pg_type.h"
27 : : #include "common/hashfn.h"
28 : : #include "utils/builtins.h"
29 : : #include "utils/datum.h"
30 : : #include "utils/resowner.h"
31 : : #include "utils/syscache.h"
32 : :
33 : : /* ResourceOwner callbacks to hold tupledesc references */
34 : : static void ResOwnerReleaseTupleDesc(Datum res);
35 : : static char *ResOwnerPrintTupleDesc(Datum res);
36 : :
37 : : static const ResourceOwnerDesc tupdesc_resowner_desc =
38 : : {
39 : : .name = "tupdesc reference",
40 : : .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
41 : : .release_priority = RELEASE_PRIO_TUPDESC_REFS,
42 : : .ReleaseResource = ResOwnerReleaseTupleDesc,
43 : : .DebugPrint = ResOwnerPrintTupleDesc
44 : : };
45 : :
46 : : /* Convenience wrappers over ResourceOwnerRemember/Forget */
47 : : static inline void
158 heikki.linnakangas@i 48 :GNC 14565224 : ResourceOwnerRememberTupleDesc(ResourceOwner owner, TupleDesc tupdesc)
49 : : {
50 : 14565224 : ResourceOwnerRemember(owner, PointerGetDatum(tupdesc), &tupdesc_resowner_desc);
51 : 14565224 : }
52 : :
53 : : static inline void
54 : 14559047 : ResourceOwnerForgetTupleDesc(ResourceOwner owner, TupleDesc tupdesc)
55 : : {
56 : 14559047 : ResourceOwnerForget(owner, PointerGetDatum(tupdesc), &tupdesc_resowner_desc);
57 : 14559047 : }
58 : :
59 : : /*
60 : : * CreateTemplateTupleDesc
61 : : * This function allocates an empty tuple descriptor structure.
62 : : *
63 : : * Tuple type ID information is initially set for an anonymous record type;
64 : : * caller can overwrite this if needed.
65 : : */
66 : : TupleDesc
1972 andres@anarazel.de 67 :CBC 4291821 : CreateTemplateTupleDesc(int natts)
68 : : {
69 : : TupleDesc desc;
70 : :
71 : : /*
72 : : * sanity checks
73 : : */
534 peter@eisentraut.org 74 [ - + ]: 4291821 : Assert(natts >= 0);
75 : :
76 : : /*
77 : : * Allocate enough memory for the tuple descriptor, including the
78 : : * attribute rows.
79 : : *
80 : : * Note: the attribute array stride is sizeof(FormData_pg_attribute),
81 : : * since we declare the array elements as FormData_pg_attribute for
82 : : * notational convenience. However, we only guarantee that the first
83 : : * ATTRIBUTE_FIXED_PART_SIZE bytes of each entry are valid; most code that
84 : : * copies tupdesc entries around copies just that much. In principle that
85 : : * could be less due to trailing padding, although with the current
86 : : * definition of pg_attribute there probably isn't any padding.
87 : : */
1917 andres@anarazel.de 88 : 4291821 : desc = (TupleDesc) palloc(offsetof(struct TupleDescData, attrs) +
2429 89 : 4291821 : natts * sizeof(FormData_pg_attribute));
90 : :
91 : : /*
92 : : * Initialize other fields of the tupdesc.
93 : : */
7318 tgl@sss.pgh.pa.us 94 : 4291821 : desc->natts = natts;
7869 95 : 4291821 : desc->constr = NULL;
7318 96 : 4291821 : desc->tdtypeid = RECORDOID;
97 : 4291821 : desc->tdtypmod = -1;
6512 98 : 4291821 : desc->tdrefcount = -1; /* assume not reference-counted */
99 : :
9357 bruce@momjian.us 100 : 4291821 : return desc;
101 : : }
102 : :
103 : : /*
104 : : * CreateTupleDesc
105 : : * This function allocates a new TupleDesc by copying a given
106 : : * Form_pg_attribute array.
107 : : *
108 : : * Tuple type ID information is initially set for an anonymous record type;
109 : : * caller can overwrite this if needed.
110 : : */
111 : : TupleDesc
1972 andres@anarazel.de 112 : 446355 : CreateTupleDesc(int natts, Form_pg_attribute *attrs)
113 : : {
114 : : TupleDesc desc;
115 : : int i;
116 : :
117 : 446355 : desc = CreateTemplateTupleDesc(natts);
118 : :
2429 119 [ + + ]: 6786156 : for (i = 0; i < natts; ++i)
120 : 6339801 : memcpy(TupleDescAttr(desc, i), attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
121 : :
9357 bruce@momjian.us 122 : 446355 : return desc;
123 : : }
124 : :
125 : : /*
126 : : * CreateTupleDescCopy
127 : : * This function creates a new TupleDesc by copying from an existing
128 : : * TupleDesc.
129 : : *
130 : : * !!! Constraints and defaults are not copied !!!
131 : : */
132 : : TupleDesc
10141 scrappy@hub.org 133 : 185211 : CreateTupleDescCopy(TupleDesc tupdesc)
134 : : {
135 : : TupleDesc desc;
136 : : int i;
137 : :
1972 andres@anarazel.de 138 : 185211 : desc = CreateTemplateTupleDesc(tupdesc->natts);
139 : :
140 : : /* Flat-copy the attribute array */
2293 tgl@sss.pgh.pa.us 141 : 185211 : memcpy(TupleDescAttr(desc, 0),
142 : 185211 : TupleDescAttr(tupdesc, 0),
143 : 185211 : desc->natts * sizeof(FormData_pg_attribute));
144 : :
145 : : /*
146 : : * Since we're not copying constraints and defaults, clear fields
147 : : * associated with them.
148 : : */
6978 149 [ + + ]: 969561 : for (i = 0; i < desc->natts; i++)
150 : : {
2429 andres@anarazel.de 151 : 784350 : Form_pg_attribute att = TupleDescAttr(desc, i);
152 : :
153 : 784350 : att->attnotnull = false;
154 : 784350 : att->atthasdef = false;
2209 andrew@dunslane.net 155 : 784350 : att->atthasmissing = false;
2429 andres@anarazel.de 156 : 784350 : att->attidentity = '\0';
1842 peter@eisentraut.org 157 : 784350 : att->attgenerated = '\0';
158 : : }
159 : :
160 : : /* We can copy the tuple type identification, too */
7318 tgl@sss.pgh.pa.us 161 : 185211 : desc->tdtypeid = tupdesc->tdtypeid;
162 : 185211 : desc->tdtypmod = tupdesc->tdtypmod;
163 : :
9716 bruce@momjian.us 164 : 185211 : return desc;
165 : : }
166 : :
167 : : /*
168 : : * CreateTupleDescCopyConstr
169 : : * This function creates a new TupleDesc by copying from an existing
170 : : * TupleDesc (including its constraints and defaults).
171 : : */
172 : : TupleDesc
9732 vadim4o@yahoo.com 173 : 361343 : CreateTupleDescCopyConstr(TupleDesc tupdesc)
174 : : {
175 : : TupleDesc desc;
9715 bruce@momjian.us 176 : 361343 : TupleConstr *constr = tupdesc->constr;
177 : : int i;
178 : :
1972 andres@anarazel.de 179 : 361343 : desc = CreateTemplateTupleDesc(tupdesc->natts);
180 : :
181 : : /* Flat-copy the attribute array */
2293 tgl@sss.pgh.pa.us 182 : 361343 : memcpy(TupleDescAttr(desc, 0),
183 : 361343 : TupleDescAttr(tupdesc, 0),
184 : 361343 : desc->natts * sizeof(FormData_pg_attribute));
185 : :
186 : : /* Copy the TupleConstr data structure, if any */
9716 bruce@momjian.us 187 [ + + ]: 361343 : if (constr)
188 : : {
7318 tgl@sss.pgh.pa.us 189 : 331091 : TupleConstr *cpy = (TupleConstr *) palloc0(sizeof(TupleConstr));
190 : :
9716 bruce@momjian.us 191 : 331091 : cpy->has_not_null = constr->has_not_null;
1842 peter@eisentraut.org 192 : 331091 : cpy->has_generated_stored = constr->has_generated_stored;
193 : :
9716 bruce@momjian.us 194 [ + + ]: 331091 : if ((cpy->num_defval = constr->num_defval) > 0)
195 : : {
196 : 1882 : cpy->defval = (AttrDefault *) palloc(cpy->num_defval * sizeof(AttrDefault));
197 : 1882 : memcpy(cpy->defval, constr->defval, cpy->num_defval * sizeof(AttrDefault));
198 [ + + ]: 4497 : for (i = cpy->num_defval - 1; i >= 0; i--)
1104 tgl@sss.pgh.pa.us 199 : 2615 : cpy->defval[i].adbin = pstrdup(constr->defval[i].adbin);
200 : : }
201 : :
2209 andrew@dunslane.net 202 [ + + ]: 331091 : if (constr->missing)
203 : : {
204 : 289 : cpy->missing = (AttrMissing *) palloc(tupdesc->natts * sizeof(AttrMissing));
205 : 289 : memcpy(cpy->missing, constr->missing, tupdesc->natts * sizeof(AttrMissing));
206 [ + + ]: 2314 : for (i = tupdesc->natts - 1; i >= 0; i--)
207 : : {
2118 akapila@postgresql.o 208 [ + + ]: 2025 : if (constr->missing[i].am_present)
209 : : {
2209 andrew@dunslane.net 210 : 538 : Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
211 : :
2118 akapila@postgresql.o 212 : 538 : cpy->missing[i].am_value = datumCopy(constr->missing[i].am_value,
213 : 538 : attr->attbyval,
214 : 538 : attr->attlen);
215 : : }
216 : : }
217 : : }
218 : :
9716 bruce@momjian.us 219 [ + + ]: 331091 : if ((cpy->num_check = constr->num_check) > 0)
220 : : {
221 : 971 : cpy->check = (ConstrCheck *) palloc(cpy->num_check * sizeof(ConstrCheck));
222 : 971 : memcpy(cpy->check, constr->check, cpy->num_check * sizeof(ConstrCheck));
223 [ + + ]: 2304 : for (i = cpy->num_check - 1; i >= 0; i--)
224 : : {
1104 tgl@sss.pgh.pa.us 225 : 1333 : cpy->check[i].ccname = pstrdup(constr->check[i].ccname);
226 : 1333 : cpy->check[i].ccbin = pstrdup(constr->check[i].ccbin);
4701 alvherre@alvh.no-ip. 227 : 1333 : cpy->check[i].ccvalid = constr->check[i].ccvalid;
3675 noah@leadboat.com 228 : 1333 : cpy->check[i].ccnoinherit = constr->check[i].ccnoinherit;
229 : : }
230 : : }
231 : :
9716 bruce@momjian.us 232 : 331091 : desc->constr = cpy;
233 : : }
234 : :
235 : : /* We can copy the tuple type identification, too */
7318 tgl@sss.pgh.pa.us 236 : 361343 : desc->tdtypeid = tupdesc->tdtypeid;
237 : 361343 : desc->tdtypmod = tupdesc->tdtypmod;
238 : :
9716 bruce@momjian.us 239 : 361343 : return desc;
240 : : }
241 : :
242 : : /*
243 : : * TupleDescCopy
244 : : * Copy a tuple descriptor into caller-supplied memory.
245 : : * The memory may be shared memory mapped at any address, and must
246 : : * be sufficient to hold TupleDescSize(src) bytes.
247 : : *
248 : : * !!! Constraints and defaults are not copied !!!
249 : : */
250 : : void
2404 andres@anarazel.de 251 : 11809 : TupleDescCopy(TupleDesc dst, TupleDesc src)
252 : : {
253 : : int i;
254 : :
255 : : /* Flat-copy the header and attribute array */
256 : 11809 : memcpy(dst, src, TupleDescSize(src));
257 : :
258 : : /*
259 : : * Since we're not copying constraints and defaults, clear fields
260 : : * associated with them.
261 : : */
2293 tgl@sss.pgh.pa.us 262 [ + + ]: 45344 : for (i = 0; i < dst->natts; i++)
263 : : {
264 : 33535 : Form_pg_attribute att = TupleDescAttr(dst, i);
265 : :
266 : 33535 : att->attnotnull = false;
267 : 33535 : att->atthasdef = false;
2209 andrew@dunslane.net 268 : 33535 : att->atthasmissing = false;
2293 tgl@sss.pgh.pa.us 269 : 33535 : att->attidentity = '\0';
1842 peter@eisentraut.org 270 : 33535 : att->attgenerated = '\0';
271 : : }
2404 andres@anarazel.de 272 : 11809 : dst->constr = NULL;
273 : :
274 : : /*
275 : : * Also, assume the destination is not to be ref-counted. (Copying the
276 : : * source's refcount would be wrong in any case.)
277 : : */
278 : 11809 : dst->tdrefcount = -1;
279 : 11809 : }
280 : :
281 : : /*
282 : : * TupleDescCopyEntry
283 : : * This function copies a single attribute structure from one tuple
284 : : * descriptor to another.
285 : : *
286 : : * !!! Constraints and defaults are not copied !!!
287 : : */
288 : : void
3797 tgl@sss.pgh.pa.us 289 : 1795 : TupleDescCopyEntry(TupleDesc dst, AttrNumber dstAttno,
290 : : TupleDesc src, AttrNumber srcAttno)
291 : : {
2429 andres@anarazel.de 292 : 1795 : Form_pg_attribute dstAtt = TupleDescAttr(dst, dstAttno - 1);
293 : 1795 : Form_pg_attribute srcAtt = TupleDescAttr(src, srcAttno - 1);
294 : :
295 : : /*
296 : : * sanity checks
297 : : */
534 peter@eisentraut.org 298 [ - + ]: 1795 : Assert(PointerIsValid(src));
299 [ - + ]: 1795 : Assert(PointerIsValid(dst));
300 [ - + ]: 1795 : Assert(srcAttno >= 1);
301 [ - + ]: 1795 : Assert(srcAttno <= src->natts);
302 [ - + ]: 1795 : Assert(dstAttno >= 1);
303 [ - + ]: 1795 : Assert(dstAttno <= dst->natts);
304 : :
2429 andres@anarazel.de 305 : 1795 : memcpy(dstAtt, srcAtt, ATTRIBUTE_FIXED_PART_SIZE);
306 : :
307 : : /*
308 : : * Aside from updating the attno, we'd better reset attcacheoff.
309 : : *
310 : : * XXX Actually, to be entirely safe we'd need to reset the attcacheoff of
311 : : * all following columns in dst as well. Current usage scenarios don't
312 : : * require that though, because all following columns will get initialized
313 : : * by other uses of this function or TupleDescInitEntry. So we cheat a
314 : : * bit to avoid a useless O(N^2) penalty.
315 : : */
316 : 1795 : dstAtt->attnum = dstAttno;
317 : 1795 : dstAtt->attcacheoff = -1;
318 : :
319 : : /* since we're not copying constraints or defaults, clear these */
320 : 1795 : dstAtt->attnotnull = false;
321 : 1795 : dstAtt->atthasdef = false;
2209 andrew@dunslane.net 322 : 1795 : dstAtt->atthasmissing = false;
2429 andres@anarazel.de 323 : 1795 : dstAtt->attidentity = '\0';
1842 peter@eisentraut.org 324 : 1795 : dstAtt->attgenerated = '\0';
3797 tgl@sss.pgh.pa.us 325 : 1795 : }
326 : :
327 : : /*
328 : : * Free a TupleDesc including all substructure
329 : : */
330 : : void
9716 bruce@momjian.us 331 : 590329 : FreeTupleDesc(TupleDesc tupdesc)
332 : : {
333 : : int i;
334 : :
335 : : /*
336 : : * Possibly this should assert tdrefcount == 0, to disallow explicit
337 : : * freeing of un-refcounted tupdescs?
338 : : */
6512 tgl@sss.pgh.pa.us 339 [ - + ]: 590329 : Assert(tupdesc->tdrefcount <= 0);
340 : :
9716 bruce@momjian.us 341 [ + + ]: 590329 : if (tupdesc->constr)
342 : : {
343 [ + + ]: 165363 : if (tupdesc->constr->num_defval > 0)
344 : : {
9715 345 : 11792 : AttrDefault *attrdef = tupdesc->constr->defval;
346 : :
9716 347 [ + + ]: 28603 : for (i = tupdesc->constr->num_defval - 1; i >= 0; i--)
1104 tgl@sss.pgh.pa.us 348 : 16811 : pfree(attrdef[i].adbin);
9716 bruce@momjian.us 349 : 11792 : pfree(attrdef);
350 : : }
2209 andrew@dunslane.net 351 [ + + ]: 165363 : if (tupdesc->constr->missing)
352 : : {
353 : 1600 : AttrMissing *attrmiss = tupdesc->constr->missing;
354 : :
355 [ + + ]: 11898 : for (i = tupdesc->natts - 1; i >= 0; i--)
356 : : {
2118 akapila@postgresql.o 357 [ + + ]: 10298 : if (attrmiss[i].am_present
2209 andrew@dunslane.net 358 [ + + ]: 3502 : && !TupleDescAttr(tupdesc, i)->attbyval)
2118 akapila@postgresql.o 359 : 1339 : pfree(DatumGetPointer(attrmiss[i].am_value));
360 : : }
2209 andrew@dunslane.net 361 : 1600 : pfree(attrmiss);
362 : : }
9716 bruce@momjian.us 363 [ + + ]: 165363 : if (tupdesc->constr->num_check > 0)
364 : : {
9715 365 : 4834 : ConstrCheck *check = tupdesc->constr->check;
366 : :
9716 367 [ + + ]: 10978 : for (i = tupdesc->constr->num_check - 1; i >= 0; i--)
368 : : {
1104 tgl@sss.pgh.pa.us 369 : 6144 : pfree(check[i].ccname);
370 : 6144 : pfree(check[i].ccbin);
371 : : }
9716 bruce@momjian.us 372 : 4834 : pfree(check);
373 : : }
374 : 165363 : pfree(tupdesc->constr);
375 : : }
376 : :
377 : 590329 : pfree(tupdesc);
9732 vadim4o@yahoo.com 378 : 590329 : }
379 : :
380 : : /*
381 : : * Increment the reference count of a tupdesc, and log the reference in
382 : : * CurrentResourceOwner.
383 : : *
384 : : * Do not apply this to tupdescs that are not being refcounted. (Use the
385 : : * macro PinTupleDesc for tupdescs of uncertain status.)
386 : : */
387 : : void
6512 tgl@sss.pgh.pa.us 388 : 14565224 : IncrTupleDescRefCount(TupleDesc tupdesc)
389 : : {
390 [ - + ]: 14565224 : Assert(tupdesc->tdrefcount >= 0);
391 : :
158 heikki.linnakangas@i 392 :GNC 14565224 : ResourceOwnerEnlarge(CurrentResourceOwner);
6512 tgl@sss.pgh.pa.us 393 :CBC 14565224 : tupdesc->tdrefcount++;
394 : 14565224 : ResourceOwnerRememberTupleDesc(CurrentResourceOwner, tupdesc);
395 : 14565224 : }
396 : :
397 : : /*
398 : : * Decrement the reference count of a tupdesc, remove the corresponding
399 : : * reference from CurrentResourceOwner, and free the tupdesc if no more
400 : : * references remain.
401 : : *
402 : : * Do not apply this to tupdescs that are not being refcounted. (Use the
403 : : * macro ReleaseTupleDesc for tupdescs of uncertain status.)
404 : : */
405 : : void
406 : 14559047 : DecrTupleDescRefCount(TupleDesc tupdesc)
407 : : {
408 [ - + ]: 14559047 : Assert(tupdesc->tdrefcount > 0);
409 : :
410 : 14559047 : ResourceOwnerForgetTupleDesc(CurrentResourceOwner, tupdesc);
411 [ + + ]: 14559047 : if (--tupdesc->tdrefcount == 0)
412 : 2 : FreeTupleDesc(tupdesc);
413 : 14559047 : }
414 : :
415 : : /*
416 : : * Compare two TupleDesc structures for logical equality
417 : : */
418 : : bool
8840 419 : 141669 : equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
420 : : {
421 : : int i,
422 : : n;
423 : :
424 [ + + ]: 141669 : if (tupdesc1->natts != tupdesc2->natts)
425 : 1203 : return false;
7318 426 [ - + ]: 140466 : if (tupdesc1->tdtypeid != tupdesc2->tdtypeid)
7318 tgl@sss.pgh.pa.us 427 :LBC (819) : return false;
428 : :
429 : : /* tdtypmod and tdrefcount are not checked */
430 : :
8840 tgl@sss.pgh.pa.us 431 [ + + ]:CBC 618324 : for (i = 0; i < tupdesc1->natts; i++)
432 : : {
2429 andres@anarazel.de 433 : 484353 : Form_pg_attribute attr1 = TupleDescAttr(tupdesc1, i);
434 : 484353 : Form_pg_attribute attr2 = TupleDescAttr(tupdesc2, i);
435 : :
436 : : /*
437 : : * We do not need to check every single field here: we can disregard
438 : : * attrelid and attnum (which were used to place the row in the attrs
439 : : * array in the first place). It might look like we could dispense
440 : : * with checking attlen/attbyval/attalign, since these are derived
441 : : * from atttypid; but in the case of dropped columns we must check
442 : : * them (since atttypid will be zero for all dropped columns) and in
443 : : * general it seems safer to check them always.
444 : : *
445 : : * attcacheoff must NOT be checked since it's possibly not set in both
446 : : * copies. We also intentionally ignore atthasmissing, since that's
447 : : * not very relevant in tupdescs, which lack the attmissingval field.
448 : : */
8840 tgl@sss.pgh.pa.us 449 [ + + ]: 484353 : if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
450 : 630 : return false;
451 [ + + ]: 483723 : if (attr1->atttypid != attr2->atttypid)
452 : 480 : return false;
6940 453 [ + + ]: 483243 : if (attr1->attlen != attr2->attlen)
454 : 4 : return false;
7318 455 [ - + ]: 483239 : if (attr1->attndims != attr2->attndims)
7318 tgl@sss.pgh.pa.us 456 :UBC 0 : return false;
8840 tgl@sss.pgh.pa.us 457 [ + + ]:CBC 483239 : if (attr1->atttypmod != attr2->atttypmod)
458 : 21 : return false;
6940 459 [ + + ]: 483218 : if (attr1->attbyval != attr2->attbyval)
460 : 76 : return false;
1057 461 [ - + ]: 483142 : if (attr1->attalign != attr2->attalign)
1057 tgl@sss.pgh.pa.us 462 :UBC 0 : return false;
8840 tgl@sss.pgh.pa.us 463 [ + + ]:CBC 483142 : if (attr1->attstorage != attr2->attstorage)
464 : 104 : return false;
1057 465 [ + + ]: 483038 : if (attr1->attcompression != attr2->attcompression)
6940 466 : 30 : return false;
8840 467 [ + + ]: 483008 : if (attr1->attnotnull != attr2->attnotnull)
468 : 823 : return false;
7898 469 [ + + ]: 482185 : if (attr1->atthasdef != attr2->atthasdef)
470 : 1982 : return false;
2565 peter_e@gmx.net 471 [ + + ]: 480203 : if (attr1->attidentity != attr2->attidentity)
472 : 109 : return false;
1842 peter@eisentraut.org 473 [ + + ]: 480094 : if (attr1->attgenerated != attr2->attgenerated)
474 : 10 : return false;
7926 tgl@sss.pgh.pa.us 475 [ - + ]: 480084 : if (attr1->attisdropped != attr2->attisdropped)
7926 tgl@sss.pgh.pa.us 476 :UBC 0 : return false;
7875 tgl@sss.pgh.pa.us 477 [ + + ]:CBC 480084 : if (attr1->attislocal != attr2->attislocal)
478 : 1886 : return false;
479 [ + + ]: 478198 : if (attr1->attinhcount != attr2->attinhcount)
7898 480 : 340 : return false;
4741 481 [ - + ]: 477858 : if (attr1->attcollation != attr2->attcollation)
4741 tgl@sss.pgh.pa.us 482 :UBC 0 : return false;
483 : : /* variable-length fields are not even present... */
484 : : }
485 : :
8840 tgl@sss.pgh.pa.us 486 [ + + ]:CBC 133971 : if (tupdesc1->constr != NULL)
487 : : {
8768 bruce@momjian.us 488 : 39494 : TupleConstr *constr1 = tupdesc1->constr;
489 : 39494 : TupleConstr *constr2 = tupdesc2->constr;
490 : :
8840 tgl@sss.pgh.pa.us 491 [ + + ]: 39494 : if (constr2 == NULL)
492 : 106 : return false;
8558 493 [ - + ]: 39388 : if (constr1->has_not_null != constr2->has_not_null)
8558 tgl@sss.pgh.pa.us 494 :UBC 0 : return false;
1842 peter@eisentraut.org 495 [ + + ]:CBC 39388 : if (constr1->has_generated_stored != constr2->has_generated_stored)
496 : 248 : return false;
8558 tgl@sss.pgh.pa.us 497 : 39140 : n = constr1->num_defval;
498 [ - + ]: 39140 : if (n != (int) constr2->num_defval)
8840 tgl@sss.pgh.pa.us 499 :UBC 0 : return false;
500 : : /* We assume here that both AttrDefault arrays are in adnum order */
8558 tgl@sss.pgh.pa.us 501 [ + + ]:CBC 44667 : for (i = 0; i < n; i++)
502 : : {
8768 bruce@momjian.us 503 : 5527 : AttrDefault *defval1 = constr1->defval + i;
1104 tgl@sss.pgh.pa.us 504 : 5527 : AttrDefault *defval2 = constr2->defval + i;
505 : :
506 [ - + ]: 5527 : if (defval1->adnum != defval2->adnum)
8840 tgl@sss.pgh.pa.us 507 :UBC 0 : return false;
8840 tgl@sss.pgh.pa.us 508 [ - + ]:CBC 5527 : if (strcmp(defval1->adbin, defval2->adbin) != 0)
8840 tgl@sss.pgh.pa.us 509 :UBC 0 : return false;
510 : : }
2209 andrew@dunslane.net 511 [ + + ]:CBC 39140 : if (constr1->missing)
512 : : {
513 [ + + ]: 222 : if (!constr2->missing)
514 : 33 : return false;
515 [ + + ]: 1129 : for (i = 0; i < tupdesc1->natts; i++)
516 : : {
517 : 940 : AttrMissing *missval1 = constr1->missing + i;
518 : 940 : AttrMissing *missval2 = constr2->missing + i;
519 : :
2118 akapila@postgresql.o 520 [ - + ]: 940 : if (missval1->am_present != missval2->am_present)
2209 andrew@dunslane.net 521 :UBC 0 : return false;
2118 akapila@postgresql.o 522 [ + + ]:CBC 940 : if (missval1->am_present)
523 : : {
2209 andrew@dunslane.net 524 : 242 : Form_pg_attribute missatt1 = TupleDescAttr(tupdesc1, i);
525 : :
2118 akapila@postgresql.o 526 [ - + ]: 242 : if (!datumIsEqual(missval1->am_value, missval2->am_value,
2209 andrew@dunslane.net 527 : 242 : missatt1->attbyval, missatt1->attlen))
2209 andrew@dunslane.net 528 :UBC 0 : return false;
529 : : }
530 : : }
531 : : }
2209 andrew@dunslane.net 532 [ + + ]:CBC 38918 : else if (constr2->missing)
533 : 2 : return false;
8558 tgl@sss.pgh.pa.us 534 : 39105 : n = constr1->num_check;
535 [ + + ]: 39105 : if (n != (int) constr2->num_check)
8840 536 : 591 : return false;
537 : :
538 : : /*
539 : : * Similarly, we rely here on the ConstrCheck entries being sorted by
540 : : * name. If there are duplicate names, the outcome of the comparison
541 : : * is uncertain, but that should not happen.
542 : : */
8558 543 [ + + ]: 39729 : for (i = 0; i < n; i++)
544 : : {
8768 bruce@momjian.us 545 : 1254 : ConstrCheck *check1 = constr1->check + i;
1104 tgl@sss.pgh.pa.us 546 : 1254 : ConstrCheck *check2 = constr2->check + i;
547 : :
548 [ + - ]: 1254 : if (!(strcmp(check1->ccname, check2->ccname) == 0 &&
549 [ + - ]: 1254 : strcmp(check1->ccbin, check2->ccbin) == 0 &&
550 [ + + ]: 1254 : check1->ccvalid == check2->ccvalid &&
551 [ - + ]: 1215 : check1->ccnoinherit == check2->ccnoinherit))
8840 552 : 39 : return false;
553 : : }
554 : : }
555 [ + + ]: 94477 : else if (tupdesc2->constr != NULL)
556 : 793 : return false;
557 : 132159 : return true;
558 : : }
559 : :
560 : : /*
561 : : * equalRowTypes
562 : : *
563 : : * This determines whether two tuple descriptors have equal row types. This
564 : : * only checks those fields in pg_attribute that are applicable for row types,
565 : : * while ignoring those fields that define the physical row storage or those
566 : : * that define table column metadata.
567 : : *
568 : : * Specifically, this checks:
569 : : *
570 : : * - same number of attributes
571 : : * - same composite type ID (but could both be zero)
572 : : * - corresponding attributes (in order) have same the name, type, typmod,
573 : : * collation
574 : : *
575 : : * This is used to check whether two record types are compatible, whether
576 : : * function return row types are the same, and other similar situations.
577 : : *
578 : : * (XXX There was some discussion whether attndims should be checked here, but
579 : : * for now it has been decided not to.)
580 : : *
581 : : * Note: We deliberately do not check the tdtypmod field. This allows
582 : : * typcache.c to use this routine to see if a cached record type matches a
583 : : * requested type.
584 : : */
585 : : bool
28 peter@eisentraut.org 586 :GNC 159964 : equalRowTypes(TupleDesc tupdesc1, TupleDesc tupdesc2)
587 : : {
588 [ + + ]: 159964 : if (tupdesc1->natts != tupdesc2->natts)
589 : 66 : return false;
590 [ + + ]: 159898 : if (tupdesc1->tdtypeid != tupdesc2->tdtypeid)
591 : 821 : return false;
592 : :
593 [ + + ]: 2588614 : for (int i = 0; i < tupdesc1->natts; i++)
594 : : {
595 : 2431119 : Form_pg_attribute attr1 = TupleDescAttr(tupdesc1, i);
596 : 2431119 : Form_pg_attribute attr2 = TupleDescAttr(tupdesc2, i);
597 : :
598 [ + + ]: 2431119 : if (strcmp(NameStr(attr1->attname), NameStr(attr2->attname)) != 0)
599 : 1569 : return false;
600 [ + + ]: 2429550 : if (attr1->atttypid != attr2->atttypid)
601 : 11 : return false;
602 [ + + ]: 2429539 : if (attr1->atttypmod != attr2->atttypmod)
603 : 2 : return false;
604 [ - + ]: 2429537 : if (attr1->attcollation != attr2->attcollation)
28 peter@eisentraut.org 605 :UNC 0 : return false;
606 : :
607 : : /* Record types derived from tables could have dropped fields. */
28 peter@eisentraut.org 608 [ - + ]:GNC 2429537 : if (attr1->attisdropped != attr2->attisdropped)
28 peter@eisentraut.org 609 :UNC 0 : return false;
610 : : }
611 : :
28 peter@eisentraut.org 612 :GNC 157495 : return true;
613 : : }
614 : :
615 : : /*
616 : : * hashRowType
617 : : *
618 : : * If two tuple descriptors would be considered equal by equalRowTypes()
619 : : * then their hash value will be equal according to this function.
620 : : */
621 : : uint32
622 : 168355 : hashRowType(TupleDesc desc)
623 : : {
624 : : uint32 s;
625 : : int i;
626 : :
2427 andres@anarazel.de 627 :CBC 168355 : s = hash_combine(0, hash_uint32(desc->natts));
628 : 168355 : s = hash_combine(s, hash_uint32(desc->tdtypeid));
629 [ + + ]: 2735169 : for (i = 0; i < desc->natts; ++i)
630 : 2566814 : s = hash_combine(s, hash_uint32(TupleDescAttr(desc, i)->atttypid));
631 : :
632 : 168355 : return s;
633 : : }
634 : :
635 : : /*
636 : : * TupleDescInitEntry
637 : : * This function initializes a single attribute structure in
638 : : * a previously allocated tuple descriptor.
639 : : *
640 : : * If attributeName is NULL, the attname field is set to an empty string
641 : : * (this is for cases where we don't know or need a name for the field).
642 : : * Also, some callers use this function to change the datatype-related fields
643 : : * in an existing tupdesc; they pass attributeName = NameStr(att->attname)
644 : : * to indicate that the attname field shouldn't be modified.
645 : : *
646 : : * Note that attcollation is set to the default for the specified datatype.
647 : : * If a nondefault collation is needed, insert it afterwards using
648 : : * TupleDescInitEntryCollation.
649 : : */
650 : : void
10141 scrappy@hub.org 651 : 5418660 : TupleDescInitEntry(TupleDesc desc,
652 : : AttrNumber attributeNumber,
653 : : const char *attributeName,
654 : : Oid oidtypeid,
655 : : int32 typmod,
656 : : int attdim)
657 : : {
658 : : HeapTuple tuple;
659 : : Form_pg_type typeForm;
660 : : Form_pg_attribute att;
661 : :
662 : : /*
663 : : * sanity checks
664 : : */
534 peter@eisentraut.org 665 [ - + ]: 5418660 : Assert(PointerIsValid(desc));
666 [ - + ]: 5418660 : Assert(attributeNumber >= 1);
667 [ - + ]: 5418660 : Assert(attributeNumber <= desc->natts);
383 668 [ - + ]: 5418660 : Assert(attdim >= 0);
669 [ - + ]: 5418660 : Assert(attdim <= PG_INT16_MAX);
670 : :
671 : : /*
672 : : * initialize the attribute fields
673 : : */
2429 andres@anarazel.de 674 : 5418660 : att = TupleDescAttr(desc, attributeNumber - 1);
675 : :
9716 bruce@momjian.us 676 : 5418660 : att->attrelid = 0; /* dummy value */
677 : :
678 : : /*
679 : : * Note: attributeName can be NULL, because the planner doesn't always
680 : : * fill in valid resname values in targetlists, particularly for resjunk
681 : : * attributes. Also, do nothing if caller wants to re-use the old attname.
682 : : */
3821 tgl@sss.pgh.pa.us 683 [ + + ]: 5418660 : if (attributeName == NULL)
8925 bruce@momjian.us 684 [ - + - - : 1810301 : MemSet(NameStr(att->attname), 0, NAMEDATALEN);
- - - - -
- ]
3821 tgl@sss.pgh.pa.us 685 [ + + ]: 3608359 : else if (attributeName != NameStr(att->attname))
686 : 3607215 : namestrcpy(&(att->attname), attributeName);
687 : :
9716 bruce@momjian.us 688 : 5418660 : att->attcacheoff = -1;
9560 689 : 5418660 : att->atttypmod = typmod;
690 : :
9716 691 : 5418660 : att->attnum = attributeNumber;
8378 tgl@sss.pgh.pa.us 692 : 5418660 : att->attndims = attdim;
693 : :
9716 bruce@momjian.us 694 : 5418660 : att->attnotnull = false;
695 : 5418660 : att->atthasdef = false;
2209 andrew@dunslane.net 696 : 5418660 : att->atthasmissing = false;
2565 peter_e@gmx.net 697 : 5418660 : att->attidentity = '\0';
1842 peter@eisentraut.org 698 : 5418660 : att->attgenerated = '\0';
7926 tgl@sss.pgh.pa.us 699 : 5418660 : att->attisdropped = false;
7875 700 : 5418660 : att->attislocal = true;
701 : 5418660 : att->attinhcount = 0;
702 : : /* variable-length fields are not present in tupledescs */
703 : :
5173 rhaas@postgresql.org 704 : 5418660 : tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(oidtypeid));
9716 bruce@momjian.us 705 [ - + ]: 5418660 : if (!HeapTupleIsValid(tuple))
7573 tgl@sss.pgh.pa.us 706 [ # # ]:UBC 0 : elog(ERROR, "cache lookup failed for type %u", oidtypeid);
9357 bruce@momjian.us 707 :CBC 5418660 : typeForm = (Form_pg_type) GETSTRUCT(tuple);
708 : :
7318 tgl@sss.pgh.pa.us 709 : 5418660 : att->atttypid = oidtypeid;
710 : 5418660 : att->attlen = typeForm->typlen;
711 : 5418660 : att->attbyval = typeForm->typbyval;
712 : 5418660 : att->attalign = typeForm->typalign;
713 : 5418660 : att->attstorage = typeForm->typstorage;
1053 714 : 5418660 : att->attcompression = InvalidCompressionMethod;
1057 715 : 5418660 : att->attcollation = typeForm->typcollation;
716 : :
8550 717 : 5418660 : ReleaseSysCache(tuple);
10141 scrappy@hub.org 718 : 5418660 : }
719 : :
720 : : /*
721 : : * TupleDescInitBuiltinEntry
722 : : * Initialize a tuple descriptor without catalog access. Only
723 : : * a limited range of builtin types are supported.
724 : : */
725 : : void
2637 rhaas@postgresql.org 726 : 6270 : TupleDescInitBuiltinEntry(TupleDesc desc,
727 : : AttrNumber attributeNumber,
728 : : const char *attributeName,
729 : : Oid oidtypeid,
730 : : int32 typmod,
731 : : int attdim)
732 : : {
733 : : Form_pg_attribute att;
734 : :
735 : : /* sanity checks */
534 peter@eisentraut.org 736 [ - + ]: 6270 : Assert(PointerIsValid(desc));
737 [ - + ]: 6270 : Assert(attributeNumber >= 1);
738 [ - + ]: 6270 : Assert(attributeNumber <= desc->natts);
383 739 [ - + ]: 6270 : Assert(attdim >= 0);
740 [ - + ]: 6270 : Assert(attdim <= PG_INT16_MAX);
741 : :
742 : : /* initialize the attribute fields */
2429 andres@anarazel.de 743 : 6270 : att = TupleDescAttr(desc, attributeNumber - 1);
2637 rhaas@postgresql.org 744 : 6270 : att->attrelid = 0; /* dummy value */
745 : :
746 : : /* unlike TupleDescInitEntry, we require an attribute name */
747 [ - + ]: 6270 : Assert(attributeName != NULL);
748 : 6270 : namestrcpy(&(att->attname), attributeName);
749 : :
750 : 6270 : att->attcacheoff = -1;
751 : 6270 : att->atttypmod = typmod;
752 : :
753 : 6270 : att->attnum = attributeNumber;
754 : 6270 : att->attndims = attdim;
755 : :
756 : 6270 : att->attnotnull = false;
757 : 6270 : att->atthasdef = false;
2209 andrew@dunslane.net 758 : 6270 : att->atthasmissing = false;
2565 peter_e@gmx.net 759 : 6270 : att->attidentity = '\0';
1842 peter@eisentraut.org 760 : 6270 : att->attgenerated = '\0';
2637 rhaas@postgresql.org 761 : 6270 : att->attisdropped = false;
762 : 6270 : att->attislocal = true;
763 : 6270 : att->attinhcount = 0;
764 : : /* variable-length fields are not present in tupledescs */
765 : :
766 : 6270 : att->atttypid = oidtypeid;
767 : :
768 : : /*
769 : : * Our goal here is to support just enough types to let basic builtin
770 : : * commands work without catalog access - e.g. so that we can do certain
771 : : * things even in processes that are not connected to a database.
772 : : */
773 [ + - - + : 6270 : switch (oidtypeid)
+ - ]
774 : : {
775 : 5001 : case TEXTOID:
776 : : case TEXTARRAYOID:
777 : 5001 : att->attlen = -1;
778 : 5001 : att->attbyval = false;
1502 tgl@sss.pgh.pa.us 779 : 5001 : att->attalign = TYPALIGN_INT;
780 : 5001 : att->attstorage = TYPSTORAGE_EXTENDED;
1053 781 : 5001 : att->attcompression = InvalidCompressionMethod;
2637 rhaas@postgresql.org 782 : 5001 : att->attcollation = DEFAULT_COLLATION_OID;
783 : 5001 : break;
784 : :
2637 rhaas@postgresql.org 785 :UBC 0 : case BOOLOID:
786 : 0 : att->attlen = 1;
787 : 0 : att->attbyval = true;
1502 tgl@sss.pgh.pa.us 788 : 0 : att->attalign = TYPALIGN_CHAR;
789 : 0 : att->attstorage = TYPSTORAGE_PLAIN;
1057 790 : 0 : att->attcompression = InvalidCompressionMethod;
2637 rhaas@postgresql.org 791 : 0 : att->attcollation = InvalidOid;
792 : 0 : break;
793 : :
794 : 0 : case INT4OID:
795 : 0 : att->attlen = 4;
796 : 0 : att->attbyval = true;
1502 tgl@sss.pgh.pa.us 797 : 0 : att->attalign = TYPALIGN_INT;
798 : 0 : att->attstorage = TYPSTORAGE_PLAIN;
1057 799 : 0 : att->attcompression = InvalidCompressionMethod;
2637 rhaas@postgresql.org 800 : 0 : att->attcollation = InvalidOid;
2629 801 : 0 : break;
802 : :
2629 rhaas@postgresql.org 803 :CBC 1120 : case INT8OID:
804 : 1120 : att->attlen = 8;
805 : 1120 : att->attbyval = FLOAT8PASSBYVAL;
1502 tgl@sss.pgh.pa.us 806 : 1120 : att->attalign = TYPALIGN_DOUBLE;
807 : 1120 : att->attstorage = TYPSTORAGE_PLAIN;
1057 808 : 1120 : att->attcompression = InvalidCompressionMethod;
2629 rhaas@postgresql.org 809 : 1120 : att->attcollation = InvalidOid;
2637 810 : 1120 : break;
811 : :
650 peter@eisentraut.org 812 : 149 : case OIDOID:
813 : 149 : att->attlen = 4;
814 : 149 : att->attbyval = true;
815 : 149 : att->attalign = TYPALIGN_INT;
816 : 149 : att->attstorage = TYPSTORAGE_PLAIN;
817 : 149 : att->attcompression = InvalidCompressionMethod;
818 : 149 : att->attcollation = InvalidOid;
819 : 149 : break;
820 : :
1952 tgl@sss.pgh.pa.us 821 :UBC 0 : default:
822 [ # # ]: 0 : elog(ERROR, "unsupported type %u", oidtypeid);
823 : : }
2637 rhaas@postgresql.org 824 :CBC 6270 : }
825 : :
826 : : /*
827 : : * TupleDescInitEntryCollation
828 : : *
829 : : * Assign a nondefault collation to a previously initialized tuple descriptor
830 : : * entry.
831 : : */
832 : : void
4814 peter_e@gmx.net 833 : 2786894 : TupleDescInitEntryCollation(TupleDesc desc,
834 : : AttrNumber attributeNumber,
835 : : Oid collationid)
836 : : {
837 : : /*
838 : : * sanity checks
839 : : */
534 peter@eisentraut.org 840 [ - + ]: 2786894 : Assert(PointerIsValid(desc));
841 [ - + ]: 2786894 : Assert(attributeNumber >= 1);
842 [ - + ]: 2786894 : Assert(attributeNumber <= desc->natts);
843 : :
2429 andres@anarazel.de 844 : 2786894 : TupleDescAttr(desc, attributeNumber - 1)->attcollation = collationid;
4814 peter_e@gmx.net 845 : 2786894 : }
846 : :
847 : : /*
848 : : * BuildDescFromLists
849 : : *
850 : : * Build a TupleDesc given lists of column names (as String nodes),
851 : : * column type OIDs, typmods, and collation OIDs.
852 : : *
853 : : * No constraints are generated.
854 : : *
855 : : * This is for use with functions returning RECORD.
856 : : */
857 : : TupleDesc
201 peter@eisentraut.org 858 :GNC 646 : BuildDescFromLists(const List *names, const List *types, const List *typmods, const List *collations)
859 : : {
860 : : int natts;
861 : : AttrNumber attnum;
862 : : ListCell *l1;
863 : : ListCell *l2;
864 : : ListCell *l3;
865 : : ListCell *l4;
866 : : TupleDesc desc;
867 : :
6604 tgl@sss.pgh.pa.us 868 :CBC 646 : natts = list_length(names);
869 [ - + ]: 646 : Assert(natts == list_length(types));
870 [ - + ]: 646 : Assert(natts == list_length(typmods));
4814 peter_e@gmx.net 871 [ - + ]: 646 : Assert(natts == list_length(collations));
872 : :
873 : : /*
874 : : * allocate a new tuple descriptor
875 : : */
1972 andres@anarazel.de 876 : 646 : desc = CreateTemplateTupleDesc(natts);
877 : :
6604 tgl@sss.pgh.pa.us 878 : 646 : attnum = 0;
1872 879 [ + - + + : 2366 : forfour(l1, names, l2, types, l3, typmods, l4, collations)
+ - + + +
- + + + -
+ + + + +
- + - + -
+ + ]
880 : : {
6604 881 : 1720 : char *attname = strVal(lfirst(l1));
1872 882 : 1720 : Oid atttypid = lfirst_oid(l2);
883 : 1720 : int32 atttypmod = lfirst_int(l3);
884 : 1720 : Oid attcollation = lfirst_oid(l4);
885 : :
6604 886 : 1720 : attnum++;
887 : :
888 : 1720 : TupleDescInitEntry(desc, attnum, attname, atttypid, atttypmod, 0);
4814 peter_e@gmx.net 889 : 1720 : TupleDescInitEntryCollation(desc, attnum, attcollation);
890 : : }
891 : :
6604 tgl@sss.pgh.pa.us 892 : 646 : return desc;
893 : : }
894 : :
895 : : /*
896 : : * Get default expression (or NULL if none) for the given attribute number.
897 : : */
898 : : Node *
200 peter@eisentraut.org 899 :GNC 74392 : TupleDescGetDefault(TupleDesc tupdesc, AttrNumber attnum)
900 : : {
901 : 74392 : Node *result = NULL;
902 : :
903 [ + - ]: 74392 : if (tupdesc->constr)
904 : : {
905 : 74392 : AttrDefault *attrdef = tupdesc->constr->defval;
906 : :
907 [ + - ]: 112478 : for (int i = 0; i < tupdesc->constr->num_defval; i++)
908 : : {
909 [ + + ]: 112478 : if (attrdef[i].adnum == attnum)
910 : : {
911 : 74392 : result = stringToNode(attrdef[i].adbin);
912 : 74392 : break;
913 : : }
914 : : }
915 : : }
916 : :
917 : 74392 : return result;
918 : : }
919 : :
920 : : /* ResourceOwner callbacks */
921 : :
922 : : static void
158 heikki.linnakangas@i 923 : 6176 : ResOwnerReleaseTupleDesc(Datum res)
924 : : {
925 : 6176 : TupleDesc tupdesc = (TupleDesc) DatumGetPointer(res);
926 : :
927 : : /* Like DecrTupleDescRefCount, but don't call ResourceOwnerForget() */
928 [ - + ]: 6176 : Assert(tupdesc->tdrefcount > 0);
929 [ + + ]: 6176 : if (--tupdesc->tdrefcount == 0)
930 : 181 : FreeTupleDesc(tupdesc);
931 : 6176 : }
932 : :
933 : : static char *
158 heikki.linnakangas@i 934 :UNC 0 : ResOwnerPrintTupleDesc(Datum res)
935 : : {
936 : 0 : TupleDesc tupdesc = (TupleDesc) DatumGetPointer(res);
937 : :
938 : 0 : return psprintf("TupleDesc %p (%u,%d)",
939 : : tupdesc, tupdesc->tdtypeid, tupdesc->tdtypmod);
940 : : }
|
