PostgreSQL Source Code: contrib/btree_gist/btree_interval.c Source File

PostgreSQL Source Code git master
btree_interval.c
Go to the documentation of this file.
1/*
2 * contrib/btree_gist/btree_interval.c
3 */
4#include "postgres.h"
5
6#include "btree_gist.h"
7#include "btree_utils_num.h"
8#include "utils/fmgrprotos.h"
9#include "utils/rel.h"
10#include "utils/sortsupport.h"
11#include "utils/timestamp.h"
12
13 typedef struct
14{
15 Interval lower,
16 upper;
17} intvKEY;
18
19/* GiST support functions */
20 PG_FUNCTION_INFO_V1(gbt_intv_compress);
21 PG_FUNCTION_INFO_V1(gbt_intv_fetch);
22 PG_FUNCTION_INFO_V1(gbt_intv_decompress);
23 PG_FUNCTION_INFO_V1(gbt_intv_union);
24 PG_FUNCTION_INFO_V1(gbt_intv_picksplit);
25 PG_FUNCTION_INFO_V1(gbt_intv_consistent);
26 PG_FUNCTION_INFO_V1(gbt_intv_distance);
27 PG_FUNCTION_INFO_V1(gbt_intv_penalty);
28 PG_FUNCTION_INFO_V1(gbt_intv_same);
29 PG_FUNCTION_INFO_V1(gbt_intv_sortsupport);
30
31
32static bool
33 gbt_intvgt(const void *a, const void *b, FmgrInfo *flinfo)
34{
35 return DatumGetBool(DirectFunctionCall2(interval_gt, IntervalPGetDatum(a), IntervalPGetDatum(b)));
36}
37
38static bool
39 gbt_intvge(const void *a, const void *b, FmgrInfo *flinfo)
40{
41 return DatumGetBool(DirectFunctionCall2(interval_ge, IntervalPGetDatum(a), IntervalPGetDatum(b)));
42}
43
44static bool
45 gbt_intveq(const void *a, const void *b, FmgrInfo *flinfo)
46{
47 return DatumGetBool(DirectFunctionCall2(interval_eq, IntervalPGetDatum(a), IntervalPGetDatum(b)));
48}
49
50static bool
51 gbt_intvle(const void *a, const void *b, FmgrInfo *flinfo)
52{
53 return DatumGetBool(DirectFunctionCall2(interval_le, IntervalPGetDatum(a), IntervalPGetDatum(b)));
54}
55
56static bool
57 gbt_intvlt(const void *a, const void *b, FmgrInfo *flinfo)
58{
59 return DatumGetBool(DirectFunctionCall2(interval_lt, IntervalPGetDatum(a), IntervalPGetDatum(b)));
60}
61
62static int
63 gbt_intvkey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
64{
65 intvKEY *ia = (intvKEY *) (((const Nsrt *) a)->t);
66 intvKEY *ib = (intvKEY *) (((const Nsrt *) b)->t);
67 int res;
68
69 res = DatumGetInt32(DirectFunctionCall2(interval_cmp, IntervalPGetDatum(&ia->lower), IntervalPGetDatum(&ib->lower)));
70 if (res == 0)
71 return DatumGetInt32(DirectFunctionCall2(interval_cmp, IntervalPGetDatum(&ia->upper), IntervalPGetDatum(&ib->upper)));
72
73 return res;
74}
75
76
77static double
78 intr2num(const Interval *i)
79{
80 return INTERVAL_TO_SEC(i);
81}
82
83static float8
84 gbt_intv_dist(const void *a, const void *b, FmgrInfo *flinfo)
85{
86 return fabs(intr2num((const Interval *) a) - intr2num((const Interval *) b));
87}
88
89/*
90 * INTERVALSIZE should be the actual size-on-disk of an Interval, as shown
91 * in pg_type. This might be less than sizeof(Interval) if the compiler
92 * insists on adding alignment padding at the end of the struct. (Note:
93 * this concern is obsolete with the current definition of Interval, but
94 * was real before a separate "day" field was added to it.)
95 */
96 #define INTERVALSIZE 16
97
98 static const gbtree_ninfo tinfo =
99{
100 gbt_t_intv,
101 sizeof(Interval),
102 32, /* sizeof(gbtreekey32) */
103 gbt_intvgt,
104 gbt_intvge,
105 gbt_intveq,
106 gbt_intvle,
107 gbt_intvlt,
108 gbt_intvkey_cmp,
109 gbt_intv_dist
110};
111
112
113Interval *
114 abs_interval(Interval *a)
115{
116 static const Interval zero = {0, 0, 0};
117
118 if (DatumGetBool(DirectFunctionCall2(interval_lt,
119 IntervalPGetDatum(a),
120 IntervalPGetDatum(&zero))))
121 a = DatumGetIntervalP(DirectFunctionCall1(interval_um,
122 IntervalPGetDatum(a)));
123
124 return a;
125}
126
127 PG_FUNCTION_INFO_V1(interval_dist);
128Datum
129 interval_dist(PG_FUNCTION_ARGS)
130{
131 Datum diff = DirectFunctionCall2(interval_mi,
132 PG_GETARG_DATUM(0),
133 PG_GETARG_DATUM(1));
134
135 PG_RETURN_INTERVAL_P(abs_interval(DatumGetIntervalP(diff)));
136}
137
138
139/**************************************************
140 * GiST support functions
141 **************************************************/
142
143Datum
144 gbt_intv_compress(PG_FUNCTION_ARGS)
145{
146 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
147 GISTENTRY *retval = entry;
148
149 if (entry->leafkey || INTERVALSIZE != sizeof(Interval))
150 {
151 char *r = (char *) palloc(2 * INTERVALSIZE);
152
153 retval = palloc(sizeof(GISTENTRY));
154
155 if (entry->leafkey)
156 {
157 Interval *key = DatumGetIntervalP(entry->key);
158
159 memcpy(r, key, INTERVALSIZE);
160 memcpy(r + INTERVALSIZE, key, INTERVALSIZE);
161 }
162 else
163 {
164 intvKEY *key = (intvKEY *) DatumGetPointer(entry->key);
165
166 memcpy(r, &key->lower, INTERVALSIZE);
167 memcpy(r + INTERVALSIZE, &key->upper, INTERVALSIZE);
168 }
169 gistentryinit(*retval, PointerGetDatum(r),
170 entry->rel, entry->page,
171 entry->offset, false);
172 }
173
174 PG_RETURN_POINTER(retval);
175}
176
177Datum
178 gbt_intv_fetch(PG_FUNCTION_ARGS)
179{
180 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
181
182 PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo));
183}
184
185Datum
186 gbt_intv_decompress(PG_FUNCTION_ARGS)
187{
188 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
189 GISTENTRY *retval = entry;
190
191 if (INTERVALSIZE != sizeof(Interval))
192 {
193 intvKEY *r = palloc(sizeof(intvKEY));
194 char *key = DatumGetPointer(entry->key);
195
196 retval = palloc(sizeof(GISTENTRY));
197 memcpy(&r->lower, key, INTERVALSIZE);
198 memcpy(&r->upper, key + INTERVALSIZE, INTERVALSIZE);
199
200 gistentryinit(*retval, PointerGetDatum(r),
201 entry->rel, entry->page,
202 entry->offset, false);
203 }
204 PG_RETURN_POINTER(retval);
205}
206
207
208Datum
209 gbt_intv_consistent(PG_FUNCTION_ARGS)
210{
211 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
212 Interval *query = PG_GETARG_INTERVAL_P(1);
213 StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
214
215 /* Oid subtype = PG_GETARG_OID(3); */
216 bool *recheck = (bool *) PG_GETARG_POINTER(4);
217 intvKEY *kkk = (intvKEY *) DatumGetPointer(entry->key);
218 GBT_NUMKEY_R key;
219
220 /* All cases served by this function are exact */
221 *recheck = false;
222
223 key.lower = (GBT_NUMKEY *) &kkk->lower;
224 key.upper = (GBT_NUMKEY *) &kkk->upper;
225
226 PG_RETURN_BOOL(gbt_num_consistent(&key, query, &strategy,
227 GIST_LEAF(entry), &tinfo, fcinfo->flinfo));
228}
229
230
231Datum
232 gbt_intv_distance(PG_FUNCTION_ARGS)
233{
234 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
235 Interval *query = PG_GETARG_INTERVAL_P(1);
236
237 /* Oid subtype = PG_GETARG_OID(3); */
238 intvKEY *kkk = (intvKEY *) DatumGetPointer(entry->key);
239 GBT_NUMKEY_R key;
240
241 key.lower = (GBT_NUMKEY *) &kkk->lower;
242 key.upper = (GBT_NUMKEY *) &kkk->upper;
243
244 PG_RETURN_FLOAT8(gbt_num_distance(&key, query, GIST_LEAF(entry),
245 &tinfo, fcinfo->flinfo));
246}
247
248
249Datum
250 gbt_intv_union(PG_FUNCTION_ARGS)
251{
252 GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
253 void *out = palloc(sizeof(intvKEY));
254
255 *(int *) PG_GETARG_POINTER(1) = sizeof(intvKEY);
256 PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo));
257}
258
259
260Datum
261 gbt_intv_penalty(PG_FUNCTION_ARGS)
262{
263 intvKEY *origentry = (intvKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
264 intvKEY *newentry = (intvKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
265 float *result = (float *) PG_GETARG_POINTER(2);
266 double iorg[2],
267 inew[2];
268
269 iorg[0] = intr2num(&origentry->lower);
270 iorg[1] = intr2num(&origentry->upper);
271 inew[0] = intr2num(&newentry->lower);
272 inew[1] = intr2num(&newentry->upper);
273
274 penalty_num(result, iorg[0], iorg[1], inew[0], inew[1]);
275
276 PG_RETURN_POINTER(result);
277}
278
279Datum
280 gbt_intv_picksplit(PG_FUNCTION_ARGS)
281{
282 PG_RETURN_POINTER(gbt_num_picksplit((GistEntryVector *) PG_GETARG_POINTER(0),
283 (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
284 &tinfo, fcinfo->flinfo));
285}
286
287Datum
288 gbt_intv_same(PG_FUNCTION_ARGS)
289{
290 intvKEY *b1 = (intvKEY *) PG_GETARG_POINTER(0);
291 intvKEY *b2 = (intvKEY *) PG_GETARG_POINTER(1);
292 bool *result = (bool *) PG_GETARG_POINTER(2);
293
294 *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo);
295 PG_RETURN_POINTER(result);
296}
297
298static int
299 gbt_intv_ssup_cmp(Datum x, Datum y, SortSupport ssup)
300{
301 intvKEY *arg1 = (intvKEY *) DatumGetPointer(x);
302 intvKEY *arg2 = (intvKEY *) DatumGetPointer(y);
303
304 /* for leaf items we expect lower == upper, so only compare lower */
305 return DatumGetInt32(DirectFunctionCall2(interval_cmp,
306 IntervalPGetDatum(&arg1->lower),
307 IntervalPGetDatum(&arg2->lower)));
308}
309
310Datum
311 gbt_intv_sortsupport(PG_FUNCTION_ARGS)
312{
313 SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
314
315 ssup->comparator = gbt_intv_ssup_cmp;
316 ssup->ssup_extra = NULL;
317
318 PG_RETURN_VOID();
319}
Datum interval_gt(PG_FUNCTION_ARGS)
Definition: timestamp.c:2588
Datum interval_le(PG_FUNCTION_ARGS)
Definition: timestamp.c:2597
Datum interval_mi(PG_FUNCTION_ARGS)
Definition: timestamp.c:3556
Datum interval_lt(PG_FUNCTION_ARGS)
Definition: timestamp.c:2579
Datum interval_cmp(PG_FUNCTION_ARGS)
Definition: timestamp.c:2615
Datum interval_um(PG_FUNCTION_ARGS)
Definition: timestamp.c:3443
Datum interval_ge(PG_FUNCTION_ARGS)
Definition: timestamp.c:2606
Datum interval_eq(PG_FUNCTION_ARGS)
Definition: timestamp.c:2561
@ gbt_t_intv
Definition: btree_gist.h:28
Datum gbt_intv_compress(PG_FUNCTION_ARGS)
static bool gbt_intvge(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_interval.c:39
Datum gbt_intv_decompress(PG_FUNCTION_ARGS)
Interval * abs_interval(Interval *a)
Datum gbt_intv_distance(PG_FUNCTION_ARGS)
static bool gbt_intvle(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_interval.c:51
Datum gbt_intv_fetch(PG_FUNCTION_ARGS)
static int gbt_intv_ssup_cmp(Datum x, Datum y, SortSupport ssup)
Datum gbt_intv_union(PG_FUNCTION_ARGS)
static double intr2num(const Interval *i)
Definition: btree_interval.c:78
static float8 gbt_intv_dist(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_interval.c:84
Datum gbt_intv_penalty(PG_FUNCTION_ARGS)
Datum gbt_intv_consistent(PG_FUNCTION_ARGS)
static bool gbt_intvgt(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_interval.c:33
static bool gbt_intvlt(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_interval.c:57
static int gbt_intvkey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_interval.c:63
static const gbtree_ninfo tinfo
Definition: btree_interval.c:98
Datum gbt_intv_picksplit(PG_FUNCTION_ARGS)
Datum gbt_intv_same(PG_FUNCTION_ARGS)
Datum interval_dist(PG_FUNCTION_ARGS)
static bool gbt_intveq(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_interval.c:45
#define INTERVALSIZE
Definition: btree_interval.c:96
Datum gbt_intv_sortsupport(PG_FUNCTION_ARGS)
PG_FUNCTION_INFO_V1(gbt_intv_compress)
float8 gbt_num_distance(const GBT_NUMKEY_R *key, const void *query, bool is_leaf, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
bool gbt_num_consistent(const GBT_NUMKEY_R *key, const void *query, const StrategyNumber *strategy, bool is_leaf, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
bool gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
GISTENTRY * gbt_num_fetch(GISTENTRY *entry, const gbtree_ninfo *tinfo)
GIST_SPLITVEC * gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
void * gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
#define penalty_num(result, olower, oupper, nlower, nupper)
#define INTERVAL_TO_SEC(ivp)
char GBT_NUMKEY
double float8
Definition: c.h:635
#define PG_RETURN_VOID()
Definition: fmgr.h:349
#define DirectFunctionCall2(func, arg1, arg2)
Definition: fmgr.h:684
#define PG_RETURN_FLOAT8(x)
Definition: fmgr.h:367
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:682
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:268
#define PG_GETARG_UINT16(n)
Definition: fmgr.h:272
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:361
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
#define GIST_LEAF(entry)
Definition: gist.h:171
#define gistentryinit(e, k, r, pg, o, l)
Definition: gist.h:245
y
int y
Definition: isn.c:76
b
int b
Definition: isn.c:74
x
int x
Definition: isn.c:75
a
int a
Definition: isn.c:73
i
int i
Definition: isn.c:77
void * palloc(Size size)
Definition: mcxt.c:1365
static bool DatumGetBool(Datum X)
Definition: postgres.h:100
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
uint64_t Datum
Definition: postgres.h:70
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:322
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:212
struct SortSupportData * SortSupport
Definition: sortsupport.h:58
uint16 StrategyNumber
Definition: stratnum.h:22
Definition: fmgr.h:57
Definition: gist.h:160
OffsetNumber offset
Definition: gist.h:164
Datum key
Definition: gist.h:161
Page page
Definition: gist.h:163
Relation rel
Definition: gist.h:162
bool leafkey
Definition: gist.h:165
Definition: gist.h:142
int(* comparator)(Datum x, Datum y, SortSupport ssup)
Definition: sortsupport.h:106
void * ssup_extra
Definition: sortsupport.h:87
Interval lower
Definition: btree_interval.c:15
Interval upper
Definition: btree_interval.c:16
static Datum IntervalPGetDatum(const Interval *X)
Definition: timestamp.h:58
#define PG_GETARG_INTERVAL_P(n)
Definition: timestamp.h:65
static Interval * DatumGetIntervalP(Datum X)
Definition: timestamp.h:40
#define PG_RETURN_INTERVAL_P(x)
Definition: timestamp.h:69

AltStyle によって変換されたページ (->オリジナル) /