Introduce bloom_filter_size for BRIN bloom opclass

Move the calculation of Bloom filter parameters (for BRIN indexes) into
a separate function to make reuse easier. At the moment we only call it
from one place, but that may change and it's easier to read anyway.

Reviewed-by: Heikki Linnakangas
Discussion: https://postgr.es/m/0e1f3350-c9cf-ab62-43a5-5dae314de89c%40enterprisedb.com

diff --git a/src/backend/access/brin/brin_bloom.c b/src/backend/access/brin/brin_bloom.c
index 568faf1cd58ee872349dd1c6620a61cacc6197f8..f47eb81012d3ad832a5116330b44288669307241 100644 (file)
--- a/src/backend/access/brin/brin_bloom.c
+++ b/src/backend/access/brin/brin_bloom.c
@@ -259,6 +259,48 @@ typedef struct BloomFilter
    char        data[FLEXIBLE_ARRAY_MEMBER];
 } BloomFilter;
 
+/*
+ * bloom_filter_size
+ *     Calculate Bloom filter parameters (nbits, nbytes, nhashes).
+ *
+ * Given expected number of distinct values and desired false positive rate,
+ * calculates the optimal parameters of the Bloom filter.
+ *
+ * The resulting parameters are returned through nbytesp (number of bytes),
+ * nbitsp (number of bits) and nhashesp (number of hash functions). If a
+ * pointer is NULL, the parameter is not returned.
+ */
+static void
+bloom_filter_size(int ndistinct, double false_positive_rate,
+                 int *nbytesp, int *nbitsp, int *nhashesp)
+{
+   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;
+}
 
 /*
  * bloom_init
@@ -275,19 +317,15 @@ bloom_init(int ndistinct, double false_positive_rate)
 
    int         nbits;          /* size of filter / number of bits */
    int         nbytes;         /* size of filter / number of bytes */
-
-   double      k;              /* number of hash functions */
+   int         nhashes;        /* number of hash functions */
 
    Assert(ndistinct > 0);
    Assert((false_positive_rate >= BLOOM_MIN_FALSE_POSITIVE_RATE) &&
           (false_positive_rate < BLOOM_MAX_FALSE_POSITIVE_RATE));
 
-   /* 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;
+   /* 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.
@@ -310,13 +348,6 @@ bloom_init(int ndistinct, double false_positive_rate)
        elog(ERROR, "the bloom filter is too large (%d > %zu)", nbytes,
             BloomMaxFilterSize);
 
-   /*
-    * 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);
-
    /*
     * We allocate the whole filter. Most of it is going to be 0 bits, so the
     * varlena is easy to compress.
@@ -326,7 +357,7 @@ bloom_init(int ndistinct, double false_positive_rate)
    filter = (BloomFilter *) palloc0(len);
 
    filter->flags = 0;
-   filter->nhashes = (int) k;
+   filter->nhashes = nhashes;
    filter->nbits = nbits;
 
    SET_VARSIZE(filter, len);