PostgreSQL Source Code  git master
indextuple.c File Reference
#include "postgres.h"
#include "access/detoast.h"
#include "access/heaptoast.h"
#include "access/htup_details.h"
#include "access/itup.h"
#include "access/toast_internals.h"
Include dependency graph for indextuple.c:

Go to the source code of this file.

Macros

#define TOAST_INDEX_HACK
 

Functions

IndexTuple index_form_tuple (TupleDesc tupleDescriptor, Datum *values, bool *isnull)
 
Datum nocache_index_getattr (IndexTuple tup, int attnum, TupleDesc tupleDesc)
 
void index_deform_tuple (IndexTuple tup, TupleDesc tupleDescriptor, Datum *values, bool *isnull)
 
IndexTuple CopyIndexTuple (IndexTuple source)
 
IndexTuple index_truncate_tuple (TupleDesc sourceDescriptor, IndexTuple source, int leavenatts)
 

Macro Definition Documentation

◆ TOAST_INDEX_HACK

#define TOAST_INDEX_HACK

Definition at line 29 of file indextuple.c.

Referenced by index_form_tuple().

Function Documentation

◆ CopyIndexTuple()

IndexTuple CopyIndexTuple ( IndexTuple  source)

Definition at line 510 of file indextuple.c.

References IndexTupleSize, and palloc().

Referenced by _bt_buildadd(), _bt_insert_parent(), _bt_insertonpg(), _bt_load(), _bt_newroot(), _bt_pagedel(), _bt_swap_posting(), _hash_splitbucket(), _hash_squeezebucket(), btree_xlog_insert(), btree_xlog_split(), gistformdownlink(), and index_truncate_tuple().

511 {
512  IndexTuple result;
513  Size size;
514 
515  size = IndexTupleSize(source);
516  result = (IndexTuple) palloc(size);
517  memcpy(result, source, size);
518  return result;
519 }
IndexTupleData * IndexTuple
Definition: itup.h:53
size_t Size
Definition: c.h:528
void * palloc(Size size)
Definition: mcxt.c:950
#define IndexTupleSize(itup)
Definition: itup.h:71

◆ index_deform_tuple()

void index_deform_tuple ( IndexTuple  tup,
TupleDesc  tupleDescriptor,
Datum values,
bool isnull 
)

Definition at line 434 of file indextuple.c.

References Assert, att_addlength_pointer, att_align_nominal, att_align_pointer, att_isnull, attnum, fetchatt, INDEX_MAX_KEYS, IndexInfoFindDataOffset, IndexTupleHasNulls, TupleDescData::natts, IndexTupleData::t_info, and TupleDescAttr.

Referenced by _bt_check_unique(), comparetup_index_btree(), get_actual_variable_endpoint(), index_truncate_tuple(), and StoreIndexTuple().

436 {
437  int hasnulls = IndexTupleHasNulls(tup);
438  int natts = tupleDescriptor->natts; /* number of atts to extract */
439  int attnum;
440  char *tp; /* ptr to tuple data */
441  int off; /* offset in tuple data */
442  bits8 *bp; /* ptr to null bitmap in tuple */
443  bool slow = false; /* can we use/set attcacheoff? */
444 
445  /* Assert to protect callers who allocate fixed-size arrays */
446  Assert(natts <= INDEX_MAX_KEYS);
447 
448  /* XXX "knows" t_bits are just after fixed tuple header! */
449  bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
450 
451  tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
452  off = 0;
453 
454  for (attnum = 0; attnum < natts; attnum++)
455  {
456  Form_pg_attribute thisatt = TupleDescAttr(tupleDescriptor, attnum);
457 
458  if (hasnulls && att_isnull(attnum, bp))
459  {
460  values[attnum] = (Datum) 0;
461  isnull[attnum] = true;
462  slow = true; /* can't use attcacheoff anymore */
463  continue;
464  }
465 
466  isnull[attnum] = false;
467 
468  if (!slow && thisatt->attcacheoff >= 0)
469  off = thisatt->attcacheoff;
470  else if (thisatt->attlen == -1)
471  {
472  /*
473  * We can only cache the offset for a varlena attribute if the
474  * offset is already suitably aligned, so that there would be no
475  * pad bytes in any case: then the offset will be valid for either
476  * an aligned or unaligned value.
477  */
478  if (!slow &&
479  off == att_align_nominal(off, thisatt->attalign))
480  thisatt->attcacheoff = off;
481  else
482  {
483  off = att_align_pointer(off, thisatt->attalign, -1,
484  tp + off);
485  slow = true;
486  }
487  }
488  else
489  {
490  /* not varlena, so safe to use att_align_nominal */
491  off = att_align_nominal(off, thisatt->attalign);
492 
493  if (!slow)
494  thisatt->attcacheoff = off;
495  }
496 
497  values[attnum] = fetchatt(thisatt, tp + off);
498 
499  off = att_addlength_pointer(off, thisatt->attlen, tp + off);
500 
501  if (thisatt->attlen <= 0)
502  slow = true; /* can't use attcacheoff anymore */
503  }
504 }
#define IndexInfoFindDataOffset(t_info)
Definition: itup.h:80
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:148
#define att_isnull(ATT, BITS)
Definition: tupmacs.h:25
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define IndexTupleHasNulls(itup)
Definition: itup.h:72
#define fetchatt(A, T)
Definition: tupmacs.h:41
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:176
uint8 bits8
Definition: c.h:436
uintptr_t Datum
Definition: postgres.h:367
struct IndexTupleData IndexTupleData
#define att_align_pointer(cur_offset, attalign, attlen, attptr)
Definition: tupmacs.h:126
int16 attnum
Definition: pg_attribute.h:79
#define Assert(condition)
Definition: c.h:800
#define INDEX_MAX_KEYS
static Datum values[MAXATTR]
Definition: bootstrap.c:165
unsigned short t_info
Definition: itup.h:49

◆ index_form_tuple()

IndexTuple index_form_tuple ( TupleDesc  tupleDescriptor,
Datum values,
bool isnull 
)

Definition at line 47 of file indextuple.c.

References Assert, DatumGetPointer, detoast_external_attr(), ereport, errcode(), errmsg(), ERROR, heap_compute_data_size(), heap_fill_tuple(), HEAP_HASEXTERNAL, HEAP_HASVARWIDTH, i, INDEX_MAX_KEYS, INDEX_NULL_MASK, INDEX_SIZE_MASK, INDEX_VAR_MASK, IndexInfoFindDataOffset, MAXALIGN, TupleDescData::natts, palloc0(), pfree(), PointerGetDatum, IndexTupleData::t_info, toast_compress_datum(), TOAST_INDEX_HACK, TOAST_INDEX_TARGET, TupleDescAttr, VARATT_IS_EXTENDED, VARATT_IS_EXTERNAL, and VARSIZE.

Referenced by bt_normalize_tuple(), bt_tuple_present_callback(), btinsert(), GinFormTuple(), gistFormTuple(), hashbuildCallback(), hashinsert(), index_truncate_tuple(), and tuplesort_putindextuplevalues().

50 {
51  char *tp; /* tuple pointer */
52  IndexTuple tuple; /* return tuple */
53  Size size,
54  data_size,
55  hoff;
56  int i;
57  unsigned short infomask = 0;
58  bool hasnull = false;
59  uint16 tupmask = 0;
60  int numberOfAttributes = tupleDescriptor->natts;
61 
62 #ifdef TOAST_INDEX_HACK
63  Datum untoasted_values[INDEX_MAX_KEYS];
64  bool untoasted_free[INDEX_MAX_KEYS];
65 #endif
66 
67  if (numberOfAttributes > INDEX_MAX_KEYS)
68  ereport(ERROR,
69  (errcode(ERRCODE_TOO_MANY_COLUMNS),
70  errmsg("number of index columns (%d) exceeds limit (%d)",
71  numberOfAttributes, INDEX_MAX_KEYS)));
72 
73 #ifdef TOAST_INDEX_HACK
74  for (i = 0; i < numberOfAttributes; i++)
75  {
76  Form_pg_attribute att = TupleDescAttr(tupleDescriptor, i);
77 
78  untoasted_values[i] = values[i];
79  untoasted_free[i] = false;
80 
81  /* Do nothing if value is NULL or not of varlena type */
82  if (isnull[i] || att->attlen != -1)
83  continue;
84 
85  /*
86  * If value is stored EXTERNAL, must fetch it so we are not depending
87  * on outside storage. This should be improved someday.
88  */
90  {
91  untoasted_values[i] =
93  DatumGetPointer(values[i])));
94  untoasted_free[i] = true;
95  }
96 
97  /*
98  * If value is above size target, and is of a compressible datatype,
99  * try to compress it in-line.
100  */
101  if (!VARATT_IS_EXTENDED(DatumGetPointer(untoasted_values[i])) &&
102  VARSIZE(DatumGetPointer(untoasted_values[i])) > TOAST_INDEX_TARGET &&
103  (att->attstorage == TYPSTORAGE_EXTENDED ||
104  att->attstorage == TYPSTORAGE_MAIN))
105  {
106  Datum cvalue = toast_compress_datum(untoasted_values[i]);
107 
108  if (DatumGetPointer(cvalue) != NULL)
109  {
110  /* successful compression */
111  if (untoasted_free[i])
112  pfree(DatumGetPointer(untoasted_values[i]));
113  untoasted_values[i] = cvalue;
114  untoasted_free[i] = true;
115  }
116  }
117  }
118 #endif
119 
120  for (i = 0; i < numberOfAttributes; i++)
121  {
122  if (isnull[i])
123  {
124  hasnull = true;
125  break;
126  }
127  }
128 
129  if (hasnull)
130  infomask |= INDEX_NULL_MASK;
131 
132  hoff = IndexInfoFindDataOffset(infomask);
133 #ifdef TOAST_INDEX_HACK
134  data_size = heap_compute_data_size(tupleDescriptor,
135  untoasted_values, isnull);
136 #else
137  data_size = heap_compute_data_size(tupleDescriptor,
138  values, isnull);
139 #endif
140  size = hoff + data_size;
141  size = MAXALIGN(size); /* be conservative */
142 
143  tp = (char *) palloc0(size);
144  tuple = (IndexTuple) tp;
145 
146  heap_fill_tuple(tupleDescriptor,
147 #ifdef TOAST_INDEX_HACK
148  untoasted_values,
149 #else
150  values,
151 #endif
152  isnull,
153  (char *) tp + hoff,
154  data_size,
155  &tupmask,
156  (hasnull ? (bits8 *) tp + sizeof(IndexTupleData) : NULL));
157 
158 #ifdef TOAST_INDEX_HACK
159  for (i = 0; i < numberOfAttributes; i++)
160  {
161  if (untoasted_free[i])
162  pfree(DatumGetPointer(untoasted_values[i]));
163  }
164 #endif
165 
166  /*
167  * We do this because heap_fill_tuple wants to initialize a "tupmask"
168  * which is used for HeapTuples, but we want an indextuple infomask. The
169  * only relevant info is the "has variable attributes" field. We have
170  * already set the hasnull bit above.
171  */
172  if (tupmask & HEAP_HASVARWIDTH)
173  infomask |= INDEX_VAR_MASK;
174 
175  /* Also assert we got rid of external attributes */
176 #ifdef TOAST_INDEX_HACK
177  Assert((tupmask & HEAP_HASEXTERNAL) == 0);
178 #endif
179 
180  /*
181  * Here we make sure that the size will fit in the field reserved for it
182  * in t_info.
183  */
184  if ((size & INDEX_SIZE_MASK) != size)
185  ereport(ERROR,
186  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
187  errmsg("index row requires %zu bytes, maximum size is %zu",
188  size, (Size) INDEX_SIZE_MASK)));
189 
190  infomask |= size;
191 
192  /*
193  * initialize metadata
194  */
195  tuple->t_info = infomask;
196  return tuple;
197 }
void heap_fill_tuple(TupleDesc tupleDesc, Datum *values, bool *isnull, char *data, Size data_size, uint16 *infomask, bits8 *bit)
Definition: heaptuple.c:304
#define IndexInfoFindDataOffset(t_info)
Definition: itup.h:80
#define VARSIZE(PTR)
Definition: postgres.h:303
#define PointerGetDatum(X)
Definition: postgres.h:556
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
struct varlena * detoast_external_attr(struct varlena *attr)
Definition: detoast.c:44
#define INDEX_SIZE_MASK
Definition: itup.h:65
int errcode(int sqlerrcode)
Definition: elog.c:691
#define VARATT_IS_EXTERNAL(PTR)
Definition: postgres.h:313
unsigned short uint16
Definition: c.h:428
void pfree(void *pointer)
Definition: mcxt.c:1057
#define TOAST_INDEX_TARGET
Definition: heaptoast.h:68
#define ERROR
Definition: elog.h:43
#define INDEX_VAR_MASK
Definition: itup.h:68
IndexTupleData * IndexTuple
Definition: itup.h:53
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
#define INDEX_NULL_MASK
Definition: itup.h:69
#define HEAP_HASVARWIDTH
Definition: htup_details.h:190
uint8 bits8
Definition: c.h:436
void * palloc0(Size size)
Definition: mcxt.c:981
uintptr_t Datum
Definition: postgres.h:367
#define TOAST_INDEX_HACK
Definition: indextuple.c:29
#define ereport(elevel,...)
Definition: elog.h:155
#define Assert(condition)
Definition: c.h:800
#define INDEX_MAX_KEYS
size_t Size
Definition: c.h:528
#define MAXALIGN(LEN)
Definition: c.h:753
Size heap_compute_data_size(TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:119
#define VARATT_IS_EXTENDED(PTR)
Definition: postgres.h:327
#define DatumGetPointer(X)
Definition: postgres.h:549
static Datum values[MAXATTR]
Definition: bootstrap.c:165
Datum toast_compress_datum(Datum value)
int errmsg(const char *fmt,...)
Definition: elog.c:902
int i
#define HEAP_HASEXTERNAL
Definition: htup_details.h:191
Definition: c.h:617
unsigned short t_info
Definition: itup.h:49

◆ index_truncate_tuple()

IndexTuple index_truncate_tuple ( TupleDesc  sourceDescriptor,
IndexTuple  source,
int  leavenatts 
)

Definition at line 539 of file indextuple.c.

References Assert, CopyIndexTuple(), index_deform_tuple(), index_form_tuple(), INDEX_MAX_KEYS, IndexTupleSize, TupleDescData::natts, palloc(), pfree(), IndexTupleData::t_tid, TupleDescCopy(), TupleDescSize, and values.

Referenced by _bt_truncate().

541 {
542  TupleDesc truncdesc;
544  bool isnull[INDEX_MAX_KEYS];
545  IndexTuple truncated;
546 
547  Assert(leavenatts <= sourceDescriptor->natts);
548 
549  /* Easy case: no truncation actually required */
550  if (leavenatts == sourceDescriptor->natts)
551  return CopyIndexTuple(source);
552 
553  /* Create temporary descriptor to scribble on */
554  truncdesc = palloc(TupleDescSize(sourceDescriptor));
555  TupleDescCopy(truncdesc, sourceDescriptor);
556  truncdesc->natts = leavenatts;
557 
558  /* Deform, form copy of tuple with fewer attributes */
559  index_deform_tuple(source, truncdesc, values, isnull);
560  truncated = index_form_tuple(truncdesc, values, isnull);
561  truncated->t_tid = source->t_tid;
562  Assert(IndexTupleSize(truncated) <= IndexTupleSize(source));
563 
564  /*
565  * Cannot leak memory here, TupleDescCopy() doesn't allocate any inner
566  * structure, so, plain pfree() should clean all allocated memory
567  */
568  pfree(truncdesc);
569 
570  return truncated;
571 }
ItemPointerData t_tid
Definition: itup.h:37
#define TupleDescSize(src)
Definition: tupdesc.h:102
IndexTuple index_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: indextuple.c:47
void pfree(void *pointer)
Definition: mcxt.c:1057
IndexTuple CopyIndexTuple(IndexTuple source)
Definition: indextuple.c:510
void index_deform_tuple(IndexTuple tup, TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: indextuple.c:434
uintptr_t Datum
Definition: postgres.h:367
#define Assert(condition)
Definition: c.h:800
#define INDEX_MAX_KEYS
static Datum values[MAXATTR]
Definition: bootstrap.c:165
void TupleDescCopy(TupleDesc dst, TupleDesc src)
Definition: tupdesc.c:233
void * palloc(Size size)
Definition: mcxt.c:950
#define IndexTupleSize(itup)
Definition: itup.h:71

◆ nocache_index_getattr()

Datum nocache_index_getattr ( IndexTuple  tup,
int  attnum,
TupleDesc  tupleDesc 
)

Definition at line 219 of file indextuple.c.

References Assert, att_addlength_pointer, att_align_nominal, att_align_pointer, att_isnull, attlen, attnum, byte, fetchatt, i, IndexInfoFindDataOffset, IndexTupleHasNulls, IndexTupleHasVarwidths, TupleDescData::natts, IndexTupleData::t_info, and TupleDescAttr.

222 {
223  char *tp; /* ptr to data part of tuple */
224  bits8 *bp = NULL; /* ptr to null bitmap in tuple */
225  bool slow = false; /* do we have to walk attrs? */
226  int data_off; /* tuple data offset */
227  int off; /* current offset within data */
228 
229  /* ----------------
230  * Three cases:
231  *
232  * 1: No nulls and no variable-width attributes.
233  * 2: Has a null or a var-width AFTER att.
234  * 3: Has nulls or var-widths BEFORE att.
235  * ----------------
236  */
237 
238  data_off = IndexInfoFindDataOffset(tup->t_info);
239 
240  attnum--;
241 
242  if (IndexTupleHasNulls(tup))
243  {
244  /*
245  * there's a null somewhere in the tuple
246  *
247  * check to see if desired att is null
248  */
249 
250  /* XXX "knows" t_bits are just after fixed tuple header! */
251  bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
252 
253  /*
254  * Now check to see if any preceding bits are null...
255  */
256  {
257  int byte = attnum >> 3;
258  int finalbit = attnum & 0x07;
259 
260  /* check for nulls "before" final bit of last byte */
261  if ((~bp[byte]) & ((1 << finalbit) - 1))
262  slow = true;
263  else
264  {
265  /* check for nulls in any "earlier" bytes */
266  int i;
267 
268  for (i = 0; i < byte; i++)
269  {
270  if (bp[i] != 0xFF)
271  {
272  slow = true;
273  break;
274  }
275  }
276  }
277  }
278  }
279 
280  tp = (char *) tup + data_off;
281 
282  if (!slow)
283  {
284  Form_pg_attribute att;
285 
286  /*
287  * If we get here, there are no nulls up to and including the target
288  * attribute. If we have a cached offset, we can use it.
289  */
290  att = TupleDescAttr(tupleDesc, attnum);
291  if (att->attcacheoff >= 0)
292  return fetchatt(att, tp + att->attcacheoff);
293 
294  /*
295  * Otherwise, check for non-fixed-length attrs up to and including
296  * target. If there aren't any, it's safe to cheaply initialize the
297  * cached offsets for these attrs.
298  */
299  if (IndexTupleHasVarwidths(tup))
300  {
301  int j;
302 
303  for (j = 0; j <= attnum; j++)
304  {
305  if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
306  {
307  slow = true;
308  break;
309  }
310  }
311  }
312  }
313 
314  if (!slow)
315  {
316  int natts = tupleDesc->natts;
317  int j = 1;
318 
319  /*
320  * If we get here, we have a tuple with no nulls or var-widths up to
321  * and including the target attribute, so we can use the cached offset
322  * ... only we don't have it yet, or we'd not have got here. Since
323  * it's cheap to compute offsets for fixed-width columns, we take the
324  * opportunity to initialize the cached offsets for *all* the leading
325  * fixed-width columns, in hope of avoiding future visits to this
326  * routine.
327  */
328  TupleDescAttr(tupleDesc, 0)->attcacheoff = 0;
329 
330  /* we might have set some offsets in the slow path previously */
331  while (j < natts && TupleDescAttr(tupleDesc, j)->attcacheoff > 0)
332  j++;
333 
334  off = TupleDescAttr(tupleDesc, j - 1)->attcacheoff +
335  TupleDescAttr(tupleDesc, j - 1)->attlen;
336 
337  for (; j < natts; j++)
338  {
339  Form_pg_attribute att = TupleDescAttr(tupleDesc, j);
340 
341  if (att->attlen <= 0)
342  break;
343 
344  off = att_align_nominal(off, att->attalign);
345 
346  att->attcacheoff = off;
347 
348  off += att->attlen;
349  }
350 
351  Assert(j > attnum);
352 
353  off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
354  }
355  else
356  {
357  bool usecache = true;
358  int i;
359 
360  /*
361  * Now we know that we have to walk the tuple CAREFULLY. But we still
362  * might be able to cache some offsets for next time.
363  *
364  * Note - This loop is a little tricky. For each non-null attribute,
365  * we have to first account for alignment padding before the attr,
366  * then advance over the attr based on its length. Nulls have no
367  * storage and no alignment padding either. We can use/set
368  * attcacheoff until we reach either a null or a var-width attribute.
369  */
370  off = 0;
371  for (i = 0;; i++) /* loop exit is at "break" */
372  {
373  Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
374 
375  if (IndexTupleHasNulls(tup) && att_isnull(i, bp))
376  {
377  usecache = false;
378  continue; /* this cannot be the target att */
379  }
380 
381  /* If we know the next offset, we can skip the rest */
382  if (usecache && att->attcacheoff >= 0)
383  off = att->attcacheoff;
384  else if (att->attlen == -1)
385  {
386  /*
387  * We can only cache the offset for a varlena attribute if the
388  * offset is already suitably aligned, so that there would be
389  * no pad bytes in any case: then the offset will be valid for
390  * either an aligned or unaligned value.
391  */
392  if (usecache &&
393  off == att_align_nominal(off, att->attalign))
394  att->attcacheoff = off;
395  else
396  {
397  off = att_align_pointer(off, att->attalign, -1,
398  tp + off);
399  usecache = false;
400  }
401  }
402  else
403  {
404  /* not varlena, so safe to use att_align_nominal */
405  off = att_align_nominal(off, att->attalign);
406 
407  if (usecache)
408  att->attcacheoff = off;
409  }
410 
411  if (i == attnum)
412  break;
413 
414  off = att_addlength_pointer(off, att->attlen, tp + off);
415 
416  if (usecache && att->attlen <= 0)
417  usecache = false;
418  }
419  }
420 
421  return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
422 }
#define IndexInfoFindDataOffset(t_info)
Definition: itup.h:80
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:148
#define att_isnull(ATT, BITS)
Definition: tupmacs.h:25
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define IndexTupleHasNulls(itup)
Definition: itup.h:72
#define fetchatt(A, T)
Definition: tupmacs.h:41
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:176
#define byte(x, n)
Definition: rijndael.c:68
int16 attlen
Definition: pg_attribute.h:64
uint8 bits8
Definition: c.h:436
struct IndexTupleData IndexTupleData
#define att_align_pointer(cur_offset, attalign, attlen, attptr)
Definition: tupmacs.h:126
int16 attnum
Definition: pg_attribute.h:79
#define Assert(condition)
Definition: c.h:800
#define IndexTupleHasVarwidths(itup)
Definition: itup.h:73
int i
unsigned short t_info
Definition: itup.h:49