brin_bloom.c File Reference

#include "postgres.h"
#include <limits.h>
#include <math.h>
#include "access/brin.h"
#include "access/brin_internal.h"
#include "access/brin_page.h"
#include "access/brin_tuple.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/reloptions.h"
#include "catalog/pg_am.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "port/pg_bitutils.h"
#include "utils/fmgrprotos.h"
#include "utils/rel.h"

Include dependency graph for brin_bloom.c:

Go to the source code of this file.

Data Structures
struct	BloomOptions
struct	BloomFilter
struct	BloomOpaque

Macros
#define	BloomEqualStrategyNumber   1
#define	BLOOM_MAX_PROCNUMS   1 /* maximum support procs we need */
#define	PROCNUM_HASH   11 /* required */
#define	PROCNUM_BASE   11
#define	BLOOM_MIN_NDISTINCT_PER_RANGE   16
#define	BLOOM_DEFAULT_NDISTINCT_PER_RANGE   -0.1 /* 10% of values */
#define	BLOOM_MIN_FALSE_POSITIVE_RATE   0.0001 /* 0.01% fp rate */
#define	BLOOM_MAX_FALSE_POSITIVE_RATE   0.25 /* 25% fp rate */
#define	BLOOM_DEFAULT_FALSE_POSITIVE_RATE   0.01 /* 1% fp rate */
#define	BloomGetNDistinctPerRange(opts)
#define	BloomGetFalsePositiveRate(opts)
#define	BloomMaxFilterSize
#define	BLOOM_SEED_1   0x71d924af
#define	BLOOM_SEED_2   0xba48b314

Typedefs
typedef struct BloomOptions	BloomOptions
typedef struct BloomFilter	BloomFilter
typedef struct BloomOpaque	BloomOpaque

Functions
static void	bloom_filter_size (int ndistinct, double false_positive_rate, int *nbytesp, int *nbitsp, int *nhashesp)
static BloomFilter *	bloom_init (int ndistinct, double false_positive_rate)
static BloomFilter *	bloom_add_value (BloomFilter *filter, uint32 value, bool *updated)
static bool	bloom_contains_value (BloomFilter *filter, uint32 value)
static FmgrInfo *	bloom_get_procinfo (BrinDesc *bdesc, uint16 attno, uint16 procnum)
Datum	brin_bloom_opcinfo (PG_FUNCTION_ARGS)
static int	brin_bloom_get_ndistinct (BrinDesc *bdesc, BloomOptions *opts)
Datum	brin_bloom_add_value (PG_FUNCTION_ARGS)
Datum	brin_bloom_consistent (PG_FUNCTION_ARGS)
Datum	brin_bloom_union (PG_FUNCTION_ARGS)
Datum	brin_bloom_options (PG_FUNCTION_ARGS)
Datum	brin_bloom_summary_in (PG_FUNCTION_ARGS)
Datum	brin_bloom_summary_out (PG_FUNCTION_ARGS)
Datum	brin_bloom_summary_recv (PG_FUNCTION_ARGS)
Datum	brin_bloom_summary_send (PG_FUNCTION_ARGS)

Macro Definition Documentation

BLOOM_DEFAULT_FALSE_POSITIVE_RATE

#define BLOOM_DEFAULT_FALSE_POSITIVE_RATE   0.01 /* 1% fp rate */

Definition at line 195 of file brin_bloom.c.

BLOOM_DEFAULT_NDISTINCT_PER_RANGE

#define BLOOM_DEFAULT_NDISTINCT_PER_RANGE   -0.1 /* 10% of values */

Definition at line 177 of file brin_bloom.c.

BLOOM_MAX_FALSE_POSITIVE_RATE

#define BLOOM_MAX_FALSE_POSITIVE_RATE   0.25 /* 25% fp rate */

Definition at line 194 of file brin_bloom.c.

BLOOM_MAX_PROCNUMS

#define BLOOM_MAX_PROCNUMS   1 /* maximum support procs we need */

Definition at line 143 of file brin_bloom.c.

BLOOM_MIN_FALSE_POSITIVE_RATE

#define BLOOM_MIN_FALSE_POSITIVE_RATE   0.0001 /* 0.01% fp rate */

Definition at line 193 of file brin_bloom.c.

BLOOM_MIN_NDISTINCT_PER_RANGE

#define BLOOM_MIN_NDISTINCT_PER_RANGE   16

Definition at line 170 of file brin_bloom.c.

BLOOM_SEED_1

#define BLOOM_SEED_1   0x71d924af

Definition at line 223 of file brin_bloom.c.

BLOOM_SEED_2

#define BLOOM_SEED_2   0xba48b314

Definition at line 224 of file brin_bloom.c.

BloomEqualStrategyNumber

#define BloomEqualStrategyNumber   1

Definition at line 134 of file brin_bloom.c.

BloomGetFalsePositiveRate

#define BloomGetFalsePositiveRate

(

opts

)

Value:

    ((opts) && (((BloomOptions *) (opts))->falsePositiveRate != 0.0) ? \
     (((BloomOptions *) (opts))->falsePositiveRate) : \
     BLOOM_DEFAULT_FALSE_POSITIVE_RATE)

Definition at line 202 of file brin_bloom.c.

                                                    : \
     BLOOM_DEFAULT_FALSE_POSITIVE_RATE)

BloomGetNDistinctPerRange

#define BloomGetNDistinctPerRange

(

opts

)

Value:

    ((opts) && (((BloomOptions *) (opts))->nDistinctPerRange != 0) ? \
     (((BloomOptions *) (opts))->nDistinctPerRange) : \
     BLOOM_DEFAULT_NDISTINCT_PER_RANGE)

Definition at line 197 of file brin_bloom.c.

                                                    : \
     BLOOM_DEFAULT_NDISTINCT_PER_RANGE)

BloomMaxFilterSize

#define BloomMaxFilterSize

Value:

    MAXALIGN_DOWN(BLCKSZ - \
                  (MAXALIGN(SizeOfPageHeaderData + \
                            sizeof(ItemIdData)) + \
                   MAXALIGN(sizeof(BrinSpecialSpace)) + \
                   SizeOfBrinTuple))

Definition at line 212 of file brin_bloom.c.

PROCNUM_BASE

#define PROCNUM_BASE   11

Definition at line 150 of file brin_bloom.c.

PROCNUM_HASH

#define PROCNUM_HASH   11 /* required */

Definition at line 144 of file brin_bloom.c.

Typedef Documentation

BloomFilter

typedef struct BloomFilter BloomFilter

BloomOpaque

typedef struct BloomOpaque BloomOpaque

BloomOptions

typedef struct BloomOptions BloomOptions

Function Documentation

bloom_add_value()

static BloomFilter * bloom_add_value ( BloomFilter *  filter, uint32  value, bool *  updated  )

static

Definition at line 371 of file brin_bloom.c.

{
    int         i;
    uint64      h1,
                h2;
 
    /* compute the hashes, used for the bloom filter */
    h1 = hash_bytes_uint32_extended(value, BLOOM_SEED_1) % filter->nbits;
    h2 = hash_bytes_uint32_extended(value, BLOOM_SEED_2) % filter->nbits;
 
    /* compute the requested number of hashes */
    for (i = 0; i < filter->nhashes; i++)
    {
        /* h1 + h2 + f(i) */
        uint32      h = (h1 + i * h2) % filter->nbits;
        uint32      byte = (h / 8);
        uint32      bit = (h % 8);
 
        /* if the bit is not set, set it and remember we did that */
        if (!(filter->data[byte] & (0x01 << bit)))
        {
            filter->data[byte] |= (0x01 << bit);
            filter->nbits_set++;
            if (updated)
                *updated = true;
        }
    }
 
    return filter;
}

References bit(), BLOOM_SEED_1, BLOOM_SEED_2, BloomFilter::data, fb(), hash_bytes_uint32_extended(), i, BloomFilter::nbits, BloomFilter::nbits_set, BloomFilter::nhashes, and value.

Referenced by brin_bloom_add_value().

bloom_contains_value()

static bool bloom_contains_value ( BloomFilter *  filter, uint32  value  )

static

Definition at line 408 of file brin_bloom.c.

{
    int         i;
    uint64      h1,
                h2;
 
    /* calculate the two hashes */
    h1 = hash_bytes_uint32_extended(value, BLOOM_SEED_1) % filter->nbits;
    h2 = hash_bytes_uint32_extended(value, BLOOM_SEED_2) % filter->nbits;
 
    /* compute the requested number of hashes */
    for (i = 0; i < filter->nhashes; i++)
    {
        /* h1 + h2 + f(i) */
        uint32      h = (h1 + i * h2) % filter->nbits;
        uint32      byte = (h / 8);
        uint32      bit = (h % 8);
 
        /* if the bit is not set, the value is not there */
        if (!(filter->data[byte] & (0x01 << bit)))
            return false;
    }
 
    /* all hashes found in bloom filter */
    return true;
}

References bit(), BLOOM_SEED_1, BLOOM_SEED_2, BloomFilter::data, fb(), hash_bytes_uint32_extended(), i, BloomFilter::nbits, BloomFilter::nhashes, and value.

Referenced by brin_bloom_consistent().

bloom_filter_size()

static void bloom_filter_size ( int  ndistinct, double  false_positive_rate, int *  nbytesp, int *  nbitsp, int *  nhashesp  )

static

Definition at line 272 of file brin_bloom.c.

{
    double      k;
    int         nbits,
                nbytes;
 
    /* sizing bloom filter: -(n * ln(p)) / (ln(2))^2 */
    nbits = ceil(-(ndistinct * log(false_positive_rate)) / pow(log(2.0), 2));
 
    /* round m to whole bytes */
    nbytes = ((nbits + 7) / 8);
    nbits = nbytes * 8;
 
    /*
     * round(log(2.0) * m / ndistinct), but assume round() may not be
     * available on Windows
     */
    k = log(2.0) * nbits / ndistinct;
    k = (k - floor(k) >= 0.5) ? ceil(k) : floor(k);
 
    if (nbytesp)
        *nbytesp = nbytes;
 
    if (nbitsp)
        *nbitsp = nbits;
 
    if (nhashesp)
        *nhashesp = (int) k;
}

References fb().

Referenced by bloom_init().

bloom_get_procinfo()

static FmgrInfo * bloom_get_procinfo ( BrinDesc *  bdesc, uint16  attno, uint16  procnum  )

static

Definition at line 718 of file brin_bloom.c.

{
    BloomOpaque *opaque;
    uint16      basenum = procnum - PROCNUM_BASE;
 
    /*
     * We cache these in the opaque struct, to avoid repetitive syscache
     * lookups.
     */
    opaque = (BloomOpaque *) bdesc->bd_info[attno - 1]->oi_opaque;
 
    if (opaque->extra_procinfos[basenum].fn_oid == InvalidOid)
    {
        if (RegProcedureIsValid(index_getprocid(bdesc->bd_index, attno,
                                                procnum)))
            fmgr_info_copy(&opaque->extra_procinfos[basenum],
                           index_getprocinfo(bdesc->bd_index, attno, procnum),
                           bdesc->bd_context);
        else
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                    errmsg_internal("invalid opclass definition"),
                    errdetail_internal("The operator class is missing support function %d for column %d.",
                                       procnum, attno));
    }
 
    return &opaque->extra_procinfos[basenum];
}

References ereport, errcode(), errdetail_internal(), errmsg_internal(), ERROR, BloomOpaque::extra_procinfos, fb(), fmgr_info_copy(), FmgrInfo::fn_oid, index_getprocid(), index_getprocinfo(), InvalidOid, PROCNUM_BASE, and RegProcedureIsValid.

Referenced by brin_bloom_add_value(), and brin_bloom_consistent().

bloom_init()

static BloomFilter * bloom_init ( int  ndistinct, double  false_positive_rate  )

static

Definition at line 311 of file brin_bloom.c.

{
    Size        len;
    BloomFilter *filter;
 
    int         nbits;          /* size of filter / number of bits */
    int         nbytes;         /* size of filter / number of bytes */
    int         nhashes;        /* number of hash functions */
 
    Assert(ndistinct > 0);
    Assert(false_positive_rate > 0 && false_positive_rate < 1);
 
    /* calculate bloom filter size / parameters */
    bloom_filter_size(ndistinct, false_positive_rate,
                      &nbytes, &nbits, &nhashes);
 
    /*
     * Reject filters that are obviously too large to store on a page.
     *
     * Initially the bloom filter is just zeroes and so very compressible, but
     * as we add values it gets more and more random, and so less and less
     * compressible. So initially everything fits on the page, but we might
     * get surprising failures later - we want to prevent that, so we reject
     * bloom filter that are obviously too large.
     *
     * XXX It's not uncommon to oversize the bloom filter a bit, to defend
     * against unexpected data anomalies (parts of table with more distinct
     * values per range etc.). But we still need to make sure even the
     * oversized filter fits on page, if such need arises.
     *
     * XXX This check is not perfect, because the index may have multiple
     * filters that are small individually, but too large when combined.
     */
    if (nbytes > BloomMaxFilterSize)
        elog(ERROR, "the bloom filter is too large (%d > %zu)", nbytes,
             BloomMaxFilterSize);
 
    /*
     * We allocate the whole filter. Most of it is going to be 0 bits, so the
     * varlena is easy to compress.
     */
    len = offsetof(BloomFilter, data) + nbytes;
 
    filter = (BloomFilter *) palloc0(len);
 
    filter->flags = 0;
    filter->nhashes = nhashes;
    filter->nbits = nbits;
 
    SET_VARSIZE(filter, len);
 
    return filter;
}

References Assert, bloom_filter_size(), BloomMaxFilterSize, data, elog, ERROR, fb(), BloomFilter::flags, len, BloomFilter::nbits, BloomFilter::nhashes, palloc0(), and SET_VARSIZE().

Referenced by brin_bloom_add_value().

brin_bloom_add_value()

Datum brin_bloom_add_value

(

PG_FUNCTION_ARGS

)

Definition at line 540 of file brin_bloom.c.

{
    BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
    BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1);
    Datum       newval = PG_GETARG_DATUM(2);
    bool        isnull PG_USED_FOR_ASSERTS_ONLY = PG_GETARG_BOOL(3);
    BloomOptions *opts = (BloomOptions *) PG_GET_OPCLASS_OPTIONS();
    Oid         colloid = PG_GET_COLLATION();
    FmgrInfo   *hashFn;
    uint32      hashValue;
    bool        updated = false;
    AttrNumber  attno;
    BloomFilter *filter;
 
    Assert(!isnull);
 
    attno = column->bv_attno;
 
    /*
     * If this is the first non-null value, we need to initialize the bloom
     * filter. Otherwise just extract the existing bloom filter from
     * BrinValues.
     */
    if (column->bv_allnulls)
    {
        filter = bloom_init(brin_bloom_get_ndistinct(bdesc, opts),
                            BloomGetFalsePositiveRate(opts));
        column->bv_values[0] = PointerGetDatum(filter);
        column->bv_allnulls = false;
        updated = true;
    }
    else
        filter = (BloomFilter *) PG_DETOAST_DATUM(column->bv_values[0]);
 
    /*
     * Compute the hash of the new value, using the supplied hash function,
     * and then add the hash value to the bloom filter.
     */
    hashFn = bloom_get_procinfo(bdesc, attno, PROCNUM_HASH);
 
    hashValue = DatumGetUInt32(FunctionCall1Coll(hashFn, colloid, newval));
 
    filter = bloom_add_value(filter, hashValue, &updated);
 
    column->bv_values[0] = PointerGetDatum(filter);
 
    PG_RETURN_BOOL(updated);
}

References Assert, bloom_add_value(), bloom_get_procinfo(), bloom_init(), BloomGetFalsePositiveRate, brin_bloom_get_ndistinct(), DatumGetUInt32(), fb(), FunctionCall1Coll(), newval, opts, PG_DETOAST_DATUM, PG_GET_COLLATION, PG_GET_OPCLASS_OPTIONS, PG_GETARG_BOOL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_BOOL, PG_USED_FOR_ASSERTS_ONLY, PointerGetDatum(), and PROCNUM_HASH.

brin_bloom_consistent()

Datum brin_bloom_consistent

(

PG_FUNCTION_ARGS

)

Definition at line 595 of file brin_bloom.c.

{
    BrinDesc   *bdesc = (BrinDesc *) PG_GETARG_POINTER(0);
    BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1);
    ScanKey    *keys = (ScanKey *) PG_GETARG_POINTER(2);
    int         nkeys = PG_GETARG_INT32(3);
    Oid         colloid = PG_GET_COLLATION();
    AttrNumber  attno;
    Datum       value;
    bool        matches;
    FmgrInfo   *finfo;
    uint32      hashValue;
    BloomFilter *filter;
    int         keyno;
 
    filter = (BloomFilter *) PG_DETOAST_DATUM(column->bv_values[0]);
 
    Assert(filter);
 
    /*
     * Assume all scan keys match. We'll be searching for a scan key
     * eliminating the page range (we can stop on the first such key).
     */
    matches = true;
 
    for (keyno = 0; keyno < nkeys; keyno++)
    {
        ScanKey     key = keys[keyno];
 
        /* NULL keys are handled and filtered-out in bringetbitmap */
        Assert(!(key->sk_flags & SK_ISNULL));
 
        attno = key->sk_attno;
        value = key->sk_argument;
 
        switch (key->sk_strategy)
        {
            case BloomEqualStrategyNumber:
 
                /*
                 * We want to return the current page range if the bloom
                 * filter seems to contain the value.
                 */
                finfo = bloom_get_procinfo(bdesc, attno, PROCNUM_HASH);
 
                hashValue = DatumGetUInt32(FunctionCall1Coll(finfo, colloid, value));
                matches &= bloom_contains_value(filter, hashValue);
 
                break;
            default:
                /* shouldn't happen */
                elog(ERROR, "invalid strategy number %d", key->sk_strategy);
                matches = false;
                break;
        }
 
        if (!matches)
            break;
    }
 
    PG_RETURN_BOOL(matches);
}

References Assert, bloom_contains_value(), bloom_get_procinfo(), BloomEqualStrategyNumber, DatumGetUInt32(), elog, ERROR, fb(), FunctionCall1Coll(), PG_DETOAST_DATUM, PG_GET_COLLATION, PG_GETARG_INT32, PG_GETARG_POINTER, PG_RETURN_BOOL, PROCNUM_HASH, SK_ISNULL, and value.

brin_bloom_get_ndistinct()

static int brin_bloom_get_ndistinct ( BrinDesc *  bdesc, BloomOptions *  opts  )

static

Definition at line 497 of file brin_bloom.c.

{
    double      ndistinct;
    double      maxtuples;
    BlockNumber pagesPerRange;
 
    pagesPerRange = BrinGetPagesPerRange(bdesc->bd_index);
    ndistinct = BloomGetNDistinctPerRange(opts);
 
    Assert(BlockNumberIsValid(pagesPerRange));
 
    maxtuples = MaxHeapTuplesPerPage * pagesPerRange;
 
    /*
     * Similarly to n_distinct, negative values are relative - in this case to
     * maximum number of tuples in the page range (maxtuples).
     */
    if (ndistinct < 0)
        ndistinct = (-ndistinct) * maxtuples;
 
    /*
     * Positive values are to be used directly, but we still apply a couple of
     * safeties to avoid using unreasonably small bloom filters.
     */
    ndistinct = Max(ndistinct, BLOOM_MIN_NDISTINCT_PER_RANGE);
 
    /*
     * And don't use more than the maximum possible number of tuples, in the
     * range, which would be entirely wasteful.
     */
    ndistinct = Min(ndistinct, maxtuples);
 
    return (int) ndistinct;
}

References Assert, BlockNumberIsValid(), BLOOM_MIN_NDISTINCT_PER_RANGE, BloomGetNDistinctPerRange, BrinGetPagesPerRange, fb(), Max, MaxHeapTuplesPerPage, Min, and opts.

Referenced by brin_bloom_add_value().

brin_bloom_opcinfo()

Datum brin_bloom_opcinfo

(

PG_FUNCTION_ARGS

)

Definition at line 450 of file brin_bloom.c.

{
    BrinOpcInfo *result;
 
    /*
     * opaque->strategy_procinfos is initialized lazily; here it is set to
     * all-uninitialized by palloc0 which sets fn_oid to InvalidOid.
     *
     * bloom indexes only store the filter as a single BYTEA column
     */
 
    result = palloc0(MAXALIGN(SizeofBrinOpcInfo(1)) +
                     sizeof(BloomOpaque));
    result->oi_nstored = 1;
    result->oi_regular_nulls = true;
    result->oi_opaque = (BloomOpaque *)
        MAXALIGN((char *) result + SizeofBrinOpcInfo(1));
    result->oi_typcache[0] = lookup_type_cache(PG_BRIN_BLOOM_SUMMARYOID, 0);
 
    PG_RETURN_POINTER(result);
}

References fb(), lookup_type_cache(), MAXALIGN, BrinOpcInfo::oi_nstored, BrinOpcInfo::oi_opaque, BrinOpcInfo::oi_regular_nulls, BrinOpcInfo::oi_typcache, palloc0(), PG_RETURN_POINTER, and SizeofBrinOpcInfo.

brin_bloom_options()

Datum brin_bloom_options

(

PG_FUNCTION_ARGS

)

Definition at line 748 of file brin_bloom.c.

{
    local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0);
 
    init_local_reloptions(relopts, sizeof(BloomOptions));
 
    add_local_real_reloption(relopts, "n_distinct_per_range",
                             "number of distinct items expected in a BRIN page range",
                             BLOOM_DEFAULT_NDISTINCT_PER_RANGE,
                             -1.0, INT_MAX, offsetof(BloomOptions, nDistinctPerRange));
 
    add_local_real_reloption(relopts, "false_positive_rate",
                             "desired false-positive rate for the bloom filters",
                             BLOOM_DEFAULT_FALSE_POSITIVE_RATE,
                             BLOOM_MIN_FALSE_POSITIVE_RATE,
                             BLOOM_MAX_FALSE_POSITIVE_RATE,
                             offsetof(BloomOptions, falsePositiveRate));
 
    PG_RETURN_VOID();
}

References add_local_real_reloption(), BLOOM_DEFAULT_FALSE_POSITIVE_RATE, BLOOM_DEFAULT_NDISTINCT_PER_RANGE, BLOOM_MAX_FALSE_POSITIVE_RATE, BLOOM_MIN_FALSE_POSITIVE_RATE, fb(), init_local_reloptions(), PG_GETARG_POINTER, and PG_RETURN_VOID.

brin_bloom_summary_in()

Datum brin_bloom_summary_in

(

PG_FUNCTION_ARGS

)

Definition at line 778 of file brin_bloom.c.

{
    /*
     * brin_bloom_summary stores the data in binary form and parsing text
     * input is not needed, so disallow this.
     */
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("cannot accept a value of type %s", "pg_brin_bloom_summary")));
 
    PG_RETURN_VOID();           /* keep compiler quiet */
}

References ereport, errcode(), errmsg(), ERROR, fb(), and PG_RETURN_VOID.

brin_bloom_summary_out()

Datum brin_bloom_summary_out

(

PG_FUNCTION_ARGS

)

Definition at line 800 of file brin_bloom.c.

{
    BloomFilter *filter;
    StringInfoData str;
 
    /* detoast the data to get value with a full 4B header */
    filter = (BloomFilter *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
 
    initStringInfo(&str);
    appendStringInfoChar(&str, '{');
 
    appendStringInfo(&str, "mode: hashed  nhashes: %u  nbits: %u  nbits_set: %u",
                     filter->nhashes, filter->nbits, filter->nbits_set);
 
    appendStringInfoChar(&str, '}');
 
    PG_RETURN_CSTRING(str.data);
}

References appendStringInfo(), appendStringInfoChar(), initStringInfo(), BloomFilter::nbits, BloomFilter::nbits_set, BloomFilter::nhashes, PG_DETOAST_DATUM, PG_GETARG_DATUM, PG_RETURN_CSTRING, and str.

brin_bloom_summary_recv()

Datum brin_bloom_summary_recv

(

PG_FUNCTION_ARGS

)

Definition at line 824 of file brin_bloom.c.

{
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("cannot accept a value of type %s", "pg_brin_bloom_summary")));
 
    PG_RETURN_VOID();           /* keep compiler quiet */
}

References ereport, errcode(), errmsg(), ERROR, fb(), and PG_RETURN_VOID.

brin_bloom_summary_send()

Datum brin_bloom_summary_send

(

PG_FUNCTION_ARGS

)

Definition at line 841 of file brin_bloom.c.

{
    return byteasend(fcinfo);
}

References byteasend().

brin_bloom_union()

Datum brin_bloom_union

(

PG_FUNCTION_ARGS

)

Definition at line 667 of file brin_bloom.c.

{
    int         i;
    int         nbytes;
    BrinValues *col_a = (BrinValues *) PG_GETARG_POINTER(1);
    BrinValues *col_b = (BrinValues *) PG_GETARG_POINTER(2);
    BloomFilter *filter_a;
    BloomFilter *filter_b;
 
    Assert(col_a->bv_attno == col_b->bv_attno);
    Assert(!col_a->bv_allnulls && !col_b->bv_allnulls);
 
    filter_a = (BloomFilter *) PG_DETOAST_DATUM(col_a->bv_values[0]);
    filter_b = (BloomFilter *) PG_DETOAST_DATUM(col_b->bv_values[0]);
 
    /* make sure the filters use the same parameters */
    Assert(filter_a && filter_b);
    Assert(filter_a->nbits == filter_b->nbits);
    Assert(filter_a->nhashes == filter_b->nhashes);
    Assert((filter_a->nbits > 0) && (filter_a->nbits % 8 == 0));
 
    nbytes = (filter_a->nbits) / 8;
 
    /* simply OR the bitmaps */
    for (i = 0; i < nbytes; i++)
        filter_a->data[i] |= filter_b->data[i];
 
    /* update the number of bits set in the filter */
    filter_a->nbits_set = pg_popcount((const char *) filter_a->data, nbytes);
 
    /* if we decompressed filter_a, update the summary */
    if (PointerGetDatum(filter_a) != col_a->bv_values[0])
    {
        pfree(DatumGetPointer(col_a->bv_values[0]));
        col_a->bv_values[0] = PointerGetDatum(filter_a);
    }
 
    /* also free filter_b, if it was decompressed */
    if (PointerGetDatum(filter_b) != col_b->bv_values[0])
        pfree(filter_b);
 
    PG_RETURN_VOID();
}

References Assert, DatumGetPointer(), fb(), i, pfree(), PG_DETOAST_DATUM, PG_GETARG_POINTER, pg_popcount(), PG_RETURN_VOID, and PointerGetDatum().