PolarDB-for-PostgreSQL

1
/*
2
 * contrib/btree_gin/btree_gin.c
3
 */
4
#include "postgres.h"
5

6
#include <limits.h>
7

8
#include "access/stratnum.h"
9
#include "utils/builtins.h"
10
#include "utils/bytea.h"
11
#include "utils/cash.h"
12
#include "utils/date.h"
13
#include "utils/inet.h"
14
#include "utils/numeric.h"
15
#include "utils/timestamp.h"
16
#include "utils/varbit.h"
17
#include "utils/uuid.h"
18

19
PG_MODULE_MAGIC;
20

21
typedef struct QueryInfo
22
{
23
	StrategyNumber strategy;
24
	Datum		datum;
25
	bool		is_varlena;
26
	Datum		(*typecmp) (FunctionCallInfo);
27
} QueryInfo;
28

29
/*** GIN support functions shared by all datatypes ***/
30

31
static Datum
32
gin_btree_extract_value(FunctionCallInfo fcinfo, bool is_varlena)
33
{
34
	Datum		datum = PG_GETARG_DATUM(0);
35
	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);
36
	Datum	   *entries = (Datum *) palloc(sizeof(Datum));
37

38
	if (is_varlena)
39
		datum = PointerGetDatum(PG_DETOAST_DATUM(datum));
40
	entries[0] = datum;
41
	*nentries = 1;
42

43
	PG_RETURN_POINTER(entries);
44
}
45

46
/*
47
 * For BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, and
48
 * BTEqualStrategyNumber we want to start the index scan at the
49
 * supplied query datum, and work forward. For BTLessStrategyNumber
50
 * and BTLessEqualStrategyNumber, we need to start at the leftmost
51
 * key, and work forward until the supplied query datum (which must be
52
 * sent along inside the QueryInfo structure).
53
 */
54
static Datum
55
gin_btree_extract_query(FunctionCallInfo fcinfo,
56
						bool is_varlena,
57
						Datum (*leftmostvalue) (void),
58
						Datum (*typecmp) (FunctionCallInfo))
59
{
60
	Datum		datum = PG_GETARG_DATUM(0);
61
	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);
62
	StrategyNumber strategy = PG_GETARG_UINT16(2);
63
	bool	  **partialmatch = (bool **) PG_GETARG_POINTER(3);
64
	Pointer   **extra_data = (Pointer **) PG_GETARG_POINTER(4);
65
	Datum	   *entries = (Datum *) palloc(sizeof(Datum));
66
	QueryInfo  *data = (QueryInfo *) palloc(sizeof(QueryInfo));
67
	bool	   *ptr_partialmatch;
68

69
	*nentries = 1;
70
	ptr_partialmatch = *partialmatch = (bool *) palloc(sizeof(bool));
71
	*ptr_partialmatch = false;
72
	if (is_varlena)
73
		datum = PointerGetDatum(PG_DETOAST_DATUM(datum));
74
	data->strategy = strategy;
75
	data->datum = datum;
76
	data->is_varlena = is_varlena;
77
	data->typecmp = typecmp;
78
	*extra_data = (Pointer *) palloc(sizeof(Pointer));
79
	**extra_data = (Pointer) data;
80

81
	switch (strategy)
82
	{
83
		case BTLessStrategyNumber:
84
		case BTLessEqualStrategyNumber:
85
			entries[0] = leftmostvalue();
86
			*ptr_partialmatch = true;
87
			break;
88
		case BTGreaterEqualStrategyNumber:
89
		case BTGreaterStrategyNumber:
90
			*ptr_partialmatch = true;
91
			/* FALLTHROUGH */
92
		case BTEqualStrategyNumber:
93
			entries[0] = datum;
94
			break;
95
		default:
96
			elog(ERROR, "unrecognized strategy number: %d", strategy);
97
	}
98

99
	PG_RETURN_POINTER(entries);
100
}
101

102
/*
103
 * Datum a is a value from extract_query method and for BTLess*
104
 * strategy it is a left-most value.  So, use original datum from QueryInfo
105
 * to decide to stop scanning or not.  Datum b is always from index.
106
 */
107
static Datum
108
gin_btree_compare_prefix(FunctionCallInfo fcinfo)
109
{
110
	Datum		a = PG_GETARG_DATUM(0);
111
	Datum		b = PG_GETARG_DATUM(1);
112
	QueryInfo  *data = (QueryInfo *) PG_GETARG_POINTER(3);
113
	int32		res,
114
				cmp;
115

116
	cmp = DatumGetInt32(CallerFInfoFunctionCall2(
117
												 data->typecmp,
118
												 fcinfo->flinfo,
119
												 PG_GET_COLLATION(),
120
												 (data->strategy == BTLessStrategyNumber ||
121
												  data->strategy == BTLessEqualStrategyNumber)
122
												 ? data->datum : a,
123
												 b));
124

125
	switch (data->strategy)
126
	{
127
		case BTLessStrategyNumber:
128
			/* If original datum > indexed one then return match */
129
			if (cmp > 0)
130
				res = 0;
131
			else
132
				res = 1;
133
			break;
134
		case BTLessEqualStrategyNumber:
135
			/* The same except equality */
136
			if (cmp >= 0)
137
				res = 0;
138
			else
139
				res = 1;
140
			break;
141
		case BTEqualStrategyNumber:
142
			if (cmp != 0)
143
				res = 1;
144
			else
145
				res = 0;
146
			break;
147
		case BTGreaterEqualStrategyNumber:
148
			/* If original datum <= indexed one then return match */
149
			if (cmp <= 0)
150
				res = 0;
151
			else
152
				res = 1;
153
			break;
154
		case BTGreaterStrategyNumber:
155
			/* If original datum <= indexed one then return match */
156
			/* If original datum == indexed one then continue scan */
157
			if (cmp < 0)
158
				res = 0;
159
			else if (cmp == 0)
160
				res = -1;
161
			else
162
				res = 1;
163
			break;
164
		default:
165
			elog(ERROR, "unrecognized strategy number: %d",
166
				 data->strategy);
167
			res = 0;
168
	}
169

170
	PG_RETURN_INT32(res);
171
}
172

173
PG_FUNCTION_INFO_V1(gin_btree_consistent);
174
Datum
175
gin_btree_consistent(PG_FUNCTION_ARGS)
176
{
177
	bool	   *recheck = (bool *) PG_GETARG_POINTER(5);
178

179
	*recheck = false;
180
	PG_RETURN_BOOL(true);
181
}
182

183
/*** GIN_SUPPORT macro defines the datatype specific functions ***/
184

185
#define GIN_SUPPORT(type, is_varlena, leftmostvalue, typecmp)				\
186
PG_FUNCTION_INFO_V1(gin_extract_value_##type);								\
187
Datum																		\
188
gin_extract_value_##type(PG_FUNCTION_ARGS)									\
189
{																			\
190
	return gin_btree_extract_value(fcinfo, is_varlena);						\
191
}	\
192
PG_FUNCTION_INFO_V1(gin_extract_query_##type);								\
193
Datum																		\
194
gin_extract_query_##type(PG_FUNCTION_ARGS)									\
195
{																			\
196
	return gin_btree_extract_query(fcinfo,									\
197
								   is_varlena, leftmostvalue, typecmp);		\
198
}	\
199
PG_FUNCTION_INFO_V1(gin_compare_prefix_##type);								\
200
Datum																		\
201
gin_compare_prefix_##type(PG_FUNCTION_ARGS)									\
202
{																			\
203
	return gin_btree_compare_prefix(fcinfo);								\
204
}
205

206

207
/*** Datatype specifications ***/
208

209
static Datum
210
leftmostvalue_int2(void)
211
{
212
	return Int16GetDatum(SHRT_MIN);
213
}
214

215
GIN_SUPPORT(int2, false, leftmostvalue_int2, btint2cmp)
216

217
static Datum
218
leftmostvalue_int4(void)
219
{
220
	return Int32GetDatum(INT_MIN);
221
}
222

223
GIN_SUPPORT(int4, false, leftmostvalue_int4, btint4cmp)
224

225
static Datum
226
leftmostvalue_int8(void)
227
{
228
	return Int64GetDatum(PG_INT64_MIN);
229
}
230

231
GIN_SUPPORT(int8, false, leftmostvalue_int8, btint8cmp)
232

233
static Datum
234
leftmostvalue_float4(void)
235
{
236
	return Float4GetDatum(-get_float4_infinity());
237
}
238

239
GIN_SUPPORT(float4, false, leftmostvalue_float4, btfloat4cmp)
240

241
static Datum
242
leftmostvalue_float8(void)
243
{
244
	return Float8GetDatum(-get_float8_infinity());
245
}
246

247
GIN_SUPPORT(float8, false, leftmostvalue_float8, btfloat8cmp)
248

249
static Datum
250
leftmostvalue_money(void)
251
{
252
	return Int64GetDatum(PG_INT64_MIN);
253
}
254

255
GIN_SUPPORT(money, false, leftmostvalue_money, cash_cmp)
256

257
static Datum
258
leftmostvalue_oid(void)
259
{
260
	return ObjectIdGetDatum(0);
261
}
262

263
GIN_SUPPORT(oid, false, leftmostvalue_oid, btoidcmp)
264

265
static Datum
266
leftmostvalue_timestamp(void)
267
{
268
	return TimestampGetDatum(DT_NOBEGIN);
269
}
270

271
GIN_SUPPORT(timestamp, false, leftmostvalue_timestamp, timestamp_cmp)
272

273
GIN_SUPPORT(timestamptz, false, leftmostvalue_timestamp, timestamp_cmp)
274

275
static Datum
276
leftmostvalue_time(void)
277
{
278
	return TimeADTGetDatum(0);
279
}
280

281
GIN_SUPPORT(time, false, leftmostvalue_time, time_cmp)
282

283
static Datum
284
leftmostvalue_timetz(void)
285
{
286
	TimeTzADT  *v = palloc(sizeof(TimeTzADT));
287

288
	v->time = 0;
289
	v->zone = -24 * 3600;		/* XXX is that true? */
290

291
	return TimeTzADTPGetDatum(v);
292
}
293

294
GIN_SUPPORT(timetz, false, leftmostvalue_timetz, timetz_cmp)
295

296
static Datum
297
leftmostvalue_date(void)
298
{
299
	return DateADTGetDatum(DATEVAL_NOBEGIN);
300
}
301

302
GIN_SUPPORT(date, false, leftmostvalue_date, date_cmp)
303

304
static Datum
305
leftmostvalue_interval(void)
306
{
307
	Interval   *v = palloc(sizeof(Interval));
308

309
	v->time = DT_NOBEGIN;
310
	v->day = 0;
311
	v->month = 0;
312
	return IntervalPGetDatum(v);
313
}
314

315
GIN_SUPPORT(interval, false, leftmostvalue_interval, interval_cmp)
316

317
static Datum
318
leftmostvalue_macaddr(void)
319
{
320
	macaddr    *v = palloc0(sizeof(macaddr));
321

322
	return MacaddrPGetDatum(v);
323
}
324

325
GIN_SUPPORT(macaddr, false, leftmostvalue_macaddr, macaddr_cmp)
326

327
static Datum
328
leftmostvalue_macaddr8(void)
329
{
330
	macaddr8   *v = palloc0(sizeof(macaddr8));
331

332
	return Macaddr8PGetDatum(v);
333
}
334

335
GIN_SUPPORT(macaddr8, false, leftmostvalue_macaddr8, macaddr8_cmp)
336

337
static Datum
338
leftmostvalue_inet(void)
339
{
340
	return DirectFunctionCall1(inet_in, CStringGetDatum("0.0.0.0/0"));
341
}
342

343
GIN_SUPPORT(inet, true, leftmostvalue_inet, network_cmp)
344

345
GIN_SUPPORT(cidr, true, leftmostvalue_inet, network_cmp)
346

347
static Datum
348
leftmostvalue_text(void)
349
{
350
	return PointerGetDatum(cstring_to_text_with_len("", 0));
351
}
352

353
GIN_SUPPORT(text, true, leftmostvalue_text, bttextcmp)
354

355
GIN_SUPPORT(bpchar, true, leftmostvalue_text, bpcharcmp)
356

357
static Datum
358
leftmostvalue_char(void)
359
{
360
	return CharGetDatum(SCHAR_MIN);
361
}
362

363
GIN_SUPPORT(char, false, leftmostvalue_char, btcharcmp)
364

365
GIN_SUPPORT(bytea, true, leftmostvalue_text, byteacmp)
366

367
static Datum
368
leftmostvalue_bit(void)
369
{
370
	return DirectFunctionCall3(bit_in,
371
							   CStringGetDatum(""),
372
							   ObjectIdGetDatum(0),
373
							   Int32GetDatum(-1));
374
}
375

376
GIN_SUPPORT(bit, true, leftmostvalue_bit, bitcmp)
377

378
static Datum
379
leftmostvalue_varbit(void)
380
{
381
	return DirectFunctionCall3(varbit_in,
382
							   CStringGetDatum(""),
383
							   ObjectIdGetDatum(0),
384
							   Int32GetDatum(-1));
385
}
386

387
GIN_SUPPORT(varbit, true, leftmostvalue_varbit, bitcmp)
388

389
/*
390
 * Numeric type hasn't a real left-most value, so we use PointerGetDatum(NULL)
391
 * (*not* a SQL NULL) to represent that.  We can get away with that because
392
 * the value returned by our leftmostvalue function will never be stored in
393
 * the index nor passed to anything except our compare and prefix-comparison
394
 * functions.  The same trick could be used for other pass-by-reference types.
395
 */
396

397
#define NUMERIC_IS_LEFTMOST(x)	((x) == NULL)
398

399
PG_FUNCTION_INFO_V1(gin_numeric_cmp);
400

401
Datum
402
gin_numeric_cmp(PG_FUNCTION_ARGS)
403
{
404
	Numeric		a = (Numeric) PG_GETARG_POINTER(0);
405
	Numeric		b = (Numeric) PG_GETARG_POINTER(1);
406
	int			res = 0;
407

408
	if (NUMERIC_IS_LEFTMOST(a))
409
	{
410
		res = (NUMERIC_IS_LEFTMOST(b)) ? 0 : -1;
411
	}
412
	else if (NUMERIC_IS_LEFTMOST(b))
413
	{
414
		res = 1;
415
	}
416
	else
417
	{
418
		res = DatumGetInt32(DirectFunctionCall2(numeric_cmp,
419
												NumericGetDatum(a),
420
												NumericGetDatum(b)));
421
	}
422

423
	PG_RETURN_INT32(res);
424
}
425

426
static Datum
427
leftmostvalue_numeric(void)
428
{
429
	return PointerGetDatum(NULL);
430
}
431

432
GIN_SUPPORT(numeric, true, leftmostvalue_numeric, gin_numeric_cmp)
433

434
/*
435
 * Use a similar trick to that used for numeric for enums, since we don't
436
 * actually know the leftmost value of any enum without knowing the concrete
437
 * type, so we use a dummy leftmost value of InvalidOid.
438
 *
439
 * Note that we use CallerFInfoFunctionCall2 here so that enum_cmp
440
 * gets a valid fn_extra to work with. Unlike most other type comparison
441
 * routines it needs it, so we can't use DirectFunctionCall2.
442
 */
443

444
#define ENUM_IS_LEFTMOST(x) ((x) == InvalidOid)
445

446
PG_FUNCTION_INFO_V1(gin_enum_cmp);
447

448
Datum
449
gin_enum_cmp(PG_FUNCTION_ARGS)
450
{
451
	Oid			a = PG_GETARG_OID(0);
452
	Oid			b = PG_GETARG_OID(1);
453
	int			res = 0;
454

455
	if (ENUM_IS_LEFTMOST(a))
456
	{
457
		res = (ENUM_IS_LEFTMOST(b)) ? 0 : -1;
458
	}
459
	else if (ENUM_IS_LEFTMOST(b))
460
	{
461
		res = 1;
462
	}
463
	else
464
	{
465
		res = DatumGetInt32(CallerFInfoFunctionCall2(
466
													 enum_cmp,
467
													 fcinfo->flinfo,
468
													 PG_GET_COLLATION(),
469
													 ObjectIdGetDatum(a),
470
													 ObjectIdGetDatum(b)));
471
	}
472

473
	PG_RETURN_INT32(res);
474
}
475

476
static Datum
477
leftmostvalue_enum(void)
478
{
479
	return ObjectIdGetDatum(InvalidOid);
480
}
481

482
GIN_SUPPORT(anyenum, false, leftmostvalue_enum, gin_enum_cmp)
483

484
static Datum
485
leftmostvalue_uuid(void)
486
{
487
	/*
488
	 * palloc0 will create the UUID with all zeroes:
489
	 * "00000000-0000-0000-0000-000000000000"
490
	 */
491
	pg_uuid_t  *retval = (pg_uuid_t *) palloc0(sizeof(pg_uuid_t));
492

493
	return UUIDPGetDatum(retval);
494
}
495

496
GIN_SUPPORT(uuid, false, leftmostvalue_uuid, uuid_cmp)
497

498
static Datum
499
leftmostvalue_name(void)
500
{
501
	NameData   *result = (NameData *) palloc0(NAMEDATALEN);
502

503
	return NameGetDatum(result);
504
}
505

506
GIN_SUPPORT(name, false, leftmostvalue_name, btnamecmp)
507

508
static Datum
509
leftmostvalue_bool(void)
510
{
511
	return BoolGetDatum(false);
512
}
513

514
GIN_SUPPORT(bool, false, leftmostvalue_bool, btboolcmp)
515