1 /*
2 * contrib/btree_gist/btree_ts.c
3 */
4 #include "postgres.h"
5
6 #include <limits.h>
7
8 #include "btree_gist.h"
9 #include "btree_utils_num.h"
10 #include "utils/builtins.h"
11 #include "utils/datetime.h"
12
13 typedef struct
14 {
15 Timestamp lower;
16 Timestamp upper;
17 } tsKEY;
18
19 /*
20 ** timestamp ops
21 */
22 PG_FUNCTION_INFO_V1(gbt_ts_compress);
23 PG_FUNCTION_INFO_V1(gbt_tstz_compress);
24 PG_FUNCTION_INFO_V1(gbt_ts_fetch);
25 PG_FUNCTION_INFO_V1(gbt_ts_union);
26 PG_FUNCTION_INFO_V1(gbt_ts_picksplit);
27 PG_FUNCTION_INFO_V1(gbt_ts_consistent);
28 PG_FUNCTION_INFO_V1(gbt_ts_distance);
29 PG_FUNCTION_INFO_V1(gbt_tstz_consistent);
30 PG_FUNCTION_INFO_V1(gbt_tstz_distance);
31 PG_FUNCTION_INFO_V1(gbt_ts_penalty);
32 PG_FUNCTION_INFO_V1(gbt_ts_same);
33
34
35 #ifdef USE_FLOAT8_BYVAL
36 #define TimestampGetDatumFast(X) TimestampGetDatum(X)
37 #else
38 #define TimestampGetDatumFast(X) PointerGetDatum(&(X))
39 #endif
40
41
42 static bool
gbt_tsgt(const void * a,const void * b,FmgrInfo * flinfo)43 gbt_tsgt(const void *a, const void *b, FmgrInfo *flinfo)
44 {
45 const Timestamp *aa = (const Timestamp *) a;
46 const Timestamp *bb = (const Timestamp *) b;
47
48 return DatumGetBool(DirectFunctionCall2(timestamp_gt,
49 TimestampGetDatumFast(*aa),
50 TimestampGetDatumFast(*bb)));
51 }
52
53 static bool
gbt_tsge(const void * a,const void * b,FmgrInfo * flinfo)54 gbt_tsge(const void *a, const void *b, FmgrInfo *flinfo)
55 {
56 const Timestamp *aa = (const Timestamp *) a;
57 const Timestamp *bb = (const Timestamp *) b;
58
59 return DatumGetBool(DirectFunctionCall2(timestamp_ge,
60 TimestampGetDatumFast(*aa),
61 TimestampGetDatumFast(*bb)));
62 }
63
64 static bool
gbt_tseq(const void * a,const void * b,FmgrInfo * flinfo)65 gbt_tseq(const void *a, const void *b, FmgrInfo *flinfo)
66 {
67 const Timestamp *aa = (const Timestamp *) a;
68 const Timestamp *bb = (const Timestamp *) b;
69
70 return DatumGetBool(DirectFunctionCall2(timestamp_eq,
71 TimestampGetDatumFast(*aa),
72 TimestampGetDatumFast(*bb)));
73 }
74
75 static bool
gbt_tsle(const void * a,const void * b,FmgrInfo * flinfo)76 gbt_tsle(const void *a, const void *b, FmgrInfo *flinfo)
77 {
78 const Timestamp *aa = (const Timestamp *) a;
79 const Timestamp *bb = (const Timestamp *) b;
80
81 return DatumGetBool(DirectFunctionCall2(timestamp_le,
82 TimestampGetDatumFast(*aa),
83 TimestampGetDatumFast(*bb)));
84 }
85
86 static bool
gbt_tslt(const void * a,const void * b,FmgrInfo * flinfo)87 gbt_tslt(const void *a, const void *b, FmgrInfo *flinfo)
88 {
89 const Timestamp *aa = (const Timestamp *) a;
90 const Timestamp *bb = (const Timestamp *) b;
91
92 return DatumGetBool(DirectFunctionCall2(timestamp_lt,
93 TimestampGetDatumFast(*aa),
94 TimestampGetDatumFast(*bb)));
95 }
96
97
98 static int
gbt_tskey_cmp(const void * a,const void * b,FmgrInfo * flinfo)99 gbt_tskey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
100 {
101 tsKEY *ia = (tsKEY *) (((const Nsrt *) a)->t);
102 tsKEY *ib = (tsKEY *) (((const Nsrt *) b)->t);
103 int res;
104
105 res = DatumGetInt32(DirectFunctionCall2(timestamp_cmp, TimestampGetDatumFast(ia->lower), TimestampGetDatumFast(ib->lower)));
106 if (res == 0)
107 return DatumGetInt32(DirectFunctionCall2(timestamp_cmp, TimestampGetDatumFast(ia->upper), TimestampGetDatumFast(ib->upper)));
108
109 return res;
110 }
111
112 static float8
gbt_ts_dist(const void * a,const void * b,FmgrInfo * flinfo)113 gbt_ts_dist(const void *a, const void *b, FmgrInfo *flinfo)
114 {
115 const Timestamp *aa = (const Timestamp *) a;
116 const Timestamp *bb = (const Timestamp *) b;
117 Interval *i;
118
119 if (TIMESTAMP_NOT_FINITE(*aa) || TIMESTAMP_NOT_FINITE(*bb))
120 return get_float8_infinity();
121
122 i = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi,
123 TimestampGetDatumFast(*aa),
124 TimestampGetDatumFast(*bb)));
125 return (float8) Abs(INTERVAL_TO_SEC(i));
126 }
127
128
129 static const gbtree_ninfo tinfo =
130 {
131 gbt_t_ts,
132 sizeof(Timestamp),
133 16, /* sizeof(gbtreekey16) */
134 gbt_tsgt,
135 gbt_tsge,
136 gbt_tseq,
137 gbt_tsle,
138 gbt_tslt,
139 gbt_tskey_cmp,
140 gbt_ts_dist
141 };
142
143
144 PG_FUNCTION_INFO_V1(ts_dist);
145 Datum
ts_dist(PG_FUNCTION_ARGS)146 ts_dist(PG_FUNCTION_ARGS)
147 {
148 Timestamp a = PG_GETARG_TIMESTAMP(0);
149 Timestamp b = PG_GETARG_TIMESTAMP(1);
150 Interval *r;
151
152 if (TIMESTAMP_NOT_FINITE(a) || TIMESTAMP_NOT_FINITE(b))
153 {
154 Interval *p = palloc(sizeof(Interval));
155
156 p->day = INT_MAX;
157 p->month = INT_MAX;
158 p->time = PG_INT64_MAX;
159 PG_RETURN_INTERVAL_P(p);
160 }
161 else
162 r = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi,
163 PG_GETARG_DATUM(0),
164 PG_GETARG_DATUM(1)));
165 PG_RETURN_INTERVAL_P(abs_interval(r));
166 }
167
168 PG_FUNCTION_INFO_V1(tstz_dist);
169 Datum
tstz_dist(PG_FUNCTION_ARGS)170 tstz_dist(PG_FUNCTION_ARGS)
171 {
172 TimestampTz a = PG_GETARG_TIMESTAMPTZ(0);
173 TimestampTz b = PG_GETARG_TIMESTAMPTZ(1);
174 Interval *r;
175
176 if (TIMESTAMP_NOT_FINITE(a) || TIMESTAMP_NOT_FINITE(b))
177 {
178 Interval *p = palloc(sizeof(Interval));
179
180 p->day = INT_MAX;
181 p->month = INT_MAX;
182 p->time = PG_INT64_MAX;
183 PG_RETURN_INTERVAL_P(p);
184 }
185
186 r = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi,
187 PG_GETARG_DATUM(0),
188 PG_GETARG_DATUM(1)));
189 PG_RETURN_INTERVAL_P(abs_interval(r));
190 }
191
192
193 /**************************************************
194 * timestamp ops
195 **************************************************/
196
197
198 static inline Timestamp
tstz_to_ts_gmt(TimestampTz ts)199 tstz_to_ts_gmt(TimestampTz ts)
200 {
201 /* No timezone correction is needed, since GMT is offset 0 by definition */
202 return (Timestamp) ts;
203 }
204
205
206 Datum
gbt_ts_compress(PG_FUNCTION_ARGS)207 gbt_ts_compress(PG_FUNCTION_ARGS)
208 {
209 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
210
211 PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo));
212 }
213
214
215 Datum
gbt_tstz_compress(PG_FUNCTION_ARGS)216 gbt_tstz_compress(PG_FUNCTION_ARGS)
217 {
218 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
219 GISTENTRY *retval;
220
221 if (entry->leafkey)
222 {
223 tsKEY *r = (tsKEY *) palloc(sizeof(tsKEY));
224 TimestampTz ts = DatumGetTimestampTz(entry->key);
225 Timestamp gmt;
226
227 gmt = tstz_to_ts_gmt(ts);
228
229 retval = palloc(sizeof(GISTENTRY));
230 r->lower = r->upper = gmt;
231 gistentryinit(*retval, PointerGetDatum(r),
232 entry->rel, entry->page,
233 entry->offset, false);
234 }
235 else
236 retval = entry;
237
238 PG_RETURN_POINTER(retval);
239 }
240
241 Datum
gbt_ts_fetch(PG_FUNCTION_ARGS)242 gbt_ts_fetch(PG_FUNCTION_ARGS)
243 {
244 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
245
246 PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo));
247 }
248
249 Datum
gbt_ts_consistent(PG_FUNCTION_ARGS)250 gbt_ts_consistent(PG_FUNCTION_ARGS)
251 {
252 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
253 Timestamp query = PG_GETARG_TIMESTAMP(1);
254 StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
255
256 /* Oid subtype = PG_GETARG_OID(3); */
257 bool *recheck = (bool *) PG_GETARG_POINTER(4);
258 tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key);
259 GBT_NUMKEY_R key;
260
261 /* All cases served by this function are exact */
262 *recheck = false;
263
264 key.lower = (GBT_NUMKEY *) &kkk->lower;
265 key.upper = (GBT_NUMKEY *) &kkk->upper;
266
267 PG_RETURN_BOOL(
268 gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo, fcinfo->flinfo)
269 );
270 }
271
272 Datum
gbt_ts_distance(PG_FUNCTION_ARGS)273 gbt_ts_distance(PG_FUNCTION_ARGS)
274 {
275 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
276 Timestamp query = PG_GETARG_TIMESTAMP(1);
277
278 /* Oid subtype = PG_GETARG_OID(3); */
279 tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key);
280 GBT_NUMKEY_R key;
281
282 key.lower = (GBT_NUMKEY *) &kkk->lower;
283 key.upper = (GBT_NUMKEY *) &kkk->upper;
284
285 PG_RETURN_FLOAT8(
286 gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), &tinfo, fcinfo->flinfo)
287 );
288 }
289
290 Datum
gbt_tstz_consistent(PG_FUNCTION_ARGS)291 gbt_tstz_consistent(PG_FUNCTION_ARGS)
292 {
293 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
294 TimestampTz query = PG_GETARG_TIMESTAMPTZ(1);
295 StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
296
297 /* Oid subtype = PG_GETARG_OID(3); */
298 bool *recheck = (bool *) PG_GETARG_POINTER(4);
299 char *kkk = (char *) DatumGetPointer(entry->key);
300 GBT_NUMKEY_R key;
301 Timestamp qqq;
302
303 /* All cases served by this function are exact */
304 *recheck = false;
305
306 key.lower = (GBT_NUMKEY *) &kkk[0];
307 key.upper = (GBT_NUMKEY *) &kkk[MAXALIGN(tinfo.size)];
308 qqq = tstz_to_ts_gmt(query);
309
310 PG_RETURN_BOOL(
311 gbt_num_consistent(&key, (void *) &qqq, &strategy, GIST_LEAF(entry), &tinfo, fcinfo->flinfo)
312 );
313 }
314
315 Datum
gbt_tstz_distance(PG_FUNCTION_ARGS)316 gbt_tstz_distance(PG_FUNCTION_ARGS)
317 {
318 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
319 TimestampTz query = PG_GETARG_TIMESTAMPTZ(1);
320
321 /* Oid subtype = PG_GETARG_OID(3); */
322 char *kkk = (char *) DatumGetPointer(entry->key);
323 GBT_NUMKEY_R key;
324 Timestamp qqq;
325
326 key.lower = (GBT_NUMKEY *) &kkk[0];
327 key.upper = (GBT_NUMKEY *) &kkk[MAXALIGN(tinfo.size)];
328 qqq = tstz_to_ts_gmt(query);
329
330 PG_RETURN_FLOAT8(
331 gbt_num_distance(&key, (void *) &qqq, GIST_LEAF(entry), &tinfo, fcinfo->flinfo)
332 );
333 }
334
335
336 Datum
gbt_ts_union(PG_FUNCTION_ARGS)337 gbt_ts_union(PG_FUNCTION_ARGS)
338 {
339 GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
340 void *out = palloc(sizeof(tsKEY));
341
342 *(int *) PG_GETARG_POINTER(1) = sizeof(tsKEY);
343 PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo));
344 }
345
346
347 #define penalty_check_max_float(val) \
348 do { \
349 if ( val > FLT_MAX ) \
350 val = FLT_MAX; \
351 if ( val < -FLT_MAX ) \
352 val = -FLT_MAX; \
353 } while (0)
354
355
356 Datum
gbt_ts_penalty(PG_FUNCTION_ARGS)357 gbt_ts_penalty(PG_FUNCTION_ARGS)
358 {
359 tsKEY *origentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
360 tsKEY *newentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
361 float *result = (float *) PG_GETARG_POINTER(2);
362
363 double orgdbl[2],
364 newdbl[2];
365
366 /*
367 * We are always using "double" timestamps here. Precision should be good
368 * enough.
369 */
370 orgdbl[0] = ((double) origentry->lower);
371 orgdbl[1] = ((double) origentry->upper);
372 newdbl[0] = ((double) newentry->lower);
373 newdbl[1] = ((double) newentry->upper);
374
375 penalty_check_max_float(orgdbl[0]);
376 penalty_check_max_float(orgdbl[1]);
377 penalty_check_max_float(newdbl[0]);
378 penalty_check_max_float(newdbl[1]);
379
380 penalty_num(result, orgdbl[0], orgdbl[1], newdbl[0], newdbl[1]);
381
382 PG_RETURN_POINTER(result);
383
384 }
385
386
387 Datum
gbt_ts_picksplit(PG_FUNCTION_ARGS)388 gbt_ts_picksplit(PG_FUNCTION_ARGS)
389 {
390 PG_RETURN_POINTER(gbt_num_picksplit(
391 (GistEntryVector *) PG_GETARG_POINTER(0),
392 (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
393 &tinfo, fcinfo->flinfo
394 ));
395 }
396
397 Datum
gbt_ts_same(PG_FUNCTION_ARGS)398 gbt_ts_same(PG_FUNCTION_ARGS)
399 {
400 tsKEY *b1 = (tsKEY *) PG_GETARG_POINTER(0);
401 tsKEY *b2 = (tsKEY *) PG_GETARG_POINTER(1);
402 bool *result = (bool *) PG_GETARG_POINTER(2);
403
404 *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo);
405 PG_RETURN_POINTER(result);
406 }
407