LCOV - code coverage report
Current view: top level - contrib/btree_gist - btree_inet.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta2 Lines: 63 66 95.5 %
Date: 2019-06-19 14:06:47 Functions: 18 18 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13