Line data    Source code

       1             : /*
       2             :  * contrib/btree_gist/btree_bytea.c
       3             :  */
       4             : #include "postgres.h"
       5             : 
       6             : #include "btree_gist.h"
       7             : #include "btree_utils_var.h"
       8             : #include "utils/fmgrprotos.h"
       9             : 
      10             : 
      11             : /*
      12             : ** Bytea ops
      13             : */
      14           4 : PG_FUNCTION_INFO_V1(gbt_bytea_compress);
      15           4 : PG_FUNCTION_INFO_V1(gbt_bytea_union);
      16           4 : PG_FUNCTION_INFO_V1(gbt_bytea_picksplit);
      17           4 : PG_FUNCTION_INFO_V1(gbt_bytea_consistent);
      18           4 : PG_FUNCTION_INFO_V1(gbt_bytea_penalty);
      19           4 : PG_FUNCTION_INFO_V1(gbt_bytea_same);
      20             : 
      21             : 
      22             : /* define for comparison */
      23             : 
      24             : static bool
      25        1190 : gbt_byteagt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      26             : {
      27        1190 :     return DatumGetBool(DirectFunctionCall2(byteagt,
      28             :                                             PointerGetDatum(a),
      29             :                                             PointerGetDatum(b)));
      30             : }
      31             : 
      32             : static bool
      33        1190 : gbt_byteage(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      34             : {
      35        1190 :     return DatumGetBool(DirectFunctionCall2(byteage,
      36             :                                             PointerGetDatum(a),
      37             :                                             PointerGetDatum(b)));
      38             : }
      39             : 
      40             : static bool
      41        2380 : gbt_byteaeq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      42             : {
      43        2380 :     return DatumGetBool(DirectFunctionCall2(byteaeq,
      44             :                                             PointerGetDatum(a),
      45             :                                             PointerGetDatum(b)));
      46             : }
      47             : 
      48             : static bool
      49        1978 : gbt_byteale(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      50             : {
      51        1978 :     return DatumGetBool(DirectFunctionCall2(byteale,
      52             :                                             PointerGetDatum(a),
      53             :                                             PointerGetDatum(b)));
      54             : }
      55             : 
      56             : static bool
      57        3280 : gbt_bytealt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      58             : {
      59        3280 :     return DatumGetBool(DirectFunctionCall2(bytealt,
      60             :                                             PointerGetDatum(a),
      61             :                                             PointerGetDatum(b)));
      62             : }
      63             : 
      64             : static int32
      65       39308 : gbt_byteacmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
      66             : {
      67       39308 :     return DatumGetInt32(DirectFunctionCall2(byteacmp,
      68             :                                              PointerGetDatum(a),
      69             :                                              PointerGetDatum(b)));
      70             : }
      71             : 
      72             : 
      73             : static const gbtree_vinfo tinfo =
      74             : {
      75             :     gbt_t_bytea,
      76             :     0,
      77             :     true,
      78             :     gbt_byteagt,
      79             :     gbt_byteage,
      80             :     gbt_byteaeq,
      81             :     gbt_byteale,
      82             :     gbt_bytealt,
      83             :     gbt_byteacmp,
      84             :     NULL
      85             : };
      86             : 
      87             : 
      88             : /**************************************************
      89             :  * Text ops
      90             :  **************************************************/
      91             : 
      92             : 
      93             : Datum
      94        2000 : gbt_bytea_compress(PG_FUNCTION_ARGS)
      95             : {
      96        2000 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
      97             : 
      98        2000 :     PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo));
      99             : }
     100             : 
     101             : 
     102             : 
     103             : Datum
     104       10102 : gbt_bytea_consistent(PG_FUNCTION_ARGS)
     105             : {
     106       10102 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     107       10102 :     void       *query = DatumGetByteaP(PG_GETARG_DATUM(1));
     108       10102 :     StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
     109             : 
     110             :     /* Oid      subtype = PG_GETARG_OID(3); */
     111       10102 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     112             :     bool        retval;
     113       10102 :     GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key);
     114       10102 :     GBT_VARKEY_R r = gbt_var_key_readable(key);
     115             : 
     116             :     /* All cases served by this function are exact */
     117       10102 :     *recheck = false;
     118             : 
     119       20204 :     retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(),
     120       10102 :                                 GIST_LEAF(entry), &tinfo, fcinfo->flinfo);
     121       10102 :     PG_RETURN_BOOL(retval);
     122             : }
     123             : 
     124             : 
     125             : 
     126             : Datum
     127        1714 : gbt_bytea_union(PG_FUNCTION_ARGS)
     128             : {
     129        1714 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     130        1714 :     int32      *size = (int *) PG_GETARG_POINTER(1);
     131             : 
     132        1714 :     PG_RETURN_POINTER(gbt_var_union(entryvec, size, PG_GET_COLLATION(),
     133             :                                     &tinfo, fcinfo->flinfo));
     134             : }
     135             : 
     136             : 
     137             : Datum
     138          10 : gbt_bytea_picksplit(PG_FUNCTION_ARGS)
     139             : {
     140          10 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     141          10 :     GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
     142             : 
     143          10 :     gbt_var_picksplit(entryvec, v, PG_GET_COLLATION(),
     144             :                       &tinfo, fcinfo->flinfo);
     145          10 :     PG_RETURN_POINTER(v);
     146             : }
     147             : 
     148             : Datum
     149        1712 : gbt_bytea_same(PG_FUNCTION_ARGS)
     150             : {
     151        1712 :     Datum       d1 = PG_GETARG_DATUM(0);
     152        1712 :     Datum       d2 = PG_GETARG_DATUM(1);
     153        1712 :     bool       *result = (bool *) PG_GETARG_POINTER(2);
     154             : 
     155        1712 :     *result = gbt_var_same(d1, d2, PG_GET_COLLATION(), &tinfo, fcinfo->flinfo);
     156        1712 :     PG_RETURN_POINTER(result);
     157             : }
     158             : 
     159             : 
     160             : Datum
     161        6470 : gbt_bytea_penalty(PG_FUNCTION_ARGS)
     162             : {
     163        6470 :     GISTENTRY  *o = (GISTENTRY *) PG_GETARG_POINTER(0);
     164        6470 :     GISTENTRY  *n = (GISTENTRY *) PG_GETARG_POINTER(1);
     165        6470 :     float      *result = (float *) PG_GETARG_POINTER(2);
     166             : 
     167        6470 :     PG_RETURN_POINTER(gbt_var_penalty(result, o, n, PG_GET_COLLATION(),
     168             :                                       &tinfo, fcinfo->flinfo));
     169             : }