LCOV - code coverage report
Current view: top level - contrib/btree_gist - btree_text.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 84 85 98.8 %
Date: 2024-12-12 16:15:21 Functions: 28 28 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * contrib/btree_gist/btree_text.c
       3             :  */
       4             : #include "postgres.h"
       5             : 
       6             : #include "btree_gist.h"
       7             : #include "btree_utils_var.h"
       8             : #include "mb/pg_wchar.h"
       9             : #include "utils/fmgrprotos.h"
      10             : 
      11             : /*
      12             : ** Text ops
      13             : */
      14           8 : PG_FUNCTION_INFO_V1(gbt_text_compress);
      15           4 : PG_FUNCTION_INFO_V1(gbt_bpchar_compress);
      16          10 : PG_FUNCTION_INFO_V1(gbt_text_union);
      17          10 : PG_FUNCTION_INFO_V1(gbt_text_picksplit);
      18           8 : PG_FUNCTION_INFO_V1(gbt_text_consistent);
      19           4 : PG_FUNCTION_INFO_V1(gbt_bpchar_consistent);
      20          10 : PG_FUNCTION_INFO_V1(gbt_text_penalty);
      21          10 : PG_FUNCTION_INFO_V1(gbt_text_same);
      22             : 
      23             : 
      24             : /* define for comparison */
      25             : 
      26             : static bool
      27        2390 : gbt_textgt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      28             : {
      29        2390 :     return DatumGetBool(DirectFunctionCall2Coll(text_gt,
      30             :                                                 collation,
      31             :                                                 PointerGetDatum(a),
      32             :                                                 PointerGetDatum(b)));
      33             : }
      34             : 
      35             : static bool
      36        2404 : gbt_textge(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      37             : {
      38        2404 :     return DatumGetBool(DirectFunctionCall2Coll(text_ge,
      39             :                                                 collation,
      40             :                                                 PointerGetDatum(a),
      41             :                                                 PointerGetDatum(b)));
      42             : }
      43             : 
      44             : static bool
      45         614 : gbt_texteq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      46             : {
      47         614 :     return DatumGetBool(DirectFunctionCall2Coll(texteq,
      48             :                                                 collation,
      49             :                                                 PointerGetDatum(a),
      50             :                                                 PointerGetDatum(b)));
      51             : }
      52             : 
      53             : static bool
      54        2154 : gbt_textle(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      55             : {
      56        2154 :     return DatumGetBool(DirectFunctionCall2Coll(text_le,
      57             :                                                 collation,
      58             :                                                 PointerGetDatum(a),
      59             :                                                 PointerGetDatum(b)));
      60             : }
      61             : 
      62             : static bool
      63        2014 : gbt_textlt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      64             : {
      65        2014 :     return DatumGetBool(DirectFunctionCall2Coll(text_lt,
      66             :                                                 collation,
      67             :                                                 PointerGetDatum(a),
      68             :                                                 PointerGetDatum(b)));
      69             : }
      70             : 
      71             : static int32
      72      123514 : gbt_textcmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      73             : {
      74      123514 :     return DatumGetInt32(DirectFunctionCall2Coll(bttextcmp,
      75             :                                                  collation,
      76             :                                                  PointerGetDatum(a),
      77             :                                                  PointerGetDatum(b)));
      78             : }
      79             : 
      80             : static gbtree_vinfo tinfo =
      81             : {
      82             :     gbt_t_text,
      83             :     0,
      84             :     false,
      85             :     gbt_textgt,
      86             :     gbt_textge,
      87             :     gbt_texteq,
      88             :     gbt_textle,
      89             :     gbt_textlt,
      90             :     gbt_textcmp,
      91             :     NULL
      92             : };
      93             : 
      94             : /* bpchar needs its own comparison rules */
      95             : 
      96             : static bool
      97        1190 : gbt_bpchargt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      98             : {
      99        1190 :     return DatumGetBool(DirectFunctionCall2Coll(bpchargt,
     100             :                                                 collation,
     101             :                                                 PointerGetDatum(a),
     102             :                                                 PointerGetDatum(b)));
     103             : }
     104             : 
     105             : static bool
     106        1206 : gbt_bpcharge(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
     107             : {
     108        1206 :     return DatumGetBool(DirectFunctionCall2Coll(bpcharge,
     109             :                                                 collation,
     110             :                                                 PointerGetDatum(a),
     111             :                                                 PointerGetDatum(b)));
     112             : }
     113             : 
     114             : static bool
     115         142 : gbt_bpchareq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
     116             : {
     117         142 :     return DatumGetBool(DirectFunctionCall2Coll(bpchareq,
     118             :                                                 collation,
     119             :                                                 PointerGetDatum(a),
     120             :                                                 PointerGetDatum(b)));
     121             : }
     122             : 
     123             : static bool
     124        1070 : gbt_bpcharle(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
     125             : {
     126        1070 :     return DatumGetBool(DirectFunctionCall2Coll(bpcharle,
     127             :                                                 collation,
     128             :                                                 PointerGetDatum(a),
     129             :                                                 PointerGetDatum(b)));
     130             : }
     131             : 
     132             : static bool
     133         928 : gbt_bpcharlt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
     134             : {
     135         928 :     return DatumGetBool(DirectFunctionCall2Coll(bpcharlt,
     136             :                                                 collation,
     137             :                                                 PointerGetDatum(a),
     138             :                                                 PointerGetDatum(b)));
     139             : }
     140             : 
     141             : static int32
     142         142 : gbt_bpcharcmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
     143             : {
     144         142 :     return DatumGetInt32(DirectFunctionCall2Coll(bpcharcmp,
     145             :                                                  collation,
     146             :                                                  PointerGetDatum(a),
     147             :                                                  PointerGetDatum(b)));
     148             : }
     149             : 
     150             : static gbtree_vinfo bptinfo =
     151             : {
     152             :     gbt_t_bpchar,
     153             :     0,
     154             :     false,
     155             :     gbt_bpchargt,
     156             :     gbt_bpcharge,
     157             :     gbt_bpchareq,
     158             :     gbt_bpcharle,
     159             :     gbt_bpcharlt,
     160             :     gbt_bpcharcmp,
     161             :     NULL
     162             : };
     163             : 
     164             : 
     165             : /**************************************************
     166             :  * Text ops
     167             :  **************************************************/
     168             : 
     169             : 
     170             : Datum
     171        6040 : gbt_text_compress(PG_FUNCTION_ARGS)
     172             : {
     173        6040 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     174             : 
     175        6040 :     if (tinfo.eml == 0)
     176             :     {
     177           8 :         tinfo.eml = pg_database_encoding_max_length();
     178             :     }
     179             : 
     180        6040 :     PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo));
     181             : }
     182             : 
     183             : Datum
     184        2022 : gbt_bpchar_compress(PG_FUNCTION_ARGS)
     185             : {
     186             :     /* This should never have been distinct from gbt_text_compress */
     187        2022 :     return gbt_text_compress(fcinfo);
     188             : }
     189             : 
     190             : 
     191             : 
     192             : Datum
     193        9718 : gbt_text_consistent(PG_FUNCTION_ARGS)
     194             : {
     195        9718 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     196        9718 :     void       *query = DatumGetTextP(PG_GETARG_DATUM(1));
     197        9718 :     StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
     198             : 
     199             :     /* Oid      subtype = PG_GETARG_OID(3); */
     200        9718 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     201             :     bool        retval;
     202        9718 :     GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key);
     203        9718 :     GBT_VARKEY_R r = gbt_var_key_readable(key);
     204             : 
     205             :     /* All cases served by this function are exact */
     206        9718 :     *recheck = false;
     207             : 
     208        9718 :     if (tinfo.eml == 0)
     209             :     {
     210           0 :         tinfo.eml = pg_database_encoding_max_length();
     211             :     }
     212             : 
     213       19436 :     retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(),
     214        9718 :                                 GIST_LEAF(entry), &tinfo, fcinfo->flinfo);
     215             : 
     216        9718 :     PG_RETURN_BOOL(retval);
     217             : }
     218             : 
     219             : 
     220             : Datum
     221        4664 : gbt_bpchar_consistent(PG_FUNCTION_ARGS)
     222             : {
     223        4664 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     224        4664 :     void       *query = DatumGetTextP(PG_GETARG_DATUM(1));
     225        4664 :     StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
     226             : 
     227             :     /* Oid      subtype = PG_GETARG_OID(3); */
     228        4664 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     229             :     bool        retval;
     230        4664 :     GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key);
     231        4664 :     GBT_VARKEY_R r = gbt_var_key_readable(key);
     232             : 
     233             :     /* All cases served by this function are exact */
     234        4664 :     *recheck = false;
     235             : 
     236        4664 :     if (bptinfo.eml == 0)
     237             :     {
     238           2 :         bptinfo.eml = pg_database_encoding_max_length();
     239             :     }
     240             : 
     241        9328 :     retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(),
     242        4664 :                                 GIST_LEAF(entry), &bptinfo, fcinfo->flinfo);
     243        4664 :     PG_RETURN_BOOL(retval);
     244             : }
     245             : 
     246             : 
     247             : Datum
     248        4984 : gbt_text_union(PG_FUNCTION_ARGS)
     249             : {
     250        4984 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     251        4984 :     int32      *size = (int *) PG_GETARG_POINTER(1);
     252             : 
     253        4984 :     PG_RETURN_POINTER(gbt_var_union(entryvec, size, PG_GET_COLLATION(),
     254             :                                     &tinfo, fcinfo->flinfo));
     255             : }
     256             : 
     257             : 
     258             : Datum
     259          38 : gbt_text_picksplit(PG_FUNCTION_ARGS)
     260             : {
     261          38 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     262          38 :     GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
     263             : 
     264          38 :     gbt_var_picksplit(entryvec, v, PG_GET_COLLATION(),
     265             :                       &tinfo, fcinfo->flinfo);
     266          38 :     PG_RETURN_POINTER(v);
     267             : }
     268             : 
     269             : Datum
     270        4978 : gbt_text_same(PG_FUNCTION_ARGS)
     271             : {
     272        4978 :     Datum       d1 = PG_GETARG_DATUM(0);
     273        4978 :     Datum       d2 = PG_GETARG_DATUM(1);
     274        4978 :     bool       *result = (bool *) PG_GETARG_POINTER(2);
     275             : 
     276        4978 :     *result = gbt_var_same(d1, d2, PG_GET_COLLATION(), &tinfo, fcinfo->flinfo);
     277        4978 :     PG_RETURN_POINTER(result);
     278             : }
     279             : 
     280             : 
     281             : Datum
     282       19122 : gbt_text_penalty(PG_FUNCTION_ARGS)
     283             : {
     284       19122 :     GISTENTRY  *o = (GISTENTRY *) PG_GETARG_POINTER(0);
     285       19122 :     GISTENTRY  *n = (GISTENTRY *) PG_GETARG_POINTER(1);
     286       19122 :     float      *result = (float *) PG_GETARG_POINTER(2);
     287             : 
     288       19122 :     PG_RETURN_POINTER(gbt_var_penalty(result, o, n, PG_GET_COLLATION(),
     289             :                                       &tinfo, fcinfo->flinfo));
     290             : }

Generated by: LCOV version 1.14