mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-08-31 18:47:20 +02:00
We used to strategically place newlines after some function call left parentheses to make pgindent move the argument list a few chars to the left, so that the whole line would fit under 80 chars. However, pgindent no longer does that, so the newlines just made the code vertically longer for no reason. Remove those newlines, and reflow some of those lines for some extra naturality. Reviewed-by: Michael Paquier, Tom Lane Discussion: https://postgr.es/m/20200129200401.GA6303@alvherre.pgsql
514 lines
11 KiB
C
514 lines
11 KiB
C
/*
|
|
* 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(SCHAR_MIN);
|
|
}
|
|
|
|
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)
|