PostgreSQL Source Code git master
Macros | Functions
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)
 
BrinTuple *  brin_form_tuple (BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple, Size *size)
 
BrinTuple *  brin_form_placeholder_tuple (BrinDesc *brdesc, BlockNumber blkno, Size *size)
 
void  brin_free_tuple (BrinTuple *tuple)
 
BrinTuple *  brin_copy_tuple (BrinTuple *tuple, Size len, BrinTuple *dest, Size *destsz)
 
bool  brin_tuples_equal (const BrinTuple *a, Size alen, const BrinTuple *b, Size blen)
 
BrinMemTuple *  brin_new_memtuple (BrinDesc *brdesc)
 
BrinMemTuple *  brin_memtuple_initialize (BrinMemTuple *dtuple, BrinDesc *brdesc)
 
BrinMemTuple *  brin_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:1610
void * palloc(Size size)
Definition: mcxt.c:1365
dest
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 CompactAttribute *thisatt = TupleDescCompactAttr(diskdsc, stored);
703
704 if (thisatt->attlen == -1)
705 {
706 off = att_pointer_alignby(off,
707 thisatt->attalignby,
708 -1,
709 tp + off);
710 }
711 else
712 {
713 /* not varlena, so safe to use att_nominal_alignby */
714 off = att_nominal_alignby(off, thisatt->attalignby);
715 }
716
717 values[stored++] = fetchatt(thisatt, tp + off);
718
719 off = att_addlength_pointer(off, thisatt->attlen, tp + off);
720 }
721 }
722}
static Datum values[MAXATTR]
Definition: bootstrap.c:153
static TupleDesc brtuple_disk_tupdesc(BrinDesc *brdesc)
Definition: brin_tuple.c:61
int16 attnum
Definition: pg_attribute.h:74
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
uint8 attalignby
Definition: tupdesc.h:80
int16 attlen
Definition: tupdesc.h:71
int natts
Definition: tupdesc.h:137
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:175
#define att_nominal_alignby(cur_offset, attalignby)
Definition: tupmacs.h:160
static bool att_isnull(int ATT, const bits8 *BITS)
Definition: tupmacs.h:26
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:180
#define att_pointer_alignby(cur_offset, attalignby, attlen, attptr)
Definition: tupmacs.h:124
#define fetchatt(A, T)
Definition: tupmacs.h:44

References att_addlength_pointer, att_isnull(), att_nominal_alignby, att_pointer_alignby, CompactAttribute::attalignby, CompactAttribute::attlen, attnum, BrinDesc::bd_info, BrinDesc::bd_tupdesc, brtuple_disk_tupdesc(), fetchatt, TupleDescData::natts, BrinOpcInfo::oi_nstored, TupleDescCompactAttr(), 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;
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}
static void brin_deconstruct_tuple(BrinDesc *brdesc, char *tp, bits8 *nullbits, bool nulls, Datum *values, bool *allnulls, bool *hasnulls)
Definition: brin_tuple.c:645
BrinMemTuple * brin_new_memtuple(BrinDesc *brdesc)
Definition: brin_tuple.c:482
BrinMemTuple * brin_memtuple_initialize(BrinMemTuple *dtuple, BrinDesc *brdesc)
Definition: brin_tuple.c:511
#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:545
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:132
i
int i
Definition: isn.c:77
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
uint64_t Datum
Definition: postgres.h:70
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:810
#define HIGHBIT
Definition: c.h:1153
size_t Size
Definition: c.h:610
static int BITMAPLEN(int NATTS)
Definition: htup_details.h:594
void * palloc0(Size size)
Definition: mcxt.c:1395
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(), 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
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
uint16_t uint16
Definition: c.h:537
struct varlena * detoast_external_attr(struct varlena *attr)
Definition: detoast.c:45
Assert(PointerIsAligned(start, uint64))
#define TOAST_INDEX_TARGET
Definition: heaptoast.h:68
Size heap_compute_data_size(TupleDesc tupleDesc, const Datum *values, const bool *isnull)
Definition: heaptuple.c:219
void heap_fill_tuple(TupleDesc tupleDesc, const Datum *values, const bool *isnull, char *data, Size data_size, uint16 *infomask, bits8 *bit)
Definition: heaptuple.c:401
static struct @169 value
void pfree(void *pointer)
Definition: mcxt.c:1594
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:202
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:322
int bd_totalstored
Definition: brin_internal.h:59
Oid type_id
Definition: typcache.h:34
char typstorage
Definition: typcache.h:42
Definition: c.h:692
#define InvalidCompressionMethod
Datum toast_compress_datum(Datum value, char cmethod)
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160
static bool VARATT_IS_EXTENDED(const void *PTR)
Definition: varatt.h:410
static bool VARATT_IS_EXTERNAL(const void *PTR)
Definition: varatt.h:354
static Size VARSIZE(const void *PTR)
Definition: varatt.h:298

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(), 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:400
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:160
#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}
b
int b
Definition: isn.c:74
a
int a
Definition: isn.c:73

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
86
87 brdesc->bd_disktdesc = tupdesc;
88 }
89
90 return brdesc->bd_disktdesc;
91}
int16 AttrNumber
Definition: attnum.h:21
j
int j
Definition: isn.c:78
MemoryContext bd_context
Definition: brin_internal.h:47
TupleDesc bd_disktdesc
Definition: brin_internal.h:56
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:182
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:842

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().

AltStyle によって変換されたページ (->オリジナル) /