1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
/*
* contrib/btree_gist/btree_uuid.c
*/
#include "postgres.h"
#include "btree_gist.h"
#include "btree_utils_num.h"
#include "port/pg_bswap.h"
#include "utils/uuid.h"
typedef struct
{
pg_uuid_t lower,
upper;
} uuidKEY;
/*
* UUID ops
*/
PG_FUNCTION_INFO_V1(gbt_uuid_compress);
PG_FUNCTION_INFO_V1(gbt_uuid_fetch);
PG_FUNCTION_INFO_V1(gbt_uuid_union);
PG_FUNCTION_INFO_V1(gbt_uuid_picksplit);
PG_FUNCTION_INFO_V1(gbt_uuid_consistent);
PG_FUNCTION_INFO_V1(gbt_uuid_penalty);
PG_FUNCTION_INFO_V1(gbt_uuid_same);
static int
uuid_internal_cmp(const pg_uuid_t *arg1, const pg_uuid_t *arg2)
{
return memcmp(arg1->data, arg2->data, UUID_LEN);
}
static bool
gbt_uuidgt(const void *a, const void *b, FmgrInfo *flinfo)
{
return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) > 0;
}
static bool
gbt_uuidge(const void *a, const void *b, FmgrInfo *flinfo)
{
return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) >= 0;
}
static bool
gbt_uuideq(const void *a, const void *b, FmgrInfo *flinfo)
{
return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) == 0;
}
static bool
gbt_uuidle(const void *a, const void *b, FmgrInfo *flinfo)
{
return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) <= 0;
}
static bool
gbt_uuidlt(const void *a, const void *b, FmgrInfo *flinfo)
{
return uuid_internal_cmp((const pg_uuid_t *) a, (const pg_uuid_t *) b) < 0;
}
static int
gbt_uuidkey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
{
uuidKEY *ia = (uuidKEY *) (((const Nsrt *) a)->t);
uuidKEY *ib = (uuidKEY *) (((const Nsrt *) b)->t);
int res;
res = uuid_internal_cmp(&ia->lower, &ib->lower);
if (res == 0)
res = uuid_internal_cmp(&ia->upper, &ib->upper);
return res;
}
static const gbtree_ninfo tinfo =
{
gbt_t_uuid,
UUID_LEN,
32, /* sizeof(gbtreekey32) */
gbt_uuidgt,
gbt_uuidge,
gbt_uuideq,
gbt_uuidle,
gbt_uuidlt,
gbt_uuidkey_cmp,
NULL
};
/**************************************************
* uuid ops
**************************************************/
Datum
gbt_uuid_compress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval;
if (entry->leafkey)
{
char *r = (char *) palloc(2 * UUID_LEN);
pg_uuid_t *key = DatumGetUUIDP(entry->key);
retval = palloc(sizeof(GISTENTRY));
memcpy((void *) r, (void *) key, UUID_LEN);
memcpy((void *) (r + UUID_LEN), (void *) key, UUID_LEN);
gistentryinit(*retval, PointerGetDatum(r),
entry->rel, entry->page,
entry->offset, false);
}
else
retval = entry;
PG_RETURN_POINTER(retval);
}
Datum
gbt_uuid_fetch(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo));
}
Datum
gbt_uuid_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
pg_uuid_t *query = PG_GETARG_UUID_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
uuidKEY *kkk = (uuidKEY *) DatumGetPointer(entry->key);
GBT_NUMKEY_R key;
/* All cases served by this function are exact */
*recheck = false;
key.lower = (GBT_NUMKEY *) &kkk->lower;
key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) query, &strategy,
GIST_LEAF(entry), &tinfo,
fcinfo->flinfo));
}
Datum
gbt_uuid_union(PG_FUNCTION_ARGS)
{
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
void *out = palloc(sizeof(uuidKEY));
*(int *) PG_GETARG_POINTER(1) = sizeof(uuidKEY);
PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo));
}
/*
* Convert a uuid to a "double" value for estimating sizes of ranges.
*/
static double
uuid_2_double(const pg_uuid_t *u)
{
uint64 uu[2];
const double two64 = 18446744073709551616.0; /* 2^64 */
/* Source data may not be suitably aligned, so copy */
memcpy(uu, u->data, UUID_LEN);
/*
* uuid values should be considered as big-endian numbers, since that
* corresponds to how memcmp will compare them. On a little-endian
* machine, byte-swap each half so we can use native uint64 arithmetic.
*/
#ifndef WORDS_BIGENDIAN
uu[0] = pg_bswap64(uu[0]);
uu[1] = pg_bswap64(uu[1]);
#endif
/*
* 2^128 is about 3.4e38, which in theory could exceed the range of
* "double" (POSIX only requires 1e37). To avoid any risk of overflow,
* put the decimal point between the two halves rather than treating the
* uuid value as a 128-bit integer.
*/
return (double) uu[0] + (double) uu[1] / two64;
}
Datum
gbt_uuid_penalty(PG_FUNCTION_ARGS)
{
uuidKEY *origentry = (uuidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
uuidKEY *newentry = (uuidKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *result = (float *) PG_GETARG_POINTER(2);
double olower,
oupper,
nlower,
nupper;
olower = uuid_2_double(&origentry->lower);
oupper = uuid_2_double(&origentry->upper);
nlower = uuid_2_double(&newentry->lower);
nupper = uuid_2_double(&newentry->upper);
penalty_num(result, olower, oupper, nlower, nupper);
PG_RETURN_POINTER(result);
}
Datum
gbt_uuid_picksplit(PG_FUNCTION_ARGS)
{
PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0),
(GIST_SPLITVEC *) PG_GETARG_POINTER(1),
&tinfo, fcinfo->flinfo));
}
Datum
gbt_uuid_same(PG_FUNCTION_ARGS)
{
uuidKEY *b1 = (uuidKEY *) PG_GETARG_POINTER(0);
uuidKEY *b2 = (uuidKEY *) PG_GETARG_POINTER(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
*result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo);
PG_RETURN_POINTER(result);
}
|
