contrib/btree_gist/btree_ts.c

   1 /*
   2  * $PostgreSQL:$
   3  */
   4 #include "btree_gist.h"
   5 #include "btree_utils_num.h"
   6 #include "utils/datetime.h"
   7
   8 typedef struct
   9 {
  10         Timestamp       lower;
  11         Timestamp       upper;
  12 }       tsKEY;
  13
  14 /*
  15 ** timestamp ops
  16 */
  17 PG_FUNCTION_INFO_V1(gbt_ts_compress);
  18 PG_FUNCTION_INFO_V1(gbt_tstz_compress);
  19 PG_FUNCTION_INFO_V1(gbt_ts_union);
  20 PG_FUNCTION_INFO_V1(gbt_ts_picksplit);
  21 PG_FUNCTION_INFO_V1(gbt_ts_consistent);
  22 PG_FUNCTION_INFO_V1(gbt_tstz_consistent);
  23 PG_FUNCTION_INFO_V1(gbt_ts_penalty);
  24 PG_FUNCTION_INFO_V1(gbt_ts_same);
  25
  26 Datum           gbt_ts_compress(PG_FUNCTION_ARGS);
  27 Datum           gbt_tstz_compress(PG_FUNCTION_ARGS);
  28 Datum           gbt_ts_union(PG_FUNCTION_ARGS);
  29 Datum           gbt_ts_picksplit(PG_FUNCTION_ARGS);
  30 Datum           gbt_ts_consistent(PG_FUNCTION_ARGS);
  31 Datum           gbt_tstz_consistent(PG_FUNCTION_ARGS);
  32 Datum           gbt_ts_penalty(PG_FUNCTION_ARGS);
  33 Datum           gbt_ts_same(PG_FUNCTION_ARGS);
  34
  35
  36 #ifdef USE_FLOAT8_BYVAL
  37 #define TimestampGetDatumFast(X) TimestampGetDatum(X)
  38 #else
  39 #define TimestampGetDatumFast(X) PointerGetDatum(&(X))
  40 #endif
  41
  42
  43 static bool
  44 gbt_tsgt(const void *a, const void *b)
  45 {
  46         const Timestamp *aa = (const Timestamp *) a;
  47         const Timestamp *bb = (const Timestamp *) b;
  48
  49         return DatumGetBool(DirectFunctionCall2(timestamp_gt,
  50                                                                                         TimestampGetDatumFast(*aa),
  51                                                                                         TimestampGetDatumFast(*bb)));
  52 }
  53
  54 static bool
  55 gbt_tsge(const void *a, const void *b)
  56 {
  57         const Timestamp *aa = (const Timestamp *) a;
  58         const Timestamp *bb = (const Timestamp *) b;
  59
  60         return DatumGetBool(DirectFunctionCall2(timestamp_ge,
  61                                                                                         TimestampGetDatumFast(*aa),
  62                                                                                         TimestampGetDatumFast(*bb)));
  63 }
  64
  65 static bool
  66 gbt_tseq(const void *a, const void *b)
  67 {
  68         const Timestamp *aa = (const Timestamp *) a;
  69         const Timestamp *bb = (const Timestamp *) b;
  70
  71         return DatumGetBool(DirectFunctionCall2(timestamp_eq,
  72                                                                                         TimestampGetDatumFast(*aa),
  73                                                                                         TimestampGetDatumFast(*bb)));
  74 }
  75
  76 static bool
  77 gbt_tsle(const void *a, const void *b)
  78 {
  79         const Timestamp *aa = (const Timestamp *) a;
  80         const Timestamp *bb = (const Timestamp *) b;
  81
  82         return DatumGetBool(DirectFunctionCall2(timestamp_le,
  83                                                                                         TimestampGetDatumFast(*aa),
  84                                                                                         TimestampGetDatumFast(*bb)));
  85 }
  86
  87 static bool
  88 gbt_tslt(const void *a, const void *b)
  89 {
  90         const Timestamp *aa = (const Timestamp *) a;
  91         const Timestamp *bb = (const Timestamp *) b;
  92
  93         return DatumGetBool(DirectFunctionCall2(timestamp_lt,
  94                                                                                         TimestampGetDatumFast(*aa),
  95                                                                                         TimestampGetDatumFast(*bb)));
  96 }
  97
  98
  99 static int
 100 gbt_tskey_cmp(const void *a, const void *b)
 101 {
 102         if (gbt_tsgt((void *) &(((Nsrt *) a)->t[0]), (void *) &(((Nsrt *) b)->t[0])))
 103                 return 1;
 104         else if (gbt_tslt((void *) &(((Nsrt *) a)->t[0]), (void *) &(((Nsrt *) b)->t[0])))
 105                 return -1;
 106         return 0;
 107 }
 108
 109
 110 static const gbtree_ninfo tinfo =
 111 {
 112         gbt_t_ts,
 113         sizeof(Timestamp),
 114         gbt_tsgt,
 115         gbt_tsge,
 116         gbt_tseq,
 117         gbt_tsle,
 118         gbt_tslt,
 119         gbt_tskey_cmp
 120 };
 121
 122
 123 /**************************************************
 124  * timestamp ops
 125  **************************************************/
 126
 127
 128 static Timestamp
 129 tstz_to_ts_gmt(TimestampTz ts)
 130 {
 131         Timestamp       gmt;
 132         int                     val,
 133                                 tz;
 134
 135         gmt = ts;
 136         DecodeSpecial(0, "gmt", &val);
 137
 138         if (ts < DT_NOEND && ts > DT_NOBEGIN)
 139         {
 140                 tz = val * 60;
 141
 142 #ifdef HAVE_INT64_TIMESTAMP
 143                 gmt -= (tz * INT64CONST(1000000));
 144 #else
 145                 gmt -= tz;
 146 #endif
 147         }
 148         return gmt;
 149 }
 150
 151
 152 Datum
 153 gbt_ts_compress(PG_FUNCTION_ARGS)
 154 {
 155         GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 156         GISTENTRY  *retval = NULL;
 157
 158         PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo));
 159 }
 160
 161
 162 Datum
 163 gbt_tstz_compress(PG_FUNCTION_ARGS)
 164 {
 165         GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 166         GISTENTRY  *retval;
 167
 168         if (entry->leafkey)
 169         {
 170                 tsKEY      *r = (tsKEY *) palloc(sizeof(tsKEY));
 171                 TimestampTz ts = DatumGetTimestampTz(entry->key);
 172                 Timestamp       gmt;
 173
 174                 gmt = tstz_to_ts_gmt(ts);
 175
 176                 retval = palloc(sizeof(GISTENTRY));
 177                 r->lower = r->upper = gmt;
 178                 gistentryinit(*retval, PointerGetDatum(r),
 179                                           entry->rel, entry->page,
 180                                           entry->offset, FALSE);
 181         }
 182         else
 183                 retval = entry;
 184
 185         PG_RETURN_POINTER(retval);
 186 }
 187
 188
 189 Datum
 190 gbt_ts_consistent(PG_FUNCTION_ARGS)
 191 {
 192         GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 193         Timestamp       query = PG_GETARG_TIMESTAMP(1);
 194         StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
 195         /* Oid          subtype = PG_GETARG_OID(3); */
 196         bool       *recheck = (bool *) PG_GETARG_POINTER(4);
 197         tsKEY      *kkk = (tsKEY *) DatumGetPointer(entry->key);
 198         GBT_NUMKEY_R key;
 199
 200         /* All cases served by this function are exact */
 201         *recheck = false;
 202
 203         key.lower = (GBT_NUMKEY *) & kkk->lower;
 204         key.upper = (GBT_NUMKEY *) & kkk->upper;
 205
 206         PG_RETURN_BOOL(
 207                                    gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
 208                 );
 209 }
 210
 211 Datum
 212 gbt_tstz_consistent(PG_FUNCTION_ARGS)
 213 {
 214         GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 215         TimestampTz     query = PG_GETARG_TIMESTAMPTZ(1);
 216         StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
 217         /* Oid          subtype = PG_GETARG_OID(3); */
 218         bool       *recheck = (bool *) PG_GETARG_POINTER(4);
 219         char       *kkk = (char *) DatumGetPointer(entry->key);
 220         GBT_NUMKEY_R key;
 221         Timestamp       qqq;
 222
 223         /* All cases served by this function are exact */
 224         *recheck = false;
 225
 226         key.lower = (GBT_NUMKEY *) & kkk[0];
 227         key.upper = (GBT_NUMKEY *) & kkk[MAXALIGN(tinfo.size)];
 228         qqq = tstz_to_ts_gmt(query);
 229
 230         PG_RETURN_BOOL(
 231                                    gbt_num_consistent(&key, (void *) &qqq, &strategy, GIST_LEAF(entry), &tinfo)
 232                 );
 233 }
 234
 235
 236 Datum
 237 gbt_ts_union(PG_FUNCTION_ARGS)
 238 {
 239         GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
 240         void       *out = palloc(sizeof(tsKEY));
 241
 242         *(int *) PG_GETARG_POINTER(1) = sizeof(tsKEY);
 243         PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo));
 244 }
 245
 246
 247 #define penalty_check_max_float(val) do { \
 248                 if ( val > FLT_MAX ) \
 249                                 val = FLT_MAX; \
 250                 if ( val < -FLT_MAX ) \
 251                                 val = -FLT_MAX; \
 252 } while(false);
 253
 254
 255 Datum
 256 gbt_ts_penalty(PG_FUNCTION_ARGS)
 257 {
 258
 259         tsKEY      *origentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
 260         tsKEY      *newentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
 261         float      *result = (float *) PG_GETARG_POINTER(2);
 262
 263         double          orgdbl[2],
 264                                 newdbl[2];
 265
 266         /*
 267          * We are allways using "double" timestamps here. Precision should be good
 268          * enough.
 269          */
 270         orgdbl[0] = ((double) origentry->lower);
 271         orgdbl[1] = ((double) origentry->upper);
 272         newdbl[0] = ((double) newentry->lower);
 273         newdbl[1] = ((double) newentry->upper);
 274
 275         penalty_check_max_float(orgdbl[0]);
 276         penalty_check_max_float(orgdbl[1]);
 277         penalty_check_max_float(newdbl[0]);
 278         penalty_check_max_float(newdbl[1]);
 279
 280         penalty_num(result, orgdbl[0], orgdbl[1], newdbl[0], newdbl[1]);
 281
 282         PG_RETURN_POINTER(result);
 283
 284 }
 285
 286
 287 Datum
 288 gbt_ts_picksplit(PG_FUNCTION_ARGS)
 289 {
 290         PG_RETURN_POINTER(gbt_num_picksplit(
 291                                                                         (GistEntryVector *) PG_GETARG_POINTER(0),
 292                                                                           (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 293                                                                                 &tinfo
 294                                                                                 ));
 295 }
 296
 297 Datum
 298 gbt_ts_same(PG_FUNCTION_ARGS)
 299 {
 300         tsKEY      *b1 = (tsKEY *) PG_GETARG_POINTER(0);
 301         tsKEY      *b2 = (tsKEY *) PG_GETARG_POINTER(1);
 302         bool       *result = (bool *) PG_GETARG_POINTER(2);
 303
 304         *result = gbt_num_same((void *) b1, (void *) b2, &tinfo);
 305         PG_RETURN_POINTER(result);
 306 }