brin_tuple.h File Reference

#include "access/brin_internal.h"
#include "access/tupdesc.h"

Include dependency graph for brin_tuple.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	BrinValues
struct	BrinMemTuple
struct	BrinTuple

Macros
#define	SizeOfBrinTuple   (offsetof(BrinTuple, bt_info) + sizeof(uint8))
#define	BRIN_OFFSET_MASK   0x1F
#define	BRIN_EMPTY_RANGE_MASK   0x20
#define	BRIN_PLACEHOLDER_MASK   0x40
#define	BRIN_NULLS_MASK   0x80
#define	BrinTupleDataOffset(tup)   ((Size) (((BrinTuple *) (tup))->bt_info & BRIN_OFFSET_MASK))
#define	BrinTupleHasNulls(tup)   (((((BrinTuple *) (tup))->bt_info & BRIN_NULLS_MASK)) != 0)
#define	BrinTupleIsPlaceholder(tup)   (((((BrinTuple *) (tup))->bt_info & BRIN_PLACEHOLDER_MASK)) != 0)
#define	BrinTupleIsEmptyRange(tup)   (((((BrinTuple *) (tup))->bt_info & BRIN_EMPTY_RANGE_MASK)) != 0)

Typedefs
typedef void(*	brin_serialize_callback_type) (BrinDesc *bdesc, Datum src, Datum *dst)
typedef struct BrinValues	BrinValues
typedef struct BrinMemTuple	BrinMemTuple
typedef struct BrinTuple	BrinTuple

Functions
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

BRIN_EMPTY_RANGE_MASK

#define BRIN_EMPTY_RANGE_MASK   0x20

Definition at line 86 of file brin_tuple.h.

BRIN_NULLS_MASK

#define BRIN_NULLS_MASK   0x80

Definition at line 88 of file brin_tuple.h.

BRIN_OFFSET_MASK

#define BRIN_OFFSET_MASK   0x1F

Definition at line 85 of file brin_tuple.h.

BRIN_PLACEHOLDER_MASK

#define BRIN_PLACEHOLDER_MASK   0x40

Definition at line 87 of file brin_tuple.h.

BrinTupleDataOffset

#define BrinTupleDataOffset

(

tup

)

((Size) (((BrinTuple *) (tup))->bt_info & BRIN_OFFSET_MASK))

Definition at line 90 of file brin_tuple.h.

BrinTupleHasNulls

#define BrinTupleHasNulls

(

tup

)

(((((BrinTuple *) (tup))->bt_info & BRIN_NULLS_MASK)) != 0)

Definition at line 91 of file brin_tuple.h.

BrinTupleIsEmptyRange

#define BrinTupleIsEmptyRange

(

tup

)

(((((BrinTuple *) (tup))->bt_info & BRIN_EMPTY_RANGE_MASK)) != 0)

Definition at line 93 of file brin_tuple.h.

BrinTupleIsPlaceholder

#define BrinTupleIsPlaceholder

(

tup

)

(((((BrinTuple *) (tup))->bt_info & BRIN_PLACEHOLDER_MASK)) != 0)

Definition at line 92 of file brin_tuple.h.

SizeOfBrinTuple

#define SizeOfBrinTuple   (offsetof(BrinTuple, bt_info) + sizeof(uint8))

Definition at line 80 of file brin_tuple.h.

Typedef Documentation

brin_serialize_callback_type

typedef void(* brin_serialize_callback_type) (BrinDesc *bdesc, Datum src, Datum *dst)

Definition at line 21 of file brin_tuple.h.

BrinMemTuple

typedef struct BrinMemTuple BrinMemTuple

BrinTuple

typedef struct BrinTuple BrinTuple

BrinValues

typedef struct BrinValues BrinValues

Function Documentation

brin_copy_tuple()

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

extern

Definition at line 445 of file brin_tuple.c.

{
    if (!destsz || *destsz == 0)
        dest = palloc(len);
    else if (len > *destsz)
    {
        dest = repalloc(dest, len);
        *destsz = len;
    }
 
    memcpy(dest, tuple, len);
 
    return dest;
}

References fb(), len, palloc(), and repalloc().

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

brin_deform_tuple()

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

extern

Definition at line 552 of file brin_tuple.c.

{
    BrinMemTuple *dtup;
    Datum      *values;
    bool       *allnulls;
    bool       *hasnulls;
    char       *tp;
    bits8      *nullbits;
    int         keyno;
    int         valueno;
    MemoryContext oldcxt;
 
    dtup = dMemtuple ? brin_memtuple_initialize(dMemtuple, brdesc) :
        brin_new_memtuple(brdesc);
 
    if (BrinTupleIsPlaceholder(tuple))
        dtup->bt_placeholder = true;
 
    /* ranges start as empty, depends on the BrinTuple */
    if (!BrinTupleIsEmptyRange(tuple))
        dtup->bt_empty_range = false;
 
    dtup->bt_blkno = tuple->bt_blkno;
 
    values = dtup->bt_values;
    allnulls = dtup->bt_allnulls;
    hasnulls = dtup->bt_hasnulls;
 
    tp = (char *) tuple + BrinTupleDataOffset(tuple);
 
    if (BrinTupleHasNulls(tuple))
        nullbits = (bits8 *) ((char *) tuple + SizeOfBrinTuple);
    else
        nullbits = NULL;
    brin_deconstruct_tuple(brdesc,
                           tp, nullbits, BrinTupleHasNulls(tuple),
                           values, allnulls, hasnulls);
 
    /*
     * Iterate to assign each of the values to the corresponding item in the
     * values array of each column.  The copies occur in the tuple's context.
     */
    oldcxt = MemoryContextSwitchTo(dtup->bt_context);
    for (valueno = 0, keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
    {
        int         i;
 
        if (allnulls[keyno])
        {
            valueno += brdesc->bd_info[keyno]->oi_nstored;
            continue;
        }
 
        /*
         * We would like to skip datumCopy'ing the values datum in some cases,
         * caller permitting ...
         */
        for (i = 0; i < brdesc->bd_info[keyno]->oi_nstored; i++)
            dtup->bt_columns[keyno].bv_values[i] =
                datumCopy(values[valueno++],
                          brdesc->bd_info[keyno]->oi_typcache[i]->typbyval,
                          brdesc->bd_info[keyno]->oi_typcache[i]->typlen);
 
        dtup->bt_columns[keyno].bv_hasnulls = hasnulls[keyno];
        dtup->bt_columns[keyno].bv_allnulls = false;
 
        dtup->bt_columns[keyno].bv_mem_value = PointerGetDatum(NULL);
        dtup->bt_columns[keyno].bv_serialize = NULL;
        dtup->bt_columns[keyno].bv_context = dtup->bt_context;
    }
 
    MemoryContextSwitchTo(oldcxt);
 
    return dtup;
}

References brin_deconstruct_tuple(), brin_memtuple_initialize(), brin_new_memtuple(), BrinTupleDataOffset, BrinTupleHasNulls, BrinTupleIsEmptyRange, BrinTupleIsPlaceholder, BrinTuple::bt_blkno, datumCopy(), fb(), i, MemoryContextSwitchTo(), PointerGetDatum(), SizeOfBrinTuple, 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  )

extern

Definition at line 387 of file brin_tuple.c.

{
    Size        len;
    Size        hoff;
    BrinTuple  *rettuple;
    int         keyno;
    bits8      *bitP;
    int         bitmask;
 
    /* compute total space needed: always add nulls */
    len = SizeOfBrinTuple;
    len += BITMAPLEN(brdesc->bd_tupdesc->natts * 2);
    len = hoff = MAXALIGN(len);
 
    rettuple = palloc0(len);
    rettuple->bt_blkno = blkno;
    rettuple->bt_info = hoff;
    rettuple->bt_info |= BRIN_NULLS_MASK | BRIN_PLACEHOLDER_MASK | BRIN_EMPTY_RANGE_MASK;
 
    bitP = ((bits8 *) ((char *) rettuple + SizeOfBrinTuple)) - 1;
    bitmask = HIGHBIT;
    /* set allnulls true for all attributes */
    for (keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
    {
        if (bitmask != HIGHBIT)
            bitmask <<= 1;
        else
        {
            bitP += 1;
            *bitP = 0x0;
            bitmask = 1;
        }
 
        *bitP |= bitmask;
    }
    /* no need to set hasnulls */
 
    *size = len;
    return rettuple;
}

References BITMAPLEN(), BRIN_EMPTY_RANGE_MASK, BRIN_NULLS_MASK, BRIN_PLACEHOLDER_MASK, fb(), HIGHBIT, len, MAXALIGN, palloc0(), and SizeOfBrinTuple.

Referenced by summarize_range().

brin_form_tuple()

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

extern

Definition at line 99 of file brin_tuple.c.

{
    Datum      *values;
    bool       *nulls;
    bool        anynulls = false;
    BrinTuple  *rettuple;
    int         keyno;
    int         idxattno;
    uint16      phony_infomask = 0;
    bits8      *phony_nullbitmap;
    Size        len,
                hoff,
                data_len;
    int         i;
 
#ifdef TOAST_INDEX_HACK
    Datum      *untoasted_values;
    int         nuntoasted = 0;
#endif
 
    Assert(brdesc->bd_totalstored > 0);
 
    values = palloc_array(Datum, brdesc->bd_totalstored);
    nulls = palloc0_array(bool, brdesc->bd_totalstored);
    phony_nullbitmap = palloc_array(bits8, BITMAPLEN(brdesc->bd_totalstored));
 
#ifdef TOAST_INDEX_HACK
    untoasted_values = palloc_array(Datum, brdesc->bd_totalstored);
#endif
 
    /*
     * Set up the values/nulls arrays for heap_fill_tuple
     */
    idxattno = 0;
    for (keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
    {
        int         datumno;
 
        /*
         * "allnulls" is set when there's no nonnull value in any row in the
         * column; when this happens, there is no data to store.  Thus set the
         * nullable bits for all data elements of this column and we're done.
         */
        if (tuple->bt_columns[keyno].bv_allnulls)
        {
            for (datumno = 0;
                 datumno < brdesc->bd_info[keyno]->oi_nstored;
                 datumno++)
                nulls[idxattno++] = true;
            anynulls = true;
            continue;
        }
 
        /*
         * The "hasnulls" bit is set when there are some null values in the
         * data.  We still need to store a real value, but the presence of
         * this means we need a null bitmap.
         */
        if (tuple->bt_columns[keyno].bv_hasnulls)
            anynulls = true;
 
        /* If needed, serialize the values before forming the on-disk tuple. */
        if (tuple->bt_columns[keyno].bv_serialize)
        {
            tuple->bt_columns[keyno].bv_serialize(brdesc,
                                                  tuple->bt_columns[keyno].bv_mem_value,
                                                  tuple->bt_columns[keyno].bv_values);
        }
 
        /*
         * Now obtain the values of each stored datum.  Note that some values
         * might be toasted, and we cannot rely on the original heap values
         * sticking around forever, so we must detoast them.  Also try to
         * compress them.
         */
        for (datumno = 0;
             datumno < brdesc->bd_info[keyno]->oi_nstored;
             datumno++)
        {
            Datum       value = tuple->bt_columns[keyno].bv_values[datumno];
 
#ifdef TOAST_INDEX_HACK
 
            /* We must look at the stored type, not at the index descriptor. */
            TypeCacheEntry *atttype = brdesc->bd_info[keyno]->oi_typcache[datumno];
 
            /* Do we need to free the value at the end? */
            bool        free_value = false;
 
            /* For non-varlena types we don't need to do anything special */
            if (atttype->typlen != -1)
            {
                values[idxattno++] = value;
                continue;
            }
 
            /*
             * Do nothing if value is not of varlena type. We don't need to
             * care about NULL values here, thanks to bv_allnulls above.
             *
             * If value is stored EXTERNAL, must fetch it so we are not
             * depending on outside storage.
             *
             * XXX Is this actually true? Could it be that the summary is NULL
             * even for range with non-NULL data? E.g. degenerate bloom filter
             * may be thrown away, etc.
             */
            if (VARATT_IS_EXTERNAL(DatumGetPointer(value)))
            {
                value = PointerGetDatum(detoast_external_attr((struct varlena *)
                                                              DatumGetPointer(value)));
                free_value = true;
            }
 
            /*
             * If value is above size target, and is of a compressible
             * datatype, try to compress it in-line.
             */
            if (!VARATT_IS_EXTENDED(DatumGetPointer(value)) &&
                VARSIZE(DatumGetPointer(value)) > TOAST_INDEX_TARGET &&
                (atttype->typstorage == TYPSTORAGE_EXTENDED ||
                 atttype->typstorage == TYPSTORAGE_MAIN))
            {
                Datum       cvalue;
                char        compression;
                Form_pg_attribute att = TupleDescAttr(brdesc->bd_tupdesc,
                                                      keyno);
 
                /*
                 * If the BRIN summary and indexed attribute use the same data
                 * type and it has a valid compression method, we can use the
                 * same compression method. Otherwise we have to use the
                 * default method.
                 */
                if (att->atttypid == atttype->type_id)
                    compression = att->attcompression;
                else
                    compression = InvalidCompressionMethod;
 
                cvalue = toast_compress_datum(value, compression);
 
                if (DatumGetPointer(cvalue) != NULL)
                {
                    /* successful compression */
                    if (free_value)
                        pfree(DatumGetPointer(value));
 
                    value = cvalue;
                    free_value = true;
                }
            }
 
            /*
             * If we untoasted / compressed the value, we need to free it
             * after forming the index tuple.
             */
            if (free_value)
                untoasted_values[nuntoasted++] = value;
 
#endif
 
            values[idxattno++] = value;
        }
    }
 
    /* Assert we did not overrun temp arrays */
    Assert(idxattno <= brdesc->bd_totalstored);
 
    /* compute total space needed */
    len = SizeOfBrinTuple;
    if (anynulls)
    {
        /*
         * We need a double-length bitmap on an on-disk BRIN index tuple; the
         * first half stores the "allnulls" bits, the second stores
         * "hasnulls".
         */
        len += BITMAPLEN(brdesc->bd_tupdesc->natts * 2);
    }
 
    len = hoff = MAXALIGN(len);
 
    data_len = heap_compute_data_size(brtuple_disk_tupdesc(brdesc),
                                      values, nulls);
    len += data_len;
 
    len = MAXALIGN(len);
 
    rettuple = palloc0(len);
    rettuple->bt_blkno = blkno;
    rettuple->bt_info = hoff;
 
    /* Assert that hoff fits in the space available */
    Assert((rettuple->bt_info & BRIN_OFFSET_MASK) == hoff);
 
    /*
     * The infomask and null bitmap as computed by heap_fill_tuple are useless
     * to us.  However, that function will not accept a null infomask; and we
     * need to pass a valid null bitmap so that it will correctly skip
     * outputting null attributes in the data area.
     */
    heap_fill_tuple(brtuple_disk_tupdesc(brdesc),
                    values,
                    nulls,
                    (char *) rettuple + hoff,
                    data_len,
                    &phony_infomask,
                    phony_nullbitmap);
 
    /* done with these */
    pfree(values);
    pfree(nulls);
    pfree(phony_nullbitmap);
 
#ifdef TOAST_INDEX_HACK
    for (i = 0; i < nuntoasted; i++)
        pfree(DatumGetPointer(untoasted_values[i]));
#endif
 
    /*
     * Now fill in the real null bitmasks.  allnulls first.
     */
    if (anynulls)
    {
        bits8      *bitP;
        int         bitmask;
 
        rettuple->bt_info |= BRIN_NULLS_MASK;
 
        /*
         * Note that we reverse the sense of null bits in this module: we
         * store a 1 for a null attribute rather than a 0.  So we must reverse
         * the sense of the att_isnull test in brin_deconstruct_tuple as well.
         */
        bitP = ((bits8 *) ((char *) rettuple + SizeOfBrinTuple)) - 1;
        bitmask = HIGHBIT;
        for (keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
        {
            if (bitmask != HIGHBIT)
                bitmask <<= 1;
            else
            {
                bitP += 1;
                *bitP = 0x0;
                bitmask = 1;
            }
 
            if (!tuple->bt_columns[keyno].bv_allnulls)
                continue;
 
            *bitP |= bitmask;
        }
        /* hasnulls bits follow */
        for (keyno = 0; keyno < brdesc->bd_tupdesc->natts; keyno++)
        {
            if (bitmask != HIGHBIT)
                bitmask <<= 1;
            else
            {
                bitP += 1;
                *bitP = 0x0;
                bitmask = 1;
            }
 
            if (!tuple->bt_columns[keyno].bv_hasnulls)
                continue;
 
            *bitP |= bitmask;
        }
    }
 
    if (tuple->bt_placeholder)
        rettuple->bt_info |= BRIN_PLACEHOLDER_MASK;
 
    if (tuple->bt_empty_range)
        rettuple->bt_info |= BRIN_EMPTY_RANGE_MASK;
 
    *size = len;
    return rettuple;
}

References Assert, BITMAPLEN(), BRIN_EMPTY_RANGE_MASK, BRIN_NULLS_MASK, BRIN_OFFSET_MASK, BRIN_PLACEHOLDER_MASK, brtuple_disk_tupdesc(), BrinMemTuple::bt_columns, BrinMemTuple::bt_empty_range, BrinMemTuple::bt_placeholder, BrinValues::bv_allnulls, BrinValues::bv_hasnulls, BrinValues::bv_mem_value, BrinValues::bv_serialize, BrinValues::bv_values, DatumGetPointer(), detoast_external_attr(), fb(), heap_compute_data_size(), heap_fill_tuple(), HIGHBIT, i, InvalidCompressionMethod, len, MAXALIGN, palloc0(), palloc0_array, palloc_array, 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 )

extern

Definition at line 432 of file brin_tuple.c.

{
    pfree(tuple);
}

References pfree().

Referenced by summarize_range().

brin_memtuple_initialize()

BrinMemTuple * brin_memtuple_initialize ( BrinMemTuple *  dtuple, BrinDesc *  brdesc  )

extern

Definition at line 510 of file brin_tuple.c.

{
    int         i;
    char       *currdatum;
 
    MemoryContextReset(dtuple->bt_context);
 
    currdatum = (char *) dtuple +
        MAXALIGN(sizeof(BrinMemTuple) +
                 sizeof(BrinValues) * brdesc->bd_tupdesc->natts);
    for (i = 0; i < brdesc->bd_tupdesc->natts; i++)
    {
        dtuple->bt_columns[i].bv_attno = i + 1;
        dtuple->bt_columns[i].bv_allnulls = true;
        dtuple->bt_columns[i].bv_hasnulls = false;
        dtuple->bt_columns[i].bv_values = (Datum *) currdatum;
 
        dtuple->bt_columns[i].bv_mem_value = PointerGetDatum(NULL);
        dtuple->bt_columns[i].bv_serialize = NULL;
        dtuple->bt_columns[i].bv_context = dtuple->bt_context;
 
        currdatum += sizeof(Datum) * brdesc->bd_info[i]->oi_nstored;
    }
 
    dtuple->bt_empty_range = true;
 
    return dtuple;
}

References fb(), i, MAXALIGN, MemoryContextReset(), and PointerGetDatum().

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

brin_new_memtuple()

BrinMemTuple * brin_new_memtuple ( BrinDesc *  brdesc )

extern

Definition at line 481 of file brin_tuple.c.

{
    BrinMemTuple *dtup;
    long        basesize;
 
    basesize = MAXALIGN(sizeof(BrinMemTuple) +
                        sizeof(BrinValues) * brdesc->bd_tupdesc->natts);
    dtup = palloc0(basesize + sizeof(Datum) * brdesc->bd_totalstored);
 
    dtup->bt_values = palloc_array(Datum, brdesc->bd_totalstored);
    dtup->bt_allnulls = palloc_array(bool, brdesc->bd_tupdesc->natts);
    dtup->bt_hasnulls = palloc_array(bool, brdesc->bd_tupdesc->natts);
 
    dtup->bt_empty_range = true;
 
    dtup->bt_context = AllocSetContextCreate(CurrentMemoryContext,
                                             "brin dtuple",
                                             ALLOCSET_DEFAULT_SIZES);
 
    brin_memtuple_initialize(dtup, brdesc);
 
    return dtup;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, brin_memtuple_initialize(), CurrentMemoryContext, fb(), MAXALIGN, palloc0(), and palloc_array.

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  )

extern

Definition at line 464 of file brin_tuple.c.

{
    if (alen != blen)
        return false;
    if (memcmp(a, b, alen) != 0)
        return false;
    return true;
}

References a, b, and fb().

Referenced by brin_doupdate().