PostgreSQL Source Code  git master
brin_tuple.c File Reference
#include "postgres.h"
#include "access/brin_tuple.h"
#include "access/detoast.h"
#include "access/heaptoast.h"
#include "access/htup_details.h"
#include "access/toast_internals.h"
#include "access/tupdesc.h"
#include "access/tupmacs.h"
#include "utils/datum.h"
#include "utils/memutils.h"
Include dependency graph for brin_tuple.c:

Go to the source code of this file.

Macros

#define TOAST_INDEX_HACK
 

Functions

static void brin_deconstruct_tuple (BrinDesc *brdesc, char *tp, bits8 *nullbits, bool nulls, Datum *values, bool *allnulls, bool *hasnulls)
 
static TupleDesc brtuple_disk_tupdesc (BrinDesc *brdesc)
 
BrinTuplebrin_form_tuple (BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple, Size *size)
 
BrinTuplebrin_form_placeholder_tuple (BrinDesc *brdesc, BlockNumber blkno, Size *size)
 
void brin_free_tuple (BrinTuple *tuple)
 
BrinTuplebrin_copy_tuple (BrinTuple *tuple, Size len, BrinTuple *dest, Size *destsz)
 
bool brin_tuples_equal (const BrinTuple *a, Size alen, const BrinTuple *b, Size blen)
 
BrinMemTuplebrin_new_memtuple (BrinDesc *brdesc)
 
BrinMemTuplebrin_memtuple_initialize (BrinMemTuple *dtuple, BrinDesc *brdesc)
 
BrinMemTuplebrin_deform_tuple (BrinDesc *brdesc, BrinTuple *tuple, BrinMemTuple *dMemtuple)
 

Macro Definition Documentation

◆ TOAST_INDEX_HACK

#define TOAST_INDEX_HACK

Definition at line 49 of file brin_tuple.c.

Function Documentation

◆ brin_copy_tuple()

BrinTuple* brin_copy_tuple ( BrinTuple tuple,
Size  len,
BrinTuple dest,
Size destsz 
)

Definition at line 446 of file brin_tuple.c.

447 {
448  if (!destsz || *destsz == 0)
449  dest = palloc(len);
450  else if (len > *destsz)
451  {
452  dest = repalloc(dest, len);
453  *destsz = len;
454  }
455 
456  memcpy(dest, tuple, len);
457 
458  return dest;
459 }
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1541
void * palloc(Size size)
Definition: mcxt.c:1317
const void size_t len

References generate_unaccent_rules::dest, len, palloc(), and repalloc().

Referenced by brin_evacuate_page(), bringetbitmap(), brininsert(), and summarize_range().

◆ brin_deconstruct_tuple()

static void brin_deconstruct_tuple ( BrinDesc brdesc,
char *  tp,
bits8 nullbits,
bool  nulls,
Datum values,
bool allnulls,
bool hasnulls 
)
inlinestatic

Definition at line 645 of file brin_tuple.c.

648 {
649  int attnum;
650  int stored;
651  TupleDesc diskdsc;
652  long off;
653 
654  /*
655  * First iterate to natts to obtain both null flags for each attribute.
656  * Note that we reverse the sense of the att_isnull test, because we store
657  * 1 for a null value (rather than a 1 for a not null value as is the
658  * att_isnull convention used elsewhere.) See brin_form_tuple.
659  */
660  for (attnum = 0; attnum < brdesc->bd_tupdesc->natts; attnum++)
661  {
662  /*
663  * the "all nulls" bit means that all values in the page range for
664  * this column are nulls. Therefore there are no values in the tuple
665  * data area.
666  */
667  allnulls[attnum] = nulls && !att_isnull(attnum, nullbits);
668 
669  /*
670  * the "has nulls" bit means that some tuples have nulls, but others
671  * have not-null values. Therefore we know the tuple contains data
672  * for this column.
673  *
674  * The hasnulls bits follow the allnulls bits in the same bitmask.
675  */
676  hasnulls[attnum] =
677  nulls && !att_isnull(brdesc->bd_tupdesc->natts + attnum, nullbits);
678  }
679 
680  /*
681  * Iterate to obtain each attribute's stored values. Note that since we
682  * may reuse attribute entries for more than one column, we cannot cache
683  * offsets here.
684  */
685  diskdsc = brtuple_disk_tupdesc(brdesc);
686  stored = 0;
687  off = 0;
688  for (attnum = 0; attnum < brdesc->bd_tupdesc->natts; attnum++)
689  {
690  int datumno;
691 
692  if (allnulls[attnum])
693  {
694  stored += brdesc->bd_info[attnum]->oi_nstored;
695  continue;
696  }
697 
698  for (datumno = 0;
699  datumno < brdesc->bd_info[attnum]->oi_nstored;
700  datumno++)
701  {
702  Form_pg_attribute thisatt = TupleDescAttr(diskdsc, stored);
703 
704  if (thisatt->attlen == -1)
705  {
706  off = att_align_pointer(off, thisatt->attalign, -1,
707  tp + off);
708  }
709  else
710  {
711  /* not varlena, so safe to use att_align_nominal */
712  off = att_align_nominal(off, thisatt->attalign);
713  }
714 
715  values[stored++] = fetchatt(thisatt, tp + off);
716 
717  off = att_addlength_pointer(off, thisatt->attlen, tp + off);
718  }
719  }
720 }
static Datum values[MAXATTR]
Definition: bootstrap.c:150
static TupleDesc brtuple_disk_tupdesc(BrinDesc *brdesc)
Definition: brin_tuple.c:61
int16 attnum
Definition: pg_attribute.h:74
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
TupleDesc bd_tupdesc
Definition: brin_internal.h:53
BrinOpcInfo * bd_info[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_internal.h:62
uint16 oi_nstored
Definition: brin_internal.h:28
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define att_align_pointer(cur_offset, attalign, attlen, attptr)
Definition: tupmacs.h:107
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:129
static bool att_isnull(int ATT, const bits8 *BITS)
Definition: tupmacs.h:26
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:157
#define fetchatt(A, T)
Definition: tupmacs.h:46

References att_addlength_pointer, att_align_nominal, att_align_pointer, att_isnull(), attnum, BrinDesc::bd_info, BrinDesc::bd_tupdesc, brtuple_disk_tupdesc(), fetchatt, TupleDescData::natts, BrinOpcInfo::oi_nstored, TupleDescAttr, and values.

Referenced by brin_deform_tuple().

◆ brin_deform_tuple()

BrinMemTuple* brin_deform_tuple ( BrinDesc brdesc,
BrinTuple tuple,
BrinMemTuple dMemtuple 
)

Definition at line 553 of file brin_tuple.c.

554 {
555  BrinMemTuple *dtup;
556  Datum *values;
557  bool *allnulls;
558  bool *hasnulls;
559  char *tp;
560  bits8 *nullbits;
561  int keyno;
562  int valueno;
563  MemoryContext oldcxt;
564 
565  dtup = dMemtuple ? brin_memtuple_initialize(dMemtuple, brdesc) :
566  brin_new_memtuple(brdesc);
567 
568  if (BrinTupleIsPlaceholder(tuple))
569  dtup->bt_placeholder = true;
570 
571  /* ranges start as empty, depends on the BrinTuple */
572  if (!BrinTupleIsEmptyRange(tuple))
573  dtup->bt_empty_range = false;
574 
575  dtup->bt_blkno = tuple->bt_blkno;
576 
577  values = dtup->bt_values;
578  allnulls = dtup->bt_allnulls;
579  hasnulls = dtup->bt_hasnulls;
580 
581  tp = (char *) tuple + BrinTupleDataOffset(tuple);
582 
583  if (BrinTupleHasNulls(tuple))
584  nullbits = (bits8 *) ((char *) tuple + SizeOfBrinTuple);
585  else
586  nullbits = NULL;
587  brin_deconstruct_tuple(brdesc,
588  tp, nullbits, BrinTupleHasNulls(tuple),
589  values, allnulls, hasnulls);
590 
591  /*
592  * Iterate to assign each of the values to the corresponding item in the
593  * values array of each column. The copies occur in the tuple's context.
594  */
595  oldcxt = MemoryContextSwitchTo(dtup->bt_context);
596  for (valueno = 0, keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
597  {
598  int i;
599 
600  if (allnulls[keyno])
601  {
602  valueno += brdesc->bd_info[keyno]->oi_nstored;
603  continue;
604  }
605 
606  /*
607  * We would like to skip datumCopy'ing the values datum in some cases,
608  * caller permitting ...
609  */
610  for (i = 0; i < brdesc->bd_info[keyno]->oi_nstored; i++)
611  dtup->bt_columns[keyno].bv_values[i] =
612  datumCopy(values[valueno++],
613  brdesc->bd_info[keyno]->oi_typcache[i]->typbyval,
614  brdesc->bd_info[keyno]->oi_typcache[i]->typlen);
615 
616  dtup->bt_columns[keyno].bv_hasnulls = hasnulls[keyno];
617  dtup->bt_columns[keyno].bv_allnulls = false;
618 
619  dtup->bt_columns[keyno].bv_mem_value = PointerGetDatum(NULL);
620  dtup->bt_columns[keyno].bv_serialize = NULL;
621  dtup->bt_columns[keyno].bv_context = dtup->bt_context;
622  }
623 
624  MemoryContextSwitchTo(oldcxt);
625 
626  return dtup;
627 }
BrinMemTuple * brin_new_memtuple(BrinDesc *brdesc)
Definition: brin_tuple.c:482
BrinMemTuple * brin_memtuple_initialize(BrinMemTuple *dtuple, BrinDesc *brdesc)
Definition: brin_tuple.c:511
static void brin_deconstruct_tuple(BrinDesc *brdesc, char *tp, bits8 *nullbits, bool nulls, Datum *values, bool *allnulls, bool *hasnulls)
Definition: brin_tuple.c:645
#define BrinTupleIsEmptyRange(tup)
Definition: brin_tuple.h:93
#define BrinTupleDataOffset(tup)
Definition: brin_tuple.h:90
#define BrinTupleIsPlaceholder(tup)
Definition: brin_tuple.h:92
#define SizeOfBrinTuple
Definition: brin_tuple.h:80
#define BrinTupleHasNulls(tup)
Definition: brin_tuple.h:91
uint8 bits8
Definition: c.h:524
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:132
int i
Definition: isn.c:72
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
MemoryContextSwitchTo(old_ctx)
bool * bt_allnulls
Definition: brin_tuple.h:52
BrinValues bt_columns[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_tuple.h:55
MemoryContext bt_context
Definition: brin_tuple.h:49
BlockNumber bt_blkno
Definition: brin_tuple.h:48
Datum * bt_values
Definition: brin_tuple.h:51
bool * bt_hasnulls
Definition: brin_tuple.h:53
bool bt_placeholder
Definition: brin_tuple.h:46
bool bt_empty_range
Definition: brin_tuple.h:47
TypeCacheEntry * oi_typcache[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_internal.h:37
BlockNumber bt_blkno
Definition: brin_tuple.h:66
MemoryContext bv_context
Definition: brin_tuple.h:36
bool bv_hasnulls
Definition: brin_tuple.h:32
Datum bv_mem_value
Definition: brin_tuple.h:35
brin_serialize_callback_type bv_serialize
Definition: brin_tuple.h:37
Datum * bv_values
Definition: brin_tuple.h:34
bool bv_allnulls
Definition: brin_tuple.h:33
bool typbyval
Definition: typcache.h:40
int16 typlen
Definition: typcache.h:39

References BrinDesc::bd_info, BrinDesc::bd_tupdesc, brin_deconstruct_tuple(), brin_memtuple_initialize(), brin_new_memtuple(), BrinTupleDataOffset, BrinTupleHasNulls, BrinTupleIsEmptyRange, BrinTupleIsPlaceholder, BrinMemTuple::bt_allnulls, BrinMemTuple::bt_blkno, BrinTuple::bt_blkno, BrinMemTuple::bt_columns, BrinMemTuple::bt_context, BrinMemTuple::bt_empty_range, BrinMemTuple::bt_hasnulls, BrinMemTuple::bt_placeholder, BrinMemTuple::bt_values, BrinValues::bv_allnulls, BrinValues::bv_context, BrinValues::bv_hasnulls, BrinValues::bv_mem_value, BrinValues::bv_serialize, BrinValues::bv_values, datumCopy(), i, MemoryContextSwitchTo(), TupleDescData::natts, BrinOpcInfo::oi_nstored, BrinOpcInfo::oi_typcache, PointerGetDatum(), SizeOfBrinTuple, TypeCacheEntry::typbyval, TypeCacheEntry::typlen, and values.

Referenced by _brin_parallel_merge(), brin_page_items(), bringetbitmap(), brininsert(), and union_tuples().

◆ brin_form_placeholder_tuple()

BrinTuple* brin_form_placeholder_tuple ( BrinDesc brdesc,
BlockNumber  blkno,
Size size 
)

Definition at line 388 of file brin_tuple.c.

389 {
390  Size len;
391  Size hoff;
392  BrinTuple *rettuple;
393  int keyno;
394  bits8 *bitP;
395  int bitmask;
396 
397  /* compute total space needed: always add nulls */
399  len += BITMAPLEN(brdesc->bd_tupdesc->natts * 2);
400  len = hoff = MAXALIGN(len);
401 
402  rettuple = palloc0(len);
403  rettuple->bt_blkno = blkno;
404  rettuple->bt_info = hoff;
406 
407  bitP = ((bits8 *) ((char *) rettuple + SizeOfBrinTuple)) - 1;
408  bitmask = HIGHBIT;
409  /* set allnulls true for all attributes */
410  for (keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
411  {
412  if (bitmask != HIGHBIT)
413  bitmask <<= 1;
414  else
415  {
416  bitP += 1;
417  *bitP = 0x0;
418  bitmask = 1;
419  }
420 
421  *bitP |= bitmask;
422  }
423  /* no need to set hasnulls */
424 
425  *size = len;
426  return rettuple;
427 }
#define BRIN_EMPTY_RANGE_MASK
Definition: brin_tuple.h:86
#define BRIN_PLACEHOLDER_MASK
Definition: brin_tuple.h:87
#define BRIN_NULLS_MASK
Definition: brin_tuple.h:88
#define MAXALIGN(LEN)
Definition: c.h:814
#define HIGHBIT
Definition: c.h:1157
size_t Size
Definition: c.h:608
#define BITMAPLEN(NATTS)
Definition: htup_details.h:545
void * palloc0(Size size)
Definition: mcxt.c:1347
static pg_noinline void Size size
Definition: slab.c:607
uint8 bt_info
Definition: brin_tuple.h:77

References BrinDesc::bd_tupdesc, BITMAPLEN, BRIN_EMPTY_RANGE_MASK, BRIN_NULLS_MASK, BRIN_PLACEHOLDER_MASK, BrinTuple::bt_blkno, BrinTuple::bt_info, HIGHBIT, len, MAXALIGN, TupleDescData::natts, palloc0(), size, and SizeOfBrinTuple.

Referenced by summarize_range().

◆ brin_form_tuple()

BrinTuple* brin_form_tuple ( BrinDesc brdesc,
BlockNumber  blkno,
BrinMemTuple tuple,
Size size 
)

Definition at line 99 of file brin_tuple.c.

101 {
102  Datum *values;
103  bool *nulls;
104  bool anynulls = false;
105  BrinTuple *rettuple;
106  int keyno;
107  int idxattno;
108  uint16 phony_infomask = 0;
109  bits8 *phony_nullbitmap;
110  Size len,
111  hoff,
112  data_len;
113  int i;
114 
115 #ifdef TOAST_INDEX_HACK
116  Datum *untoasted_values;
117  int nuntoasted = 0;
118 #endif
119 
120  Assert(brdesc->bd_totalstored > 0);
121 
122  values = (Datum *) palloc(sizeof(Datum) * brdesc->bd_totalstored);
123  nulls = (bool *) palloc0(sizeof(bool) * brdesc->bd_totalstored);
124  phony_nullbitmap = (bits8 *)
125  palloc(sizeof(bits8) * BITMAPLEN(brdesc->bd_totalstored));
126 
127 #ifdef TOAST_INDEX_HACK
128  untoasted_values = (Datum *) palloc(sizeof(Datum) * brdesc->bd_totalstored);
129 #endif
130 
131  /*
132  * Set up the values/nulls arrays for heap_fill_tuple
133  */
134  idxattno = 0;
135  for (keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
136  {
137  int datumno;
138 
139  /*
140  * "allnulls" is set when there's no nonnull value in any row in the
141  * column; when this happens, there is no data to store. Thus set the
142  * nullable bits for all data elements of this column and we're done.
143  */
144  if (tuple->bt_columns[keyno].bv_allnulls)
145  {
146  for (datumno = 0;
147  datumno < brdesc->bd_info[keyno]->oi_nstored;
148  datumno++)
149  nulls[idxattno++] = true;
150  anynulls = true;
151  continue;
152  }
153 
154  /*
155  * The "hasnulls" bit is set when there are some null values in the
156  * data. We still need to store a real value, but the presence of
157  * this means we need a null bitmap.
158  */
159  if (tuple->bt_columns[keyno].bv_hasnulls)
160  anynulls = true;
161 
162  /* If needed, serialize the values before forming the on-disk tuple. */
163  if (tuple->bt_columns[keyno].bv_serialize)
164  {
165  tuple->bt_columns[keyno].bv_serialize(brdesc,
166  tuple->bt_columns[keyno].bv_mem_value,
167  tuple->bt_columns[keyno].bv_values);
168  }
169 
170  /*
171  * Now obtain the values of each stored datum. Note that some values
172  * might be toasted, and we cannot rely on the original heap values
173  * sticking around forever, so we must detoast them. Also try to
174  * compress them.
175  */
176  for (datumno = 0;
177  datumno < brdesc->bd_info[keyno]->oi_nstored;
178  datumno++)
179  {
180  Datum value = tuple->bt_columns[keyno].bv_values[datumno];
181 
182 #ifdef TOAST_INDEX_HACK
183 
184  /* We must look at the stored type, not at the index descriptor. */
185  TypeCacheEntry *atttype = brdesc->bd_info[keyno]->oi_typcache[datumno];
186 
187  /* Do we need to free the value at the end? */
188  bool free_value = false;
189 
190  /* For non-varlena types we don't need to do anything special */
191  if (atttype->typlen != -1)
192  {
193  values[idxattno++] = value;
194  continue;
195  }
196 
197  /*
198  * Do nothing if value is not of varlena type. We don't need to
199  * care about NULL values here, thanks to bv_allnulls above.
200  *
201  * If value is stored EXTERNAL, must fetch it so we are not
202  * depending on outside storage.
203  *
204  * XXX Is this actually true? Could it be that the summary is NULL
205  * even for range with non-NULL data? E.g. degenerate bloom filter
206  * may be thrown away, etc.
207  */
209  {
212  free_value = true;
213  }
214 
215  /*
216  * If value is above size target, and is of a compressible
217  * datatype, try to compress it in-line.
218  */
221  (atttype->typstorage == TYPSTORAGE_EXTENDED ||
222  atttype->typstorage == TYPSTORAGE_MAIN))
223  {
224  Datum cvalue;
225  char compression;
227  keyno);
228 
229  /*
230  * If the BRIN summary and indexed attribute use the same data
231  * type and it has a valid compression method, we can use the
232  * same compression method. Otherwise we have to use the
233  * default method.
234  */
235  if (att->atttypid == atttype->type_id)
236  compression = att->attcompression;
237  else
238  compression = InvalidCompressionMethod;
239 
240  cvalue = toast_compress_datum(value, compression);
241 
242  if (DatumGetPointer(cvalue) != NULL)
243  {
244  /* successful compression */
245  if (free_value)
247 
248  value = cvalue;
249  free_value = true;
250  }
251  }
252 
253  /*
254  * If we untoasted / compressed the value, we need to free it
255  * after forming the index tuple.
256  */
257  if (free_value)
258  untoasted_values[nuntoasted++] = value;
259 
260 #endif
261 
262  values[idxattno++] = value;
263  }
264  }
265 
266  /* Assert we did not overrun temp arrays */
267  Assert(idxattno <= brdesc->bd_totalstored);
268 
269  /* compute total space needed */
271  if (anynulls)
272  {
273  /*
274  * We need a double-length bitmap on an on-disk BRIN index tuple; the
275  * first half stores the "allnulls" bits, the second stores
276  * "hasnulls".
277  */
278  len += BITMAPLEN(brdesc->bd_tupdesc->natts * 2);
279  }
280 
281  len = hoff = MAXALIGN(len);
282 
283  data_len = heap_compute_data_size(brtuple_disk_tupdesc(brdesc),
284  values, nulls);
285  len += data_len;
286 
287  len = MAXALIGN(len);
288 
289  rettuple = palloc0(len);
290  rettuple->bt_blkno = blkno;
291  rettuple->bt_info = hoff;
292 
293  /* Assert that hoff fits in the space available */
294  Assert((rettuple->bt_info & BRIN_OFFSET_MASK) == hoff);
295 
296  /*
297  * The infomask and null bitmap as computed by heap_fill_tuple are useless
298  * to us. However, that function will not accept a null infomask; and we
299  * need to pass a valid null bitmap so that it will correctly skip
300  * outputting null attributes in the data area.
301  */
303  values,
304  nulls,
305  (char *) rettuple + hoff,
306  data_len,
307  &phony_infomask,
308  phony_nullbitmap);
309 
310  /* done with these */
311  pfree(values);
312  pfree(nulls);
313  pfree(phony_nullbitmap);
314 
315 #ifdef TOAST_INDEX_HACK
316  for (i = 0; i < nuntoasted; i++)
317  pfree(DatumGetPointer(untoasted_values[i]));
318 #endif
319 
320  /*
321  * Now fill in the real null bitmasks. allnulls first.
322  */
323  if (anynulls)
324  {
325  bits8 *bitP;
326  int bitmask;
327 
328  rettuple->bt_info |= BRIN_NULLS_MASK;
329 
330  /*
331  * Note that we reverse the sense of null bits in this module: we
332  * store a 1 for a null attribute rather than a 0. So we must reverse
333  * the sense of the att_isnull test in brin_deconstruct_tuple as well.
334  */
335  bitP = ((bits8 *) ((char *) rettuple + SizeOfBrinTuple)) - 1;
336  bitmask = HIGHBIT;
337  for (keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
338  {
339  if (bitmask != HIGHBIT)
340  bitmask <<= 1;
341  else
342  {
343  bitP += 1;
344  *bitP = 0x0;
345  bitmask = 1;
346  }
347 
348  if (!tuple->bt_columns[keyno].bv_allnulls)
349  continue;
350 
351  *bitP |= bitmask;
352  }
353  /* hasnulls bits follow */
354  for (keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
355  {
356  if (bitmask != HIGHBIT)
357  bitmask <<= 1;
358  else
359  {
360  bitP += 1;
361  *bitP = 0x0;
362  bitmask = 1;
363  }
364 
365  if (!tuple->bt_columns[keyno].bv_hasnulls)
366  continue;
367 
368  *bitP |= bitmask;
369  }
370  }
371 
372  if (tuple->bt_placeholder)
373  rettuple->bt_info |= BRIN_PLACEHOLDER_MASK;
374 
375  if (tuple->bt_empty_range)
376  rettuple->bt_info |= BRIN_EMPTY_RANGE_MASK;
377 
378  *size = len;
379  return rettuple;
380 }
#define BRIN_OFFSET_MASK
Definition: brin_tuple.h:85
unsigned short uint16
Definition: c.h:517
#define Assert(condition)
Definition: c.h:861
struct varlena * detoast_external_attr(struct varlena *attr)
Definition: detoast.c:45
#define TOAST_INDEX_TARGET
Definition: heaptoast.h:68
Size heap_compute_data_size(TupleDesc tupleDesc, const Datum *values, const bool *isnull)
Definition: heaptuple.c:215
void heap_fill_tuple(TupleDesc tupleDesc, const Datum *values, const bool *isnull, char *data, Size data_size, uint16 *infomask, bits8 *bit)
Definition: heaptuple.c:400
static struct @160 value
void pfree(void *pointer)
Definition: mcxt.c:1521
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
int bd_totalstored
Definition: brin_internal.h:59
char typstorage
Definition: typcache.h:42
Definition: c.h:690
#define InvalidCompressionMethod
Datum toast_compress_datum(Datum value, char cmethod)
#define VARATT_IS_EXTENDED(PTR)
Definition: varatt.h:303
#define VARSIZE(PTR)
Definition: varatt.h:279
#define VARATT_IS_EXTERNAL(PTR)
Definition: varatt.h:289

References Assert, BrinDesc::bd_info, BrinDesc::bd_totalstored, BrinDesc::bd_tupdesc, BITMAPLEN, BRIN_EMPTY_RANGE_MASK, BRIN_NULLS_MASK, BRIN_OFFSET_MASK, BRIN_PLACEHOLDER_MASK, brtuple_disk_tupdesc(), BrinTuple::bt_blkno, BrinMemTuple::bt_columns, BrinMemTuple::bt_empty_range, BrinTuple::bt_info, BrinMemTuple::bt_placeholder, BrinValues::bv_allnulls, BrinValues::bv_hasnulls, BrinValues::bv_mem_value, BrinValues::bv_serialize, BrinValues::bv_values, DatumGetPointer(), detoast_external_attr(), heap_compute_data_size(), heap_fill_tuple(), HIGHBIT, i, InvalidCompressionMethod, len, MAXALIGN, TupleDescData::natts, BrinOpcInfo::oi_nstored, BrinOpcInfo::oi_typcache, palloc(), palloc0(), pfree(), PointerGetDatum(), size, SizeOfBrinTuple, toast_compress_datum(), TOAST_INDEX_TARGET, TupleDescAttr, TypeCacheEntry::type_id, TypeCacheEntry::typlen, TypeCacheEntry::typstorage, value, values, VARATT_IS_EXTENDED, VARATT_IS_EXTERNAL, and VARSIZE.

Referenced by _brin_parallel_merge(), brin_build_empty_tuple(), brininsert(), form_and_insert_tuple(), form_and_spill_tuple(), and summarize_range().

◆ brin_free_tuple()

void brin_free_tuple ( BrinTuple tuple)

Definition at line 433 of file brin_tuple.c.

434 {
435  pfree(tuple);
436 }

References pfree().

Referenced by summarize_range().

◆ brin_memtuple_initialize()

BrinMemTuple* brin_memtuple_initialize ( BrinMemTuple dtuple,
BrinDesc brdesc 
)

Definition at line 511 of file brin_tuple.c.

512 {
513  int i;
514  char *currdatum;
515 
517 
518  currdatum = (char *) dtuple +
519  MAXALIGN(sizeof(BrinMemTuple) +
520  sizeof(BrinValues) * brdesc->bd_tupdesc->natts);
521  for (i = 0; i < brdesc->bd_tupdesc->natts; i++)
522  {
523  dtuple->bt_columns[i].bv_attno = i + 1;
524  dtuple->bt_columns[i].bv_allnulls = true;
525  dtuple->bt_columns[i].bv_hasnulls = false;
526  dtuple->bt_columns[i].bv_values = (Datum *) currdatum;
527 
528  dtuple->bt_columns[i].bv_mem_value = PointerGetDatum(NULL);
529  dtuple->bt_columns[i].bv_serialize = NULL;
530  dtuple->bt_columns[i].bv_context = dtuple->bt_context;
531 
532  currdatum += sizeof(Datum) * brdesc->bd_info[i]->oi_nstored;
533  }
534 
535  dtuple->bt_empty_range = true;
536 
537  return dtuple;
538 }
struct BrinValues BrinValues
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:383
AttrNumber bv_attno
Definition: brin_tuple.h:31

References BrinDesc::bd_info, BrinDesc::bd_tupdesc, BrinMemTuple::bt_columns, BrinMemTuple::bt_context, BrinMemTuple::bt_empty_range, BrinValues::bv_allnulls, BrinValues::bv_attno, BrinValues::bv_context, BrinValues::bv_hasnulls, BrinValues::bv_mem_value, BrinValues::bv_serialize, BrinValues::bv_values, i, MAXALIGN, MemoryContextReset(), TupleDescData::natts, BrinOpcInfo::oi_nstored, and PointerGetDatum().

Referenced by brin_deform_tuple(), brin_new_memtuple(), brinbuildCallback(), brinbuildCallbackParallel(), and brinsummarize().

◆ brin_new_memtuple()

BrinMemTuple* brin_new_memtuple ( BrinDesc brdesc)

Definition at line 482 of file brin_tuple.c.

483 {
484  BrinMemTuple *dtup;
485  long basesize;
486 
487  basesize = MAXALIGN(sizeof(BrinMemTuple) +
488  sizeof(BrinValues) * brdesc->bd_tupdesc->natts);
489  dtup = palloc0(basesize + sizeof(Datum) * brdesc->bd_totalstored);
490 
491  dtup->bt_values = palloc(sizeof(Datum) * brdesc->bd_totalstored);
492  dtup->bt_allnulls = palloc(sizeof(bool) * brdesc->bd_tupdesc->natts);
493  dtup->bt_hasnulls = palloc(sizeof(bool) * brdesc->bd_tupdesc->natts);
494 
495  dtup->bt_empty_range = true;
496 
498  "brin dtuple",
500 
501  brin_memtuple_initialize(dtup, brdesc);
502 
503  return dtup;
504 }
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, BrinDesc::bd_totalstored, BrinDesc::bd_tupdesc, brin_memtuple_initialize(), BrinMemTuple::bt_allnulls, BrinMemTuple::bt_context, BrinMemTuple::bt_empty_range, BrinMemTuple::bt_hasnulls, BrinMemTuple::bt_values, CurrentMemoryContext, MAXALIGN, TupleDescData::natts, palloc(), and palloc0().

Referenced by _brin_parallel_merge(), brin_build_empty_tuple(), brin_deform_tuple(), bringetbitmap(), and initialize_brin_buildstate().

◆ brin_tuples_equal()

bool brin_tuples_equal ( const BrinTuple a,
Size  alen,
const BrinTuple b,
Size  blen 
)

Definition at line 465 of file brin_tuple.c.

466 {
467  if (alen != blen)
468  return false;
469  if (memcmp(a, b, alen) != 0)
470  return false;
471  return true;
472 }
int b
Definition: isn.c:69
int a
Definition: isn.c:68

References a, and b.

Referenced by brin_doupdate().

◆ brtuple_disk_tupdesc()

static TupleDesc brtuple_disk_tupdesc ( BrinDesc brdesc)
static

Definition at line 61 of file brin_tuple.c.

62 {
63  /* We cache these in the BrinDesc */
64  if (brdesc->bd_disktdesc == NULL)
65  {
66  int i;
67  int j;
68  AttrNumber attno = 1;
69  TupleDesc tupdesc;
70  MemoryContext oldcxt;
71 
72  /* make sure it's in the bdesc's context */
73  oldcxt = MemoryContextSwitchTo(brdesc->bd_context);
74 
75  tupdesc = CreateTemplateTupleDesc(brdesc->bd_totalstored);
76 
77  for (i = 0; i < brdesc->bd_tupdesc->natts; i++)
78  {
79  for (j = 0; j < brdesc->bd_info[i]->oi_nstored; j++)
80  TupleDescInitEntry(tupdesc, attno++, NULL,
81  brdesc->bd_info[i]->oi_typcache[j]->type_id,
82  -1, 0);
83  }
84 
85  MemoryContextSwitchTo(oldcxt);
86 
87  brdesc->bd_disktdesc = tupdesc;
88  }
89 
90  return brdesc->bd_disktdesc;
91 }
int16 AttrNumber
Definition: attnum.h:21
int j
Definition: isn.c:73
MemoryContext bd_context
Definition: brin_internal.h:47
TupleDesc bd_disktdesc
Definition: brin_internal.h:56
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:67
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:651

References BrinDesc::bd_context, BrinDesc::bd_disktdesc, BrinDesc::bd_info, BrinDesc::bd_totalstored, BrinDesc::bd_tupdesc, CreateTemplateTupleDesc(), i, j, MemoryContextSwitchTo(), TupleDescData::natts, BrinOpcInfo::oi_nstored, BrinOpcInfo::oi_typcache, TupleDescInitEntry(), and TypeCacheEntry::type_id.

Referenced by brin_deconstruct_tuple(), and brin_form_tuple().