LCOV - code coverage report
Current view: top level - contrib/btree_gist - btree_date.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 83 83 100.0 %
Date: 2019-09-19 02:07:14 Functions: 25 25 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * contrib/btree_gist/btree_date.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/date.h"
      10             : 
      11             : typedef struct
      12             : {
      13             :     DateADT     lower;
      14             :     DateADT     upper;
      15             : } dateKEY;
      16             : 
      17             : /*
      18             : ** date ops
      19             : */
      20           4 : PG_FUNCTION_INFO_V1(gbt_date_compress);
      21           4 : PG_FUNCTION_INFO_V1(gbt_date_fetch);
      22           4 : PG_FUNCTION_INFO_V1(gbt_date_union);
      23           4 : PG_FUNCTION_INFO_V1(gbt_date_picksplit);
      24           4 : PG_FUNCTION_INFO_V1(gbt_date_consistent);
      25           4 : PG_FUNCTION_INFO_V1(gbt_date_distance);
      26           4 : PG_FUNCTION_INFO_V1(gbt_date_penalty);
      27           4 : PG_FUNCTION_INFO_V1(gbt_date_same);
      28             : 
      29             : static bool
      30        2378 : gbt_dategt(const void *a, const void *b, FmgrInfo *flinfo)
      31             : {
      32        2378 :     return DatumGetBool(
      33             :                         DirectFunctionCall2(date_gt, DateADTGetDatum(*((const DateADT *) a)), DateADTGetDatum(*((const DateADT *) b)))
      34             :         );
      35             : }
      36             : 
      37             : static bool
      38        1032 : gbt_datege(const void *a, const void *b, FmgrInfo *flinfo)
      39             : {
      40        1032 :     return DatumGetBool(
      41             :                         DirectFunctionCall2(date_ge, DateADTGetDatum(*((const DateADT *) a)), DateADTGetDatum(*((const DateADT *) b)))
      42             :         );
      43             : }
      44             : 
      45             : static bool
      46        1400 : gbt_dateeq(const void *a, const void *b, FmgrInfo *flinfo)
      47             : {
      48        1400 :     return DatumGetBool(
      49             :                         DirectFunctionCall2(date_eq, DateADTGetDatum(*((const DateADT *) a)), DateADTGetDatum(*((const DateADT *) b)))
      50             :         );
      51             : }
      52             : 
      53             : static bool
      54        1668 : gbt_datele(const void *a, const void *b, FmgrInfo *flinfo)
      55             : {
      56        1668 :     return DatumGetBool(
      57             :                         DirectFunctionCall2(date_le, DateADTGetDatum(*((const DateADT *) a)), DateADTGetDatum(*((const DateADT *) b)))
      58             :         );
      59             : }
      60             : 
      61             : static bool
      62        2904 : gbt_datelt(const void *a, const void *b, FmgrInfo *flinfo)
      63             : {
      64        2904 :     return DatumGetBool(
      65             :                         DirectFunctionCall2(date_lt, DateADTGetDatum(*((const DateADT *) a)), DateADTGetDatum(*((const DateADT *) b)))
      66             :         );
      67             : }
      68             : 
      69             : 
      70             : 
      71             : static int
      72        6218 : gbt_datekey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
      73             : {
      74        6218 :     dateKEY    *ia = (dateKEY *) (((const Nsrt *) a)->t);
      75        6218 :     dateKEY    *ib = (dateKEY *) (((const Nsrt *) b)->t);
      76             :     int         res;
      77             : 
      78        6218 :     res = DatumGetInt32(DirectFunctionCall2(date_cmp, DateADTGetDatum(ia->lower), DateADTGetDatum(ib->lower)));
      79        6218 :     if (res == 0)
      80           2 :         return DatumGetInt32(DirectFunctionCall2(date_cmp, DateADTGetDatum(ia->upper), DateADTGetDatum(ib->upper)));
      81             : 
      82        6216 :     return res;
      83             : }
      84             : 
      85             : static float8
      86         564 : gdb_date_dist(const void *a, const void *b, FmgrInfo *flinfo)
      87             : {
      88             :     /* we assume the difference can't overflow */
      89         564 :     Datum       diff = DirectFunctionCall2(date_mi,
      90             :                                            DateADTGetDatum(*((const DateADT *) a)),
      91             :                                            DateADTGetDatum(*((const DateADT *) b)));
      92             : 
      93         564 :     return (float8) Abs(DatumGetInt32(diff));
      94             : }
      95             : 
      96             : 
      97             : static const gbtree_ninfo tinfo =
      98             : {
      99             :     gbt_t_date,
     100             :     sizeof(DateADT),
     101             :     8,                          /* sizeof(gbtreekey8) */
     102             :     gbt_dategt,
     103             :     gbt_datege,
     104             :     gbt_dateeq,
     105             :     gbt_datele,
     106             :     gbt_datelt,
     107             :     gbt_datekey_cmp,
     108             :     gdb_date_dist
     109             : };
     110             : 
     111             : 
     112           4 : PG_FUNCTION_INFO_V1(date_dist);
     113             : Datum
     114        1094 : date_dist(PG_FUNCTION_ARGS)
     115             : {
     116             :     /* we assume the difference can't overflow */
     117        1094 :     Datum       diff = DirectFunctionCall2(date_mi,
     118             :                                            PG_GETARG_DATUM(0),
     119             :                                            PG_GETARG_DATUM(1));
     120             : 
     121        1094 :     PG_RETURN_INT32(Abs(DatumGetInt32(diff)));
     122             : }
     123             : 
     124             : 
     125             : /**************************************************
     126             :  * date ops
     127             :  **************************************************/
     128             : 
     129             : 
     130             : 
     131             : Datum
     132        1096 : gbt_date_compress(PG_FUNCTION_ARGS)
     133             : {
     134        1096 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     135             : 
     136        1096 :     PG_RETURN_POINTER(gbt_num_compress(entry, &tinfo));
     137             : }
     138             : 
     139             : Datum
     140         562 : gbt_date_fetch(PG_FUNCTION_ARGS)
     141             : {
     142         562 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     143             : 
     144         562 :     PG_RETURN_POINTER(gbt_num_fetch(entry, &tinfo));
     145             : }
     146             : 
     147             : Datum
     148        3882 : gbt_date_consistent(PG_FUNCTION_ARGS)
     149             : {
     150        3882 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     151        3882 :     DateADT     query = PG_GETARG_DATEADT(1);
     152        3882 :     StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
     153             : 
     154             :     /* Oid      subtype = PG_GETARG_OID(3); */
     155        3882 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     156        3882 :     dateKEY    *kkk = (dateKEY *) DatumGetPointer(entry->key);
     157             :     GBT_NUMKEY_R key;
     158             : 
     159             :     /* All cases served by this function are exact */
     160        3882 :     *recheck = false;
     161             : 
     162        3882 :     key.lower = (GBT_NUMKEY *) &kkk->lower;
     163        3882 :     key.upper = (GBT_NUMKEY *) &kkk->upper;
     164             : 
     165        3882 :     PG_RETURN_BOOL(
     166             :                    gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo, fcinfo->flinfo)
     167             :         );
     168             : }
     169             : 
     170             : 
     171             : Datum
     172         566 : gbt_date_distance(PG_FUNCTION_ARGS)
     173             : {
     174         566 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     175         566 :     DateADT     query = PG_GETARG_DATEADT(1);
     176             : 
     177             :     /* Oid      subtype = PG_GETARG_OID(3); */
     178         566 :     dateKEY    *kkk = (dateKEY *) DatumGetPointer(entry->key);
     179             :     GBT_NUMKEY_R key;
     180             : 
     181         566 :     key.lower = (GBT_NUMKEY *) &kkk->lower;
     182         566 :     key.upper = (GBT_NUMKEY *) &kkk->upper;
     183             : 
     184         566 :     PG_RETURN_FLOAT8(
     185             :                      gbt_num_distance(&key, (void *) &query, GIST_LEAF(entry), &tinfo, fcinfo->flinfo)
     186             :         );
     187             : }
     188             : 
     189             : 
     190             : Datum
     191         422 : gbt_date_union(PG_FUNCTION_ARGS)
     192             : {
     193         422 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     194         422 :     void       *out = palloc(sizeof(dateKEY));
     195             : 
     196         422 :     *(int *) PG_GETARG_POINTER(1) = sizeof(dateKEY);
     197         422 :     PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo, fcinfo->flinfo));
     198             : }
     199             : 
     200             : 
     201             : Datum
     202         680 : gbt_date_penalty(PG_FUNCTION_ARGS)
     203             : {
     204         680 :     dateKEY    *origentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
     205         680 :     dateKEY    *newentry = (dateKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
     206         680 :     float      *result = (float *) PG_GETARG_POINTER(2);
     207             :     int32       diff,
     208             :                 res;
     209             : 
     210         680 :     diff = DatumGetInt32(DirectFunctionCall2(
     211             :                                              date_mi,
     212             :                                              DateADTGetDatum(newentry->upper),
     213             :                                              DateADTGetDatum(origentry->upper)));
     214             : 
     215         680 :     res = Max(diff, 0);
     216             : 
     217         680 :     diff = DatumGetInt32(DirectFunctionCall2(
     218             :                                              date_mi,
     219             :                                              DateADTGetDatum(origentry->lower),
     220             :                                              DateADTGetDatum(newentry->lower)));
     221             : 
     222         680 :     res += Max(diff, 0);
     223             : 
     224         680 :     *result = 0.0;
     225             : 
     226         680 :     if (res > 0)
     227             :     {
     228         262 :         diff = DatumGetInt32(DirectFunctionCall2(
     229             :                                                  date_mi,
     230             :                                                  DateADTGetDatum(origentry->upper),
     231             :                                                  DateADTGetDatum(origentry->lower)));
     232         262 :         *result += FLT_MIN;
     233         262 :         *result += (float) (res / ((double) (res + diff)));
     234         262 :         *result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
     235             :     }
     236             : 
     237         680 :     PG_RETURN_POINTER(result);
     238             : }
     239             : 
     240             : 
     241             : Datum
     242           2 : gbt_date_picksplit(PG_FUNCTION_ARGS)
     243             : {
     244           2 :     PG_RETURN_POINTER(gbt_num_picksplit(
     245             :                                         (GistEntryVector *) PG_GETARG_POINTER(0),
     246             :                                         (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
     247             :                                         &tinfo, fcinfo->flinfo
     248             :                                         ));
     249             : }
     250             : 
     251             : Datum
     252         420 : gbt_date_same(PG_FUNCTION_ARGS)
     253             : {
     254         420 :     dateKEY    *b1 = (dateKEY *) PG_GETARG_POINTER(0);
     255         420 :     dateKEY    *b2 = (dateKEY *) PG_GETARG_POINTER(1);
     256         420 :     bool       *result = (bool *) PG_GETARG_POINTER(2);
     257             : 
     258         420 :     *result = gbt_num_same((void *) b1, (void *) b2, &tinfo, fcinfo->flinfo);
     259         420 :     PG_RETURN_POINTER(result);
     260             : }

Generated by: LCOV version 1.13