Adding upstream version 14.5.upstream/14.5upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 513 insertions, 0 deletions

diff --git a/contrib/btree_gin/btree_gin.c b/contrib/btree_gin/btree_gin.c
new file mode 100644
index 0000000..c50d68c
--- /dev/null
+++ b/contrib/btree_gin/btree_gin.c
@@ -0,0 +1,513 @@
+/*
+ * contrib/btree_gin/btree_gin.c
+ */
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "access/stratnum.h"
+#include "utils/builtins.h"
+#include "utils/bytea.h"
+#include "utils/cash.h"
+#include "utils/date.h"
+#include "utils/float.h"
+#include "utils/inet.h"
+#include "utils/numeric.h"
+#include "utils/timestamp.h"
+#include "utils/uuid.h"
+#include "utils/varbit.h"
+
+PG_MODULE_MAGIC;
+
+typedef struct QueryInfo
+{
+	StrategyNumber strategy;
+	Datum		datum;
+	bool		is_varlena;
+	Datum		(*typecmp) (FunctionCallInfo);
+} QueryInfo;
+
+/*** GIN support functions shared by all datatypes ***/
+
+static Datum
+gin_btree_extract_value(FunctionCallInfo fcinfo, bool is_varlena)
+{
+	Datum		datum = PG_GETARG_DATUM(0);
+	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);
+	Datum	   *entries = (Datum *) palloc(sizeof(Datum));
+
+	if (is_varlena)
+		datum = PointerGetDatum(PG_DETOAST_DATUM(datum));
+	entries[0] = datum;
+	*nentries = 1;
+
+	PG_RETURN_POINTER(entries);
+}
+
+/*
+ * For BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, and
+ * BTEqualStrategyNumber we want to start the index scan at the
+ * supplied query datum, and work forward. For BTLessStrategyNumber
+ * and BTLessEqualStrategyNumber, we need to start at the leftmost
+ * key, and work forward until the supplied query datum (which must be
+ * sent along inside the QueryInfo structure).
+ */
+static Datum
+gin_btree_extract_query(FunctionCallInfo fcinfo,
+						bool is_varlena,
+						Datum (*leftmostvalue) (void),
+						Datum (*typecmp) (FunctionCallInfo))
+{
+	Datum		datum = PG_GETARG_DATUM(0);
+	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);
+	StrategyNumber strategy = PG_GETARG_UINT16(2);
+	bool	  **partialmatch = (bool **) PG_GETARG_POINTER(3);
+	Pointer   **extra_data = (Pointer **) PG_GETARG_POINTER(4);
+	Datum	   *entries = (Datum *) palloc(sizeof(Datum));
+	QueryInfo  *data = (QueryInfo *) palloc(sizeof(QueryInfo));
+	bool	   *ptr_partialmatch;
+
+	*nentries = 1;
+	ptr_partialmatch = *partialmatch = (bool *) palloc(sizeof(bool));
+	*ptr_partialmatch = false;
+	if (is_varlena)
+		datum = PointerGetDatum(PG_DETOAST_DATUM(datum));
+	data->strategy = strategy;
+	data->datum = datum;
+	data->is_varlena = is_varlena;
+	data->typecmp = typecmp;
+	*extra_data = (Pointer *) palloc(sizeof(Pointer));
+	**extra_data = (Pointer) data;
+
+	switch (strategy)
+	{
+		case BTLessStrategyNumber:
+		case BTLessEqualStrategyNumber:
+			entries[0] = leftmostvalue();
+			*ptr_partialmatch = true;
+			break;
+		case BTGreaterEqualStrategyNumber:
+		case BTGreaterStrategyNumber:
+			*ptr_partialmatch = true;
+			/* FALLTHROUGH */
+		case BTEqualStrategyNumber:
+			entries[0] = datum;
+			break;
+		default:
+			elog(ERROR, "unrecognized strategy number: %d", strategy);
+	}
+
+	PG_RETURN_POINTER(entries);
+}
+
+/*
+ * Datum a is a value from extract_query method and for BTLess*
+ * strategy it is a left-most value.  So, use original datum from QueryInfo
+ * to decide to stop scanning or not.  Datum b is always from index.
+ */
+static Datum
+gin_btree_compare_prefix(FunctionCallInfo fcinfo)
+{
+	Datum		a = PG_GETARG_DATUM(0);
+	Datum		b = PG_GETARG_DATUM(1);
+	QueryInfo  *data = (QueryInfo *) PG_GETARG_POINTER(3);
+	int32		res,
+				cmp;
+
+	cmp = DatumGetInt32(CallerFInfoFunctionCall2(data->typecmp,
+												 fcinfo->flinfo,
+												 PG_GET_COLLATION(),
+												 (data->strategy == BTLessStrategyNumber ||
+												  data->strategy == BTLessEqualStrategyNumber)
+												 ? data->datum : a,
+												 b));
+
+	switch (data->strategy)
+	{
+		case BTLessStrategyNumber:
+			/* If original datum > indexed one then return match */
+			if (cmp > 0)
+				res = 0;
+			else
+				res = 1;
+			break;
+		case BTLessEqualStrategyNumber:
+			/* The same except equality */
+			if (cmp >= 0)
+				res = 0;
+			else
+				res = 1;
+			break;
+		case BTEqualStrategyNumber:
+			if (cmp != 0)
+				res = 1;
+			else
+				res = 0;
+			break;
+		case BTGreaterEqualStrategyNumber:
+			/* If original datum <= indexed one then return match */
+			if (cmp <= 0)
+				res = 0;
+			else
+				res = 1;
+			break;
+		case BTGreaterStrategyNumber:
+			/* If original datum <= indexed one then return match */
+			/* If original datum == indexed one then continue scan */
+			if (cmp < 0)
+				res = 0;
+			else if (cmp == 0)
+				res = -1;
+			else
+				res = 1;
+			break;
+		default:
+			elog(ERROR, "unrecognized strategy number: %d",
+				 data->strategy);
+			res = 0;
+	}
+
+	PG_RETURN_INT32(res);
+}
+
+PG_FUNCTION_INFO_V1(gin_btree_consistent);
+Datum
+gin_btree_consistent(PG_FUNCTION_ARGS)
+{
+	bool	   *recheck = (bool *) PG_GETARG_POINTER(5);
+
+	*recheck = false;
+	PG_RETURN_BOOL(true);
+}
+
+/*** GIN_SUPPORT macro defines the datatype specific functions ***/
+
+#define GIN_SUPPORT(type, is_varlena, leftmostvalue, typecmp)				\
+PG_FUNCTION_INFO_V1(gin_extract_value_##type);								\
+Datum																		\
+gin_extract_value_##type(PG_FUNCTION_ARGS)									\
+{																			\
+	return gin_btree_extract_value(fcinfo, is_varlena);						\
+}	\
+PG_FUNCTION_INFO_V1(gin_extract_query_##type);								\
+Datum																		\
+gin_extract_query_##type(PG_FUNCTION_ARGS)									\
+{																			\
+	return gin_btree_extract_query(fcinfo,									\
+								   is_varlena, leftmostvalue, typecmp);		\
+}	\
+PG_FUNCTION_INFO_V1(gin_compare_prefix_##type);								\
+Datum																		\
+gin_compare_prefix_##type(PG_FUNCTION_ARGS)									\
+{																			\
+	return gin_btree_compare_prefix(fcinfo);								\
+}
+
+
+/*** Datatype specifications ***/
+
+static Datum
+leftmostvalue_int2(void)
+{
+	return Int16GetDatum(SHRT_MIN);
+}
+
+GIN_SUPPORT(int2, false, leftmostvalue_int2, btint2cmp)
+
+static Datum
+leftmostvalue_int4(void)
+{
+	return Int32GetDatum(INT_MIN);
+}
+
+GIN_SUPPORT(int4, false, leftmostvalue_int4, btint4cmp)
+
+static Datum
+leftmostvalue_int8(void)
+{
+	return Int64GetDatum(PG_INT64_MIN);
+}
+
+GIN_SUPPORT(int8, false, leftmostvalue_int8, btint8cmp)
+
+static Datum
+leftmostvalue_float4(void)
+{
+	return Float4GetDatum(-get_float4_infinity());
+}
+
+GIN_SUPPORT(float4, false, leftmostvalue_float4, btfloat4cmp)
+
+static Datum
+leftmostvalue_float8(void)
+{
+	return Float8GetDatum(-get_float8_infinity());
+}
+
+GIN_SUPPORT(float8, false, leftmostvalue_float8, btfloat8cmp)
+
+static Datum
+leftmostvalue_money(void)
+{
+	return Int64GetDatum(PG_INT64_MIN);
+}
+
+GIN_SUPPORT(money, false, leftmostvalue_money, cash_cmp)
+
+static Datum
+leftmostvalue_oid(void)
+{
+	return ObjectIdGetDatum(0);
+}
+
+GIN_SUPPORT(oid, false, leftmostvalue_oid, btoidcmp)
+
+static Datum
+leftmostvalue_timestamp(void)
+{
+	return TimestampGetDatum(DT_NOBEGIN);
+}
+
+GIN_SUPPORT(timestamp, false, leftmostvalue_timestamp, timestamp_cmp)
+
+GIN_SUPPORT(timestamptz, false, leftmostvalue_timestamp, timestamp_cmp)
+
+static Datum
+leftmostvalue_time(void)
+{
+	return TimeADTGetDatum(0);
+}
+
+GIN_SUPPORT(time, false, leftmostvalue_time, time_cmp)
+
+static Datum
+leftmostvalue_timetz(void)
+{
+	TimeTzADT  *v = palloc(sizeof(TimeTzADT));
+
+	v->time = 0;
+	v->zone = -24 * 3600;		/* XXX is that true? */
+
+	return TimeTzADTPGetDatum(v);
+}
+
+GIN_SUPPORT(timetz, false, leftmostvalue_timetz, timetz_cmp)
+
+static Datum
+leftmostvalue_date(void)
+{
+	return DateADTGetDatum(DATEVAL_NOBEGIN);
+}
+
+GIN_SUPPORT(date, false, leftmostvalue_date, date_cmp)
+
+static Datum
+leftmostvalue_interval(void)
+{
+	Interval   *v = palloc(sizeof(Interval));
+
+	v->time = DT_NOBEGIN;
+	v->day = 0;
+	v->month = 0;
+	return IntervalPGetDatum(v);
+}
+
+GIN_SUPPORT(interval, false, leftmostvalue_interval, interval_cmp)
+
+static Datum
+leftmostvalue_macaddr(void)
+{
+	macaddr    *v = palloc0(sizeof(macaddr));
+
+	return MacaddrPGetDatum(v);
+}
+
+GIN_SUPPORT(macaddr, false, leftmostvalue_macaddr, macaddr_cmp)
+
+static Datum
+leftmostvalue_macaddr8(void)
+{
+	macaddr8   *v = palloc0(sizeof(macaddr8));
+
+	return Macaddr8PGetDatum(v);
+}
+
+GIN_SUPPORT(macaddr8, false, leftmostvalue_macaddr8, macaddr8_cmp)
+
+static Datum
+leftmostvalue_inet(void)
+{
+	return DirectFunctionCall1(inet_in, CStringGetDatum("0.0.0.0/0"));
+}
+
+GIN_SUPPORT(inet, true, leftmostvalue_inet, network_cmp)
+
+GIN_SUPPORT(cidr, true, leftmostvalue_inet, network_cmp)
+
+static Datum
+leftmostvalue_text(void)
+{
+	return PointerGetDatum(cstring_to_text_with_len("", 0));
+}
+
+GIN_SUPPORT(text, true, leftmostvalue_text, bttextcmp)
+
+GIN_SUPPORT(bpchar, true, leftmostvalue_text, bpcharcmp)
+
+static Datum
+leftmostvalue_char(void)
+{
+	return CharGetDatum(0);
+}
+
+GIN_SUPPORT(char, false, leftmostvalue_char, btcharcmp)
+
+GIN_SUPPORT(bytea, true, leftmostvalue_text, byteacmp)
+
+static Datum
+leftmostvalue_bit(void)
+{
+	return DirectFunctionCall3(bit_in,
+							   CStringGetDatum(""),
+							   ObjectIdGetDatum(0),
+							   Int32GetDatum(-1));
+}
+
+GIN_SUPPORT(bit, true, leftmostvalue_bit, bitcmp)
+
+static Datum
+leftmostvalue_varbit(void)
+{
+	return DirectFunctionCall3(varbit_in,
+							   CStringGetDatum(""),
+							   ObjectIdGetDatum(0),
+							   Int32GetDatum(-1));
+}
+
+GIN_SUPPORT(varbit, true, leftmostvalue_varbit, bitcmp)
+
+/*
+ * Numeric type hasn't a real left-most value, so we use PointerGetDatum(NULL)
+ * (*not* a SQL NULL) to represent that.  We can get away with that because
+ * the value returned by our leftmostvalue function will never be stored in
+ * the index nor passed to anything except our compare and prefix-comparison
+ * functions.  The same trick could be used for other pass-by-reference types.
+ */
+
+#define NUMERIC_IS_LEFTMOST(x)	((x) == NULL)
+
+PG_FUNCTION_INFO_V1(gin_numeric_cmp);
+
+Datum
+gin_numeric_cmp(PG_FUNCTION_ARGS)
+{
+	Numeric		a = (Numeric) PG_GETARG_POINTER(0);
+	Numeric		b = (Numeric) PG_GETARG_POINTER(1);
+	int			res = 0;
+
+	if (NUMERIC_IS_LEFTMOST(a))
+	{
+		res = (NUMERIC_IS_LEFTMOST(b)) ? 0 : -1;
+	}
+	else if (NUMERIC_IS_LEFTMOST(b))
+	{
+		res = 1;
+	}
+	else
+	{
+		res = DatumGetInt32(DirectFunctionCall2(numeric_cmp,
+												NumericGetDatum(a),
+												NumericGetDatum(b)));
+	}
+
+	PG_RETURN_INT32(res);
+}
+
+static Datum
+leftmostvalue_numeric(void)
+{
+	return PointerGetDatum(NULL);
+}
+
+GIN_SUPPORT(numeric, true, leftmostvalue_numeric, gin_numeric_cmp)
+
+/*
+ * Use a similar trick to that used for numeric for enums, since we don't
+ * actually know the leftmost value of any enum without knowing the concrete
+ * type, so we use a dummy leftmost value of InvalidOid.
+ *
+ * Note that we use CallerFInfoFunctionCall2 here so that enum_cmp
+ * gets a valid fn_extra to work with. Unlike most other type comparison
+ * routines it needs it, so we can't use DirectFunctionCall2.
+ */
+
+#define ENUM_IS_LEFTMOST(x) ((x) == InvalidOid)
+
+PG_FUNCTION_INFO_V1(gin_enum_cmp);
+
+Datum
+gin_enum_cmp(PG_FUNCTION_ARGS)
+{
+	Oid			a = PG_GETARG_OID(0);
+	Oid			b = PG_GETARG_OID(1);
+	int			res = 0;
+
+	if (ENUM_IS_LEFTMOST(a))
+	{
+		res = (ENUM_IS_LEFTMOST(b)) ? 0 : -1;
+	}
+	else if (ENUM_IS_LEFTMOST(b))
+	{
+		res = 1;
+	}
+	else
+	{
+		res = DatumGetInt32(CallerFInfoFunctionCall2(enum_cmp,
+													 fcinfo->flinfo,
+													 PG_GET_COLLATION(),
+													 ObjectIdGetDatum(a),
+													 ObjectIdGetDatum(b)));
+	}
+
+	PG_RETURN_INT32(res);
+}
+
+static Datum
+leftmostvalue_enum(void)
+{
+	return ObjectIdGetDatum(InvalidOid);
+}
+
+GIN_SUPPORT(anyenum, false, leftmostvalue_enum, gin_enum_cmp)
+
+static Datum
+leftmostvalue_uuid(void)
+{
+	/*
+	 * palloc0 will create the UUID with all zeroes:
+	 * "00000000-0000-0000-0000-000000000000"
+	 */
+	pg_uuid_t  *retval = (pg_uuid_t *) palloc0(sizeof(pg_uuid_t));
+
+	return UUIDPGetDatum(retval);
+}
+
+GIN_SUPPORT(uuid, false, leftmostvalue_uuid, uuid_cmp)
+
+static Datum
+leftmostvalue_name(void)
+{
+	NameData   *result = (NameData *) palloc0(NAMEDATALEN);
+
+	return NameGetDatum(result);
+}
+
+GIN_SUPPORT(name, false, leftmostvalue_name, btnamecmp)
+
+static Datum
+leftmostvalue_bool(void)
+{
+	return BoolGetDatum(false);
+}
+
+GIN_SUPPORT(bool, false, leftmostvalue_bool, btboolcmp)