contains any?

Author: akuzm

tsl/src/compression/batch_metadata_builder_bloom1.c

@@ -469,6 +469,123 @@ bloom1_contains(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+static int
+uint64_qsort_cmp(const void *a, const void *b)
+{
+	return pg_cmp_u64(*(const uint64 *) a, *(const uint64 *) b);
+}
+
+Datum
+bloom1_contains_any(PG_FUNCTION_ARGS)
+{
+	/*
+	 * This function is not strict, because if we don't have a bloom filter, this
+	 * means the condition can potentially be true.
+	 */
+	if (PG_ARGISNULL(0))
+	{
+		PG_RETURN_BOOL(true);
+	}
+
+	/*
+	 * A null value cannot match the equality condition, although this probably
+	 * should be optimized away by the planner.
+	 */
+	if (PG_ARGISNULL(1))
+	{
+		PG_RETURN_BOOL(false);
+	}
+
+	ArrayType  *arr      = PG_GETARG_ARRAYTYPE_P(1);
+	int         nelems;
+	Datum      *values;
+	bool       *nulls;
+
+	Oid elem_type = ARR_ELEMTYPE(arr);
+
+	FmgrInfo   *finfo    = NULL;
+	PGFunction  hash_fn  = bloom1_get_hash_function(elem_type, &finfo);
+	if (hash_fn == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("type %s lacks an extended hash function",
+						format_type_be(elem_type))));
+
+	int16 typlen; bool typbyval; char typalign;
+	get_typlenbyvalalign(elem_type, &typlen, &typbyval, &typalign);
+	deconstruct_array(arr, elem_type, typlen, typbyval, typalign,
+					  &values, &nulls, &nelems);
+
+	if (nelems == 0)
+		PG_RETURN_BOOL(false);
+
+	/* --- hash elements -------------------------------------------------- */
+#if FLOAT8PASSBYVAL
+	uint64 *hashes = values;
+#else
+	uint64 *hashes = palloc(sizeof(uint64) * nelems);
+#endif
+
+	int     valid  = 0;
+
+	for (int i = 0; i < nelems; i++)
+	{
+		if (nulls[i])
+		{
+		/*
+		 * A null value cannot match the equality condition.
+		 */
+			continue;
+		}
+		hashes[valid++] = calculate_hash(hash_fn, finfo, values[i]);
+	}
+
+	if (valid == 0)
+	{
+		/*
+		 * No non-null elements.
+		 */
+		PG_RETURN_BOOL(false);
+	}
+
+	/*
+	 * Sort the hashes for cache-friendly probing.
+	 */
+	pg_qsort(hashes, valid, sizeof(uint64), uint64_qsort_cmp);
+
+	/* Probe the bloom filter. */
+	struct varlena *bloom = PG_GETARG_VARLENA_P(0);
+	const uint64   *words = (const uint64 *) bloom1_words_buf(bloom);
+	uint32  num_bits      = bloom1_num_bits(bloom);  /* power of two */
+	uint32  abs_mask      = num_bits - 1;
+	uint32  word_bits     = sizeof(*words) * 8;
+	uint32  word_shift    = pg_leftmost_one_pos32(word_bits);
+	uint32  word_mask     = word_bits - 1;
+
+	for (int i = 0; i < valid; i++)
+	{
+		uint64 h = hashes[i];
+		bool   match = true;
+
+		for (int k = 0; k < BLOOM1_HASHES; k++)
+		{
+			uint32 bit  = bloom1_get_one_offset(h, k) & abs_mask;
+			uint32 word = bit >> word_shift;
+			uint32 off  = bit &  word_mask;
+
+			if ((words[word] & (UINT64_C(1) << off)) == 0)
+			{
+				match = false;
+				break;
+			}
+		}
+		if (match)
+			PG_RETURN_BOOL(true);           /* any element present */
+	}
+
+	PG_RETURN_BOOL(false);
+}
+
 static int
 bloom1_varlena_alloc_size(int num_bits)
 {

tsl/src/compression/sparse_index_bloom1.h

@@ -9,4 +9,6 @@
 
 Datum bloom1_contains(PG_FUNCTION_ARGS);
 
+Datum bloom1_contains_any(PG_FUNCTION_ARGS);
+
 PGFunction bloom1_get_hash_function(Oid type, FmgrInfo **finfo);