contrib/btree_gist/btree_inet.c

   1 /*
   2  * $PostgreSQL:$
   3  */
   4 #include "btree_gist.h"
   5 #include "btree_utils_num.h"
   6 #include "utils/builtins.h"
   7 #include "utils/inet.h"
   8 #include "catalog/pg_type.h"
   9
  10 typedef struct inetkey
  11 {
  12         double          lower;
  13         double          upper;
  14 }       inetKEY;
  15
  16 /*
  17 ** inet ops
  18 */
  19 PG_FUNCTION_INFO_V1(gbt_inet_compress);
  20 PG_FUNCTION_INFO_V1(gbt_inet_union);
  21 PG_FUNCTION_INFO_V1(gbt_inet_picksplit);
  22 PG_FUNCTION_INFO_V1(gbt_inet_consistent);
  23 PG_FUNCTION_INFO_V1(gbt_inet_penalty);
  24 PG_FUNCTION_INFO_V1(gbt_inet_same);
  25
  26 Datum           gbt_inet_compress(PG_FUNCTION_ARGS);
  27 Datum           gbt_inet_union(PG_FUNCTION_ARGS);
  28 Datum           gbt_inet_picksplit(PG_FUNCTION_ARGS);
  29 Datum           gbt_inet_consistent(PG_FUNCTION_ARGS);
  30 Datum           gbt_inet_penalty(PG_FUNCTION_ARGS);
  31 Datum           gbt_inet_same(PG_FUNCTION_ARGS);
  32
  33
  34 static bool
  35 gbt_inetgt(const void *a, const void *b)
  36 {
  37         return (*((double *) a) > *((double *) b));
  38 }
  39 static bool
  40 gbt_inetge(const void *a, const void *b)
  41 {
  42         return (*((double *) a) >= *((double *) b));
  43 }
  44 static bool
  45 gbt_ineteq(const void *a, const void *b)
  46 {
  47         return (*((double *) a) == *((double *) b));
  48 }
  49 static bool
  50 gbt_inetle(const void *a, const void *b)
  51 {
  52         return (*((double *) a) <= *((double *) b));
  53 }
  54 static bool
  55 gbt_inetlt(const void *a, const void *b)
  56 {
  57         return (*((double *) a) < *((double *) b));
  58 }
  59
  60 static int
  61 gbt_inetkey_cmp(const void *a, const void *b)
  62 {
  63
  64         if (*(double *) (&((Nsrt *) a)->t[0]) > *(double *) (&((Nsrt *) b)->t[0]))
  65                 return 1;
  66         else if (*(double *) (&((Nsrt *) a)->t[0]) < *(double *) (&((Nsrt *) b)->t[0]))
  67                 return -1;
  68         return 0;
  69
  70 }
  71
  72
  73 static const gbtree_ninfo tinfo =
  74 {
  75         gbt_t_inet,
  76         sizeof(double),
  77         gbt_inetgt,
  78         gbt_inetge,
  79         gbt_ineteq,
  80         gbt_inetle,
  81         gbt_inetlt,
  82         gbt_inetkey_cmp
  83 };
  84
  85
  86 /**************************************************
  87  * inet ops
  88  **************************************************/
  89
  90
  91 Datum
  92 gbt_inet_compress(PG_FUNCTION_ARGS)
  93 {
  94         GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
  95         GISTENTRY  *retval;
  96
  97         if (entry->leafkey)
  98         {
  99                 inetKEY    *r = (inetKEY *) palloc(sizeof(inetKEY));
 100
 101                 retval = palloc(sizeof(GISTENTRY));
 102                 r->lower = convert_network_to_scalar(entry->key, INETOID);
 103                 r->upper = r->lower;
 104                 gistentryinit(*retval, PointerGetDatum(r),
 105                                           entry->rel, entry->page,
 106                                           entry->offset, FALSE);
 107         }
 108         else
 109                 retval = entry;
 110
 111         PG_RETURN_POINTER(retval);
 112 }
 113
 114
 115 Datum
 116 gbt_inet_consistent(PG_FUNCTION_ARGS)
 117 {
 118         GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 119         double          query = convert_network_to_scalar(PG_GETARG_DATUM(1), INETOID);
 120         StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
 121         /* Oid          subtype = PG_GETARG_OID(3); */
 122         bool       *recheck = (bool *) PG_GETARG_POINTER(4);
 123         inetKEY    *kkk = (inetKEY *) DatumGetPointer(entry->key);
 124         GBT_NUMKEY_R key;
 125
 126         /* All cases served by this function are inexact */
 127         *recheck = true;
 128
 129         key.lower = (GBT_NUMKEY *) & kkk->lower;
 130         key.upper = (GBT_NUMKEY *) & kkk->upper;
 131
 132         PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query,
 133                                                                           &strategy, GIST_LEAF(entry), &tinfo));
 134 }
 135
 136
 137 Datum
 138 gbt_inet_union(PG_FUNCTION_ARGS)
 139 {
 140         GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
 141         void       *out = palloc(sizeof(inetKEY));
 142
 143         *(int *) PG_GETARG_POINTER(1) = sizeof(inetKEY);
 144         PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo));
 145 }
 146
 147
 148 Datum
 149 gbt_inet_penalty(PG_FUNCTION_ARGS)
 150 {
 151         inetKEY    *origentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
 152         inetKEY    *newentry = (inetKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
 153         float      *result = (float *) PG_GETARG_POINTER(2);
 154
 155         penalty_num(result, origentry->lower, origentry->upper, newentry->lower, newentry->upper);
 156
 157         PG_RETURN_POINTER(result);
 158
 159 }
 160
 161 Datum
 162 gbt_inet_picksplit(PG_FUNCTION_ARGS)
 163 {
 164         PG_RETURN_POINTER(gbt_num_picksplit(
 165                                                                         (GistEntryVector *) PG_GETARG_POINTER(0),
 166                                                                           (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
 167                                                                                 &tinfo
 168                                                                                 ));
 169 }
 170
 171 Datum
 172 gbt_inet_same(PG_FUNCTION_ARGS)
 173 {
 174         inetKEY    *b1 = (inetKEY *) PG_GETARG_POINTER(0);
 175         inetKEY    *b2 = (inetKEY *) PG_GETARG_POINTER(1);
 176         bool       *result = (bool *) PG_GETARG_POINTER(2);
 177
 178         *result = gbt_num_same((void *) b1, (void *) b2, &tinfo);
 179         PG_RETURN_POINTER(result);
 180 }