Thanks to visit codestin.com
Credit goes to doxygen.postgresql.org

PostgreSQL Source Code git master
btree_ts.c
Go to the documentation of this file.
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/fmgrprotos.h"
11#include "utils/timestamp.h"
12#include "utils/float.h"
13#include "utils/rel.h"
14#include "utils/sortsupport.h"
15
16typedef struct
17{
20} tsKEY;
21
22/* GiST support functions */
35
36
37/* define for comparison */
38
39static bool
40gbt_tsgt(const void *a, const void *b, FmgrInfo *flinfo)
41{
42 const Timestamp *aa = (const Timestamp *) a;
43 const Timestamp *bb = (const Timestamp *) b;
44
47 TimestampGetDatum(*bb)));
48}
49
50static bool
51gbt_tsge(const void *a, const void *b, FmgrInfo *flinfo)
52{
53 const Timestamp *aa = (const Timestamp *) a;
54 const Timestamp *bb = (const Timestamp *) b;
55
58 TimestampGetDatum(*bb)));
59}
60
61static bool
62gbt_tseq(const void *a, const void *b, FmgrInfo *flinfo)
63{
64 const Timestamp *aa = (const Timestamp *) a;
65 const Timestamp *bb = (const Timestamp *) b;
66
69 TimestampGetDatum(*bb)));
70}
71
72static bool
73gbt_tsle(const void *a, const void *b, FmgrInfo *flinfo)
74{
75 const Timestamp *aa = (const Timestamp *) a;
76 const Timestamp *bb = (const Timestamp *) b;
77
80 TimestampGetDatum(*bb)));
81}
82
83static bool
84gbt_tslt(const void *a, const void *b, FmgrInfo *flinfo)
85{
86 const Timestamp *aa = (const Timestamp *) a;
87 const Timestamp *bb = (const Timestamp *) b;
88
91 TimestampGetDatum(*bb)));
92}
93
94static int
95gbt_tskey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
96{
97 tsKEY *ia = (tsKEY *) (((const Nsrt *) a)->t);
98 tsKEY *ib = (tsKEY *) (((const Nsrt *) b)->t);
99 int res;
100
102 if (res == 0)
104
105 return res;
106}
107
108static float8
109gbt_ts_dist(const void *a, const void *b, FmgrInfo *flinfo)
110{
111 const Timestamp *aa = (const Timestamp *) a;
112 const Timestamp *bb = (const Timestamp *) b;
113 Interval *i;
114
116 return get_float8_infinity();
117
120 TimestampGetDatum(*bb)));
121 return fabs(INTERVAL_TO_SEC(i));
122}
123
124static const gbtree_ninfo tinfo =
125{
126 gbt_t_ts,
127 sizeof(Timestamp),
128 16, /* sizeof(gbtreekey16) */
129 gbt_tsgt,
130 gbt_tsge,
131 gbt_tseq,
132 gbt_tsle,
133 gbt_tslt,
136};
137
138
140Datum
142{
145 Interval *r;
146
148 {
149 Interval *p = palloc(sizeof(Interval));
150
151 p->day = INT_MAX;
152 p->month = INT_MAX;
153 p->time = PG_INT64_MAX;
155 }
156 else
159 PG_GETARG_DATUM(1)));
161}
162
164Datum
166{
169 Interval *r;
170
172 {
173 Interval *p = palloc(sizeof(Interval));
174
175 p->day = INT_MAX;
176 p->month = INT_MAX;
177 p->time = PG_INT64_MAX;
179 }
180
183 PG_GETARG_DATUM(1)));
185}
186
187/**************************************************
188 * GiST support functions
189 **************************************************/
190
191static inline Timestamp
193{
194 /* No timezone correction is needed, since GMT is offset 0 by definition */
195 return (Timestamp) ts;
196}
197
198
199Datum
201{
202 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
203
205}
206
207Datum
209{
210 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
211 GISTENTRY *retval;
212
213 if (entry->leafkey)
214 {
215 tsKEY *r = (tsKEY *) palloc(sizeof(tsKEY));
218
219 gmt = tstz_to_ts_gmt(ts);
220
221 retval = palloc(sizeof(GISTENTRY));
222 r->lower = r->upper = gmt;
223 gistentryinit(*retval, PointerGetDatum(r),
224 entry->rel, entry->page,
225 entry->offset, false);
226 }
227 else
228 retval = entry;
229
230 PG_RETURN_POINTER(retval);
231}
232
233Datum
235{
236 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
237
239}
240
241Datum
243{
244 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
247
248 /* Oid subtype = PG_GETARG_OID(3); */
249 bool *recheck = (bool *) PG_GETARG_POINTER(4);
250 tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key);
252
253 /* All cases served by this function are exact */
254 *recheck = false;
255
256 key.lower = (GBT_NUMKEY *) &kkk->lower;
257 key.upper = (GBT_NUMKEY *) &kkk->upper;
258
259 PG_RETURN_BOOL(gbt_num_consistent(&key, &query, &strategy,
260 GIST_LEAF(entry), &tinfo, fcinfo->flinfo));
261}
262
263Datum
265{
266 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
268
269 /* Oid subtype = PG_GETARG_OID(3); */
270 tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key);
272
273 key.lower = (GBT_NUMKEY *) &kkk->lower;
274 key.upper = (GBT_NUMKEY *) &kkk->upper;
275
277 &tinfo, fcinfo->flinfo));
278}
279
280Datum
282{
283 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
286
287 /* Oid subtype = PG_GETARG_OID(3); */
288 bool *recheck = (bool *) PG_GETARG_POINTER(4);
289 char *kkk = (char *) DatumGetPointer(entry->key);
291 Timestamp qqq;
292
293 /* All cases served by this function are exact */
294 *recheck = false;
295
296 key.lower = (GBT_NUMKEY *) &kkk[0];
297 key.upper = (GBT_NUMKEY *) &kkk[MAXALIGN(tinfo.size)];
298 qqq = tstz_to_ts_gmt(query);
299
300 PG_RETURN_BOOL(gbt_num_consistent(&key, &qqq, &strategy,
301 GIST_LEAF(entry), &tinfo, fcinfo->flinfo));
302}
303
304Datum
306{
307 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
309
310 /* Oid subtype = PG_GETARG_OID(3); */
311 char *kkk = (char *) DatumGetPointer(entry->key);
313 Timestamp qqq;
314
315 key.lower = (GBT_NUMKEY *) &kkk[0];
316 key.upper = (GBT_NUMKEY *) &kkk[MAXALIGN(tinfo.size)];
317 qqq = tstz_to_ts_gmt(query);
318
320 &tinfo, fcinfo->flinfo));
321}
322
323
324Datum
326{
328 void *out = palloc(sizeof(tsKEY));
329
330 *(int *) PG_GETARG_POINTER(1) = sizeof(tsKEY);
331 PG_RETURN_POINTER(gbt_num_union(out, entryvec, &tinfo, fcinfo->flinfo));
332}
333
334
335#define penalty_check_max_float(val) \
336 do { \
337 if ( val > FLT_MAX ) \
338 val = FLT_MAX; \
339 if ( val < -FLT_MAX ) \
340 val = -FLT_MAX; \
341 } while (0)
342
343
344Datum
346{
347 tsKEY *origentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
348 tsKEY *newentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
349 float *result = (float *) PG_GETARG_POINTER(2);
350
351 double orgdbl[2],
352 newdbl[2];
353
354 /*
355 * We are always using "double" timestamps here. Precision should be good
356 * enough.
357 */
358 orgdbl[0] = ((double) origentry->lower);
359 orgdbl[1] = ((double) origentry->upper);
360 newdbl[0] = ((double) newentry->lower);
361 newdbl[1] = ((double) newentry->upper);
362
363 penalty_check_max_float(orgdbl[0]);
364 penalty_check_max_float(orgdbl[1]);
365 penalty_check_max_float(newdbl[0]);
366 penalty_check_max_float(newdbl[1]);
367
368 penalty_num(result, orgdbl[0], orgdbl[1], newdbl[0], newdbl[1]);
369
370 PG_RETURN_POINTER(result);
371}
372
373
374Datum
376{
379 &tinfo, fcinfo->flinfo));
380}
381
382Datum
384{
385 tsKEY *b1 = (tsKEY *) PG_GETARG_POINTER(0);
386 tsKEY *b2 = (tsKEY *) PG_GETARG_POINTER(1);
387 bool *result = (bool *) PG_GETARG_POINTER(2);
388
389 *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo);
390 PG_RETURN_POINTER(result);
391}
392
393static int
395{
396 tsKEY *arg1 = (tsKEY *) DatumGetPointer(x);
397 tsKEY *arg2 = (tsKEY *) DatumGetPointer(y);
398
399 /* for leaf items we expect lower == upper, so only compare lower */
402 TimestampGetDatum(arg2->lower)));
403}
404
405Datum
407{
409
411 ssup->ssup_extra = NULL;
412
414}
Datum timestamp_cmp(PG_FUNCTION_ARGS)
Definition: timestamp.c:2270
Datum timestamp_ge(PG_FUNCTION_ARGS)
Definition: timestamp.c:2261
Datum timestamp_lt(PG_FUNCTION_ARGS)
Definition: timestamp.c:2234
Datum timestamp_le(PG_FUNCTION_ARGS)
Definition: timestamp.c:2252
Datum timestamp_gt(PG_FUNCTION_ARGS)
Definition: timestamp.c:2243
Datum timestamp_mi(PG_FUNCTION_ARGS)
Definition: timestamp.c:2824
Datum timestamp_eq(PG_FUNCTION_ARGS)
Definition: timestamp.c:2216
@ gbt_t_ts
Definition: btree_gist.h:23
Interval * abs_interval(Interval *a)
Datum gbt_ts_compress(PG_FUNCTION_ARGS)
Definition: btree_ts.c:200
static bool gbt_tsle(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_ts.c:73
Datum gbt_ts_penalty(PG_FUNCTION_ARGS)
Definition: btree_ts.c:345
Datum gbt_tstz_compress(PG_FUNCTION_ARGS)
Definition: btree_ts.c:208
static int gbt_ts_ssup_cmp(Datum x, Datum y, SortSupport ssup)
Definition: btree_ts.c:394
static bool gbt_tsgt(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_ts.c:40
Datum gbt_ts_same(PG_FUNCTION_ARGS)
Definition: btree_ts.c:383
Datum gbt_tstz_consistent(PG_FUNCTION_ARGS)
Definition: btree_ts.c:281
Datum gbt_tstz_distance(PG_FUNCTION_ARGS)
Definition: btree_ts.c:305
Datum gbt_ts_distance(PG_FUNCTION_ARGS)
Definition: btree_ts.c:264
Datum gbt_ts_picksplit(PG_FUNCTION_ARGS)
Definition: btree_ts.c:375
#define penalty_check_max_float(val)
Definition: btree_ts.c:335
Datum ts_dist(PG_FUNCTION_ARGS)
Definition: btree_ts.c:141
Datum gbt_ts_union(PG_FUNCTION_ARGS)
Definition: btree_ts.c:325
Datum gbt_ts_fetch(PG_FUNCTION_ARGS)
Definition: btree_ts.c:234
static const gbtree_ninfo tinfo
Definition: btree_ts.c:124
static bool gbt_tslt(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_ts.c:84
static bool gbt_tsge(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_ts.c:51
Datum tstz_dist(PG_FUNCTION_ARGS)
Definition: btree_ts.c:165
static Timestamp tstz_to_ts_gmt(TimestampTz ts)
Definition: btree_ts.c:192
Datum gbt_ts_consistent(PG_FUNCTION_ARGS)
Definition: btree_ts.c:242
Datum gbt_ts_sortsupport(PG_FUNCTION_ARGS)
Definition: btree_ts.c:406
static int gbt_tskey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_ts.c:95
static bool gbt_tseq(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_ts.c:62
PG_FUNCTION_INFO_V1(gbt_ts_compress)
static float8 gbt_ts_dist(const void *a, const void *b, FmgrInfo *flinfo)
Definition: btree_ts.c:109
GISTENTRY * gbt_num_compress(GISTENTRY *entry, const gbtree_ninfo *tinfo)
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
#define MAXALIGN(LEN)
Definition: c.h:811
double float8
Definition: c.h:636
#define PG_INT64_MAX
Definition: c.h:598
int64 Timestamp
Definition: timestamp.h:38
int64 TimestampTz
Definition: timestamp.h:39
#define TIMESTAMP_NOT_FINITE(j)
Definition: timestamp.h:169
static float8 get_float8_infinity(void)
Definition: float.h:94
#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 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
int y
Definition: isn.c:76
int b
Definition: isn.c:74
int x
Definition: isn.c:75
int a
Definition: isn.c:73
int i
Definition: isn.c:77
static const char gmt[]
Definition: localtime.c:53
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
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
int32 day
Definition: timestamp.h:51
int32 month
Definition: timestamp.h:52
TimeOffset time
Definition: timestamp.h:49
int(* comparator)(Datum x, Datum y, SortSupport ssup)
Definition: sortsupport.h:106
void * ssup_extra
Definition: sortsupport.h:87
Definition: btree_ts.c:17
Timestamp lower
Definition: btree_ts.c:18
Timestamp upper
Definition: btree_ts.c:19
static Datum TimestampGetDatum(Timestamp X)
Definition: timestamp.h:46
#define PG_GETARG_TIMESTAMP(n)
Definition: timestamp.h:63
#define PG_GETARG_TIMESTAMPTZ(n)
Definition: timestamp.h:64
static Interval * DatumGetIntervalP(Datum X)
Definition: timestamp.h:40
#define PG_RETURN_INTERVAL_P(x)
Definition: timestamp.h:69
static TimestampTz DatumGetTimestampTz(Datum X)
Definition: timestamp.h:34