Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * indextuple.c
4 : * This file contains index tuple accessor and mutator routines,
5 : * as well as various tuple utilities.
6 : *
7 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
8 : * Portions Copyright (c) 1994, Regents of the University of California
9 : *
10 : *
11 : * IDENTIFICATION
12 : * src/backend/access/common/indextuple.c
13 : *
14 : *-------------------------------------------------------------------------
15 : */
16 :
17 : #include "postgres.h"
18 :
19 : #include "access/detoast.h"
20 : #include "access/heaptoast.h"
21 : #include "access/htup_details.h"
22 : #include "access/itup.h"
23 : #include "access/toast_internals.h"
24 :
25 : /*
26 : * This enables de-toasting of index entries. Needed until VACUUM is
27 : * smart enough to rebuild indexes from scratch.
28 : */
29 : #define TOAST_INDEX_HACK
30 :
31 : /* ----------------------------------------------------------------
32 : * index_ tuple interface routines
33 : * ----------------------------------------------------------------
34 : */
35 :
36 : /* ----------------
37 : * index_form_tuple
38 : *
39 : * As index_form_tuple_context, but allocates the returned tuple in the
40 : * CurrentMemoryContext.
41 : * ----------------
42 : */
43 : IndexTuple
44 6582901 : index_form_tuple(TupleDesc tupleDescriptor,
45 : const Datum *values,
46 : const bool *isnull)
47 : {
48 6582901 : return index_form_tuple_context(tupleDescriptor, values, isnull,
49 : CurrentMemoryContext);
50 : }
51 :
52 : /* ----------------
53 : * index_form_tuple_context
54 : *
55 : * This shouldn't leak any memory; otherwise, callers such as
56 : * tuplesort_putindextuplevalues() will be very unhappy.
57 : *
58 : * This shouldn't perform external table access provided caller
59 : * does not pass values that are stored EXTERNAL.
60 : *
61 : * Allocates returned tuple in provided 'context'.
62 : * ----------------
63 : */
64 : IndexTuple
65 13217844 : index_form_tuple_context(TupleDesc tupleDescriptor,
66 : const Datum *values,
67 : const bool *isnull,
68 : MemoryContext context)
69 : {
70 : char *tp; /* tuple pointer */
71 : IndexTuple tuple; /* return tuple */
72 : Size size,
73 : data_size,
74 : hoff;
75 : int i;
76 13217844 : unsigned short infomask = 0;
77 13217844 : bool hasnull = false;
78 13217844 : uint16 tupmask = 0;
79 13217844 : int numberOfAttributes = tupleDescriptor->natts;
80 :
81 : #ifdef TOAST_INDEX_HACK
82 13217844 : Datum untoasted_values[INDEX_MAX_KEYS] = {0};
83 13217844 : bool untoasted_free[INDEX_MAX_KEYS] = {0};
84 : #endif
85 :
86 13217844 : if (numberOfAttributes > INDEX_MAX_KEYS)
87 0 : ereport(ERROR,
88 : (errcode(ERRCODE_TOO_MANY_COLUMNS),
89 : errmsg("number of index columns (%d) exceeds limit (%d)",
90 : numberOfAttributes, INDEX_MAX_KEYS)));
91 :
92 : #ifdef TOAST_INDEX_HACK
93 34335834 : for (i = 0; i < numberOfAttributes; i++)
94 : {
95 21117990 : Form_pg_attribute att = TupleDescAttr(tupleDescriptor, i);
96 :
97 21117990 : untoasted_values[i] = values[i];
98 21117990 : untoasted_free[i] = false;
99 :
100 : /* Do nothing if value is NULL or not of varlena type */
101 21117990 : if (isnull[i] || att->attlen != -1)
102 20388733 : continue;
103 :
104 : /*
105 : * If value is stored EXTERNAL, must fetch it so we are not depending
106 : * on outside storage. This should be improved someday.
107 : */
108 729257 : if (VARATT_IS_EXTERNAL(DatumGetPointer(values[i])))
109 : {
110 181 : untoasted_values[i] =
111 181 : PointerGetDatum(detoast_external_attr((varlena *)
112 181 : DatumGetPointer(values[i])));
113 181 : untoasted_free[i] = true;
114 : }
115 :
116 : /*
117 : * If value is above size target, and is of a compressible datatype,
118 : * try to compress it in-line.
119 : */
120 1159351 : if (!VARATT_IS_EXTENDED(DatumGetPointer(untoasted_values[i])) &&
121 430094 : VARSIZE(DatumGetPointer(untoasted_values[i])) > TOAST_INDEX_TARGET &&
122 65392 : (att->attstorage == TYPSTORAGE_EXTENDED ||
123 58193 : att->attstorage == TYPSTORAGE_MAIN))
124 : {
125 : Datum cvalue;
126 :
127 7199 : cvalue = toast_compress_datum(untoasted_values[i],
128 7199 : att->attcompression);
129 :
130 7199 : if (DatumGetPointer(cvalue) != NULL)
131 : {
132 : /* successful compression */
133 1502 : if (untoasted_free[i])
134 0 : pfree(DatumGetPointer(untoasted_values[i]));
135 1502 : untoasted_values[i] = cvalue;
136 1502 : untoasted_free[i] = true;
137 : }
138 : }
139 : }
140 : #endif
141 :
142 34281187 : for (i = 0; i < numberOfAttributes; i++)
143 : {
144 21116819 : if (isnull[i])
145 : {
146 53476 : hasnull = true;
147 53476 : break;
148 : }
149 : }
150 :
151 13217844 : if (hasnull)
152 53476 : infomask |= INDEX_NULL_MASK;
153 :
154 13217844 : hoff = IndexInfoFindDataOffset(infomask);
155 : #ifdef TOAST_INDEX_HACK
156 13217844 : data_size = heap_compute_data_size(tupleDescriptor,
157 : untoasted_values, isnull);
158 : #else
159 : data_size = heap_compute_data_size(tupleDescriptor,
160 : values, isnull);
161 : #endif
162 13217844 : size = hoff + data_size;
163 13217844 : size = MAXALIGN(size); /* be conservative */
164 :
165 13217844 : tp = (char *) MemoryContextAllocZero(context, size);
166 13217844 : tuple = (IndexTuple) tp;
167 :
168 13217844 : heap_fill_tuple(tupleDescriptor,
169 : #ifdef TOAST_INDEX_HACK
170 : untoasted_values,
171 : #else
172 : values,
173 : #endif
174 : isnull,
175 : tp + hoff,
176 : data_size,
177 : &tupmask,
178 : (hasnull ? (bits8 *) tp + sizeof(IndexTupleData) : NULL));
179 :
180 : #ifdef TOAST_INDEX_HACK
181 34335834 : for (i = 0; i < numberOfAttributes; i++)
182 : {
183 21117990 : if (untoasted_free[i])
184 1683 : pfree(DatumGetPointer(untoasted_values[i]));
185 : }
186 : #endif
187 :
188 : /*
189 : * We do this because heap_fill_tuple wants to initialize a "tupmask"
190 : * which is used for HeapTuples, but we want an indextuple infomask. The
191 : * only relevant info is the "has variable attributes" field. We have
192 : * already set the hasnull bit above.
193 : */
194 13217844 : if (tupmask & HEAP_HASVARWIDTH)
195 1759073 : infomask |= INDEX_VAR_MASK;
196 :
197 : /* Also assert we got rid of external attributes */
198 : #ifdef TOAST_INDEX_HACK
199 : Assert((tupmask & HEAP_HASEXTERNAL) == 0);
200 : #endif
201 :
202 : /*
203 : * Here we make sure that the size will fit in the field reserved for it
204 : * in t_info.
205 : */
206 13217844 : if ((size & INDEX_SIZE_MASK) != size)
207 0 : ereport(ERROR,
208 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
209 : errmsg("index row requires %zu bytes, maximum size is %zu",
210 : size, (Size) INDEX_SIZE_MASK)));
211 :
212 13217844 : infomask |= size;
213 :
214 : /*
215 : * initialize metadata
216 : */
217 13217844 : tuple->t_info = infomask;
218 13217844 : return tuple;
219 : }
220 :
221 : /* ----------------
222 : * nocache_index_getattr
223 : *
224 : * This gets called from index_getattr() macro, and only in cases
225 : * where we can't use cacheoffset and the value is not null.
226 : *
227 : * This caches attribute offsets in the attribute descriptor.
228 : *
229 : * An alternative way to speed things up would be to cache offsets
230 : * with the tuple, but that seems more difficult unless you take
231 : * the storage hit of actually putting those offsets into the
232 : * tuple you send to disk. Yuck.
233 : *
234 : * This scheme will be slightly slower than that, but should
235 : * perform well for queries which hit large #'s of tuples. After
236 : * you cache the offsets once, examining all the other tuples using
237 : * the same attribute descriptor will go much quicker. -cim 5/4/91
238 : * ----------------
239 : */
240 : Datum
241 3522874 : nocache_index_getattr(IndexTuple tup,
242 : int attnum,
243 : TupleDesc tupleDesc)
244 : {
245 : char *tp; /* ptr to data part of tuple */
246 3522874 : bits8 *bp = NULL; /* ptr to null bitmap in tuple */
247 3522874 : bool slow = false; /* do we have to walk attrs? */
248 : int data_off; /* tuple data offset */
249 : int off; /* current offset within data */
250 :
251 : /* ----------------
252 : * Three cases:
253 : *
254 : * 1: No nulls and no variable-width attributes.
255 : * 2: Has a null or a var-width AFTER att.
256 : * 3: Has nulls or var-widths BEFORE att.
257 : * ----------------
258 : */
259 :
260 3522874 : data_off = IndexInfoFindDataOffset(tup->t_info);
261 :
262 3522874 : attnum--;
263 :
264 3522874 : if (IndexTupleHasNulls(tup))
265 : {
266 : /*
267 : * there's a null somewhere in the tuple
268 : *
269 : * check to see if desired att is null
270 : */
271 :
272 : /* XXX "knows" t_bits are just after fixed tuple header! */
273 57298 : bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
274 :
275 : /*
276 : * Now check to see if any preceding bits are null...
277 : */
278 : {
279 57298 : int byte = attnum >> 3;
280 57298 : int finalbit = attnum & 0x07;
281 :
282 : /* check for nulls "before" final bit of last byte */
283 57298 : if ((~bp[byte]) & ((1 << finalbit) - 1))
284 345 : slow = true;
285 : else
286 : {
287 : /* check for nulls in any "earlier" bytes */
288 : int i;
289 :
290 56953 : for (i = 0; i < byte; i++)
291 : {
292 0 : if (bp[i] != 0xFF)
293 : {
294 0 : slow = true;
295 0 : break;
296 : }
297 : }
298 : }
299 : }
300 : }
301 :
302 3522874 : tp = (char *) tup + data_off;
303 :
304 3522874 : if (!slow)
305 : {
306 : CompactAttribute *att;
307 :
308 : /*
309 : * If we get here, there are no nulls up to and including the target
310 : * attribute. If we have a cached offset, we can use it.
311 : */
312 3522529 : att = TupleDescCompactAttr(tupleDesc, attnum);
313 3522529 : if (att->attcacheoff >= 0)
314 56873 : return fetchatt(att, tp + att->attcacheoff);
315 :
316 : /*
317 : * Otherwise, check for non-fixed-length attrs up to and including
318 : * target. If there aren't any, it's safe to cheaply initialize the
319 : * cached offsets for these attrs.
320 : */
321 3465656 : if (IndexTupleHasVarwidths(tup))
322 : {
323 : int j;
324 :
325 3549279 : for (j = 0; j <= attnum; j++)
326 : {
327 3539683 : if (TupleDescCompactAttr(tupleDesc, j)->attlen <= 0)
328 : {
329 3252172 : slow = true;
330 3252172 : break;
331 : }
332 : }
333 : }
334 : }
335 :
336 3466001 : if (!slow)
337 : {
338 213484 : int natts = tupleDesc->natts;
339 213484 : int j = 1;
340 :
341 : /*
342 : * If we get here, we have a tuple with no nulls or var-widths up to
343 : * and including the target attribute, so we can use the cached offset
344 : * ... only we don't have it yet, or we'd not have got here. Since
345 : * it's cheap to compute offsets for fixed-width columns, we take the
346 : * opportunity to initialize the cached offsets for *all* the leading
347 : * fixed-width columns, in hope of avoiding future visits to this
348 : * routine.
349 : */
350 213484 : TupleDescCompactAttr(tupleDesc, 0)->attcacheoff = 0;
351 :
352 : /* we might have set some offsets in the slow path previously */
353 213484 : while (j < natts && TupleDescCompactAttr(tupleDesc, j)->attcacheoff > 0)
354 0 : j++;
355 :
356 213484 : off = TupleDescCompactAttr(tupleDesc, j - 1)->attcacheoff +
357 213484 : TupleDescCompactAttr(tupleDesc, j - 1)->attlen;
358 :
359 354793 : for (; j < natts; j++)
360 : {
361 151427 : CompactAttribute *att = TupleDescCompactAttr(tupleDesc, j);
362 :
363 151427 : if (att->attlen <= 0)
364 10118 : break;
365 :
366 141309 : off = att_nominal_alignby(off, att->attalignby);
367 :
368 141309 : att->attcacheoff = off;
369 :
370 141309 : off += att->attlen;
371 : }
372 :
373 : Assert(j > attnum);
374 :
375 213484 : off = TupleDescCompactAttr(tupleDesc, attnum)->attcacheoff;
376 : }
377 : else
378 : {
379 3252517 : bool usecache = true;
380 : int i;
381 :
382 : /*
383 : * Now we know that we have to walk the tuple CAREFULLY. But we still
384 : * might be able to cache some offsets for next time.
385 : *
386 : * Note - This loop is a little tricky. For each non-null attribute,
387 : * we have to first account for alignment padding before the attr,
388 : * then advance over the attr based on its length. Nulls have no
389 : * storage and no alignment padding either. We can use/set
390 : * attcacheoff until we reach either a null or a var-width attribute.
391 : */
392 3252517 : off = 0;
393 3252517 : for (i = 0;; i++) /* loop exit is at "break" */
394 3864643 : {
395 7117160 : CompactAttribute *att = TupleDescCompactAttr(tupleDesc, i);
396 :
397 7117160 : if (IndexTupleHasNulls(tup) && att_isnull(i, bp))
398 : {
399 345 : usecache = false;
400 345 : continue; /* this cannot be the target att */
401 : }
402 :
403 : /* If we know the next offset, we can skip the rest */
404 7116815 : if (usecache && att->attcacheoff >= 0)
405 3456217 : off = att->attcacheoff;
406 3660598 : else if (att->attlen == -1)
407 : {
408 : /*
409 : * We can only cache the offset for a varlena attribute if the
410 : * offset is already suitably aligned, so that there would be
411 : * no pad bytes in any case: then the offset will be valid for
412 : * either an aligned or unaligned value.
413 : */
414 622295 : if (usecache &&
415 5321 : off == att_nominal_alignby(off, att->attalignby))
416 1518 : att->attcacheoff = off;
417 : else
418 : {
419 620777 : off = att_pointer_alignby(off, att->attalignby, -1,
420 : tp + off);
421 620777 : usecache = false;
422 : }
423 : }
424 : else
425 : {
426 : /* not varlena, so safe to use att_nominal_alignby */
427 3038303 : off = att_nominal_alignby(off, att->attalignby);
428 :
429 3038303 : if (usecache)
430 67619 : att->attcacheoff = off;
431 : }
432 :
433 7116815 : if (i == attnum)
434 3252517 : break;
435 :
436 3864298 : off = att_addlength_pointer(off, att->attlen, tp + off);
437 :
438 3864298 : if (usecache && att->attlen <= 0)
439 3179259 : usecache = false;
440 : }
441 : }
442 :
443 3466001 : return fetchatt(TupleDescCompactAttr(tupleDesc, attnum), tp + off);
444 : }
445 :
446 : /*
447 : * Convert an index tuple into Datum/isnull arrays.
448 : *
449 : * The caller must allocate sufficient storage for the output arrays.
450 : * (INDEX_MAX_KEYS entries should be enough.)
451 : *
452 : * This is nearly the same as heap_deform_tuple(), but for IndexTuples.
453 : * One difference is that the tuple should never have any missing columns.
454 : */
455 : void
456 2059799 : index_deform_tuple(IndexTuple tup, TupleDesc tupleDescriptor,
457 : Datum *values, bool *isnull)
458 : {
459 : char *tp; /* ptr to tuple data */
460 : bits8 *bp; /* ptr to null bitmap in tuple */
461 :
462 : /* XXX "knows" t_bits are just after fixed tuple header! */
463 2059799 : bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
464 :
465 2059799 : tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
466 :
467 2059799 : index_deform_tuple_internal(tupleDescriptor, values, isnull,
468 2059799 : tp, bp, IndexTupleHasNulls(tup));
469 2059799 : }
470 :
471 : /*
472 : * Convert an index tuple into Datum/isnull arrays,
473 : * without assuming any specific layout of the index tuple header.
474 : *
475 : * Caller must supply pointer to data area, pointer to nulls bitmap
476 : * (which can be NULL if !hasnulls), and hasnulls flag.
477 : */
478 : void
479 2090801 : index_deform_tuple_internal(TupleDesc tupleDescriptor,
480 : Datum *values, bool *isnull,
481 : char *tp, bits8 *bp, int hasnulls)
482 : {
483 2090801 : int natts = tupleDescriptor->natts; /* number of atts to extract */
484 : int attnum;
485 2090801 : int off = 0; /* offset in tuple data */
486 2090801 : bool slow = false; /* can we use/set attcacheoff? */
487 :
488 : /* Assert to protect callers who allocate fixed-size arrays */
489 : Assert(natts <= INDEX_MAX_KEYS);
490 :
491 4983036 : for (attnum = 0; attnum < natts; attnum++)
492 : {
493 2892235 : CompactAttribute *thisatt = TupleDescCompactAttr(tupleDescriptor, attnum);
494 :
495 2892235 : if (hasnulls && att_isnull(attnum, bp))
496 : {
497 2866 : values[attnum] = (Datum) 0;
498 2866 : isnull[attnum] = true;
499 2866 : slow = true; /* can't use attcacheoff anymore */
500 2866 : continue;
501 : }
502 :
503 2889369 : isnull[attnum] = false;
504 :
505 2889369 : if (!slow && thisatt->attcacheoff >= 0)
506 2861289 : off = thisatt->attcacheoff;
507 28080 : else if (thisatt->attlen == -1)
508 : {
509 : /*
510 : * We can only cache the offset for a varlena attribute if the
511 : * offset is already suitably aligned, so that there would be no
512 : * pad bytes in any case: then the offset will be valid for either
513 : * an aligned or unaligned value.
514 : */
515 6225 : if (!slow &&
516 160 : off == att_nominal_alignby(off, thisatt->attalignby))
517 160 : thisatt->attcacheoff = off;
518 : else
519 : {
520 6065 : off = att_pointer_alignby(off, thisatt->attalignby, -1,
521 : tp + off);
522 6065 : slow = true;
523 : }
524 : }
525 : else
526 : {
527 : /* not varlena, so safe to use att_nominal_alignby */
528 21855 : off = att_nominal_alignby(off, thisatt->attalignby);
529 :
530 21855 : if (!slow)
531 16819 : thisatt->attcacheoff = off;
532 : }
533 :
534 2889369 : values[attnum] = fetchatt(thisatt, tp + off);
535 :
536 2889369 : off = att_addlength_pointer(off, thisatt->attlen, tp + off);
537 :
538 2889369 : if (thisatt->attlen <= 0)
539 37256 : slow = true; /* can't use attcacheoff anymore */
540 : }
541 2090801 : }
542 :
543 : /*
544 : * Create a palloc'd copy of an index tuple.
545 : */
546 : IndexTuple
547 2534761 : CopyIndexTuple(IndexTuple source)
548 : {
549 : IndexTuple result;
550 : Size size;
551 :
552 2534761 : size = IndexTupleSize(source);
553 2534761 : result = (IndexTuple) palloc(size);
554 2534761 : memcpy(result, source, size);
555 2534761 : return result;
556 : }
557 :
558 : /*
559 : * Create a palloc'd copy of an index tuple, leaving only the first
560 : * leavenatts attributes remaining.
561 : *
562 : * Truncation is guaranteed to result in an index tuple that is no
563 : * larger than the original. It is safe to use the IndexTuple with
564 : * the original tuple descriptor, but caller must avoid actually
565 : * accessing truncated attributes from returned tuple! In practice
566 : * this means that index_getattr() must be called with special care,
567 : * and that the truncated tuple should only ever be accessed by code
568 : * under caller's direct control.
569 : *
570 : * It's safe to call this function with a buffer lock held, since it
571 : * never performs external table access. If it ever became possible
572 : * for index tuples to contain EXTERNAL TOAST values, then this would
573 : * have to be revisited.
574 : */
575 : IndexTuple
576 31509 : index_truncate_tuple(TupleDesc sourceDescriptor, IndexTuple source,
577 : int leavenatts)
578 : {
579 : TupleDesc truncdesc;
580 : Datum values[INDEX_MAX_KEYS];
581 : bool isnull[INDEX_MAX_KEYS];
582 : IndexTuple truncated;
583 :
584 : Assert(leavenatts <= sourceDescriptor->natts);
585 :
586 : /* Easy case: no truncation actually required */
587 31509 : if (leavenatts == sourceDescriptor->natts)
588 17862 : return CopyIndexTuple(source);
589 :
590 : /* Create temporary truncated tuple descriptor */
591 13647 : truncdesc = CreateTupleDescTruncatedCopy(sourceDescriptor, leavenatts);
592 :
593 : /* Deform, form copy of tuple with fewer attributes */
594 13647 : index_deform_tuple(source, truncdesc, values, isnull);
595 13647 : truncated = index_form_tuple(truncdesc, values, isnull);
596 13647 : truncated->t_tid = source->t_tid;
597 : Assert(IndexTupleSize(truncated) <= IndexTupleSize(source));
598 :
599 : /*
600 : * Cannot leak memory here, TupleDescCopy() doesn't allocate any inner
601 : * structure, so, plain pfree() should clean all allocated memory
602 : */
603 13647 : pfree(truncdesc);
604 :
605 13647 : return truncated;
606 : }
|
