contrib/btree_gin/btree_gin.c

   1 /*
   2  * contrib/btree_gin/btree_gin.c
   3  */
   4 #include "postgres.h"
   5
   6 #include <limits.h>
   7
   8 #include "fmgr.h"
   9 #include "access/skey.h"
  10 #include "utils/builtins.h"
  11 #include "utils/bytea.h"
  12 #include "utils/cash.h"
  13 #include "utils/date.h"
  14 #include "utils/inet.h"
  15 #include "utils/numeric.h"
  16 #include "utils/timestamp.h"
  17 #include "utils/varbit.h"
  18
  19 PG_MODULE_MAGIC;
  20
  21 typedef struct TypeInfo
  22 {
  23         bool            is_varlena;
  24         Datum           (*leftmostvalue) (void);
  25         Datum           (*typecmp) (FunctionCallInfo);
  26 } TypeInfo;
  27
  28 typedef struct QueryInfo
  29 {
  30         StrategyNumber strategy;
  31         Datum           datum;
  32 } QueryInfo;
  33
  34 #define  GIN_EXTRACT_VALUE(type)                                                                                        \
  35 PG_FUNCTION_INFO_V1(gin_extract_value_##type);                                                          \
  36 Datum           gin_extract_value_##type(PG_FUNCTION_ARGS);                                             \
  37 Datum                                                                                                                                           \
  38 gin_extract_value_##type(PG_FUNCTION_ARGS)                                                                      \
  39 {                                                                                                                                                       \
  40         Datum           datum = PG_GETARG_DATUM(0);                                                                     \
  41         int32      *nentries = (int32 *) PG_GETARG_POINTER(1);                                  \
  42         Datum      *entries = (Datum *) palloc(sizeof(Datum));                                  \
  43                                                                                                                                                         \
  44         if ( TypeInfo_##type.is_varlena )                                                                               \
  45                 datum = PointerGetDatum(PG_DETOAST_DATUM(datum));                                       \
  46         entries[0] = datum;                                                                                                             \
  47         *nentries = 1;                                                                                                                  \
  48                                                                                                                                                         \
  49         PG_RETURN_POINTER(entries);                                                                                             \
  50 }
  51
  52 /*
  53  * For BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, and
  54  * BTEqualStrategyNumber we want to start the index scan at the
  55  * supplied query datum, and work forward. For BTLessStrategyNumber
  56  * and BTLessEqualStrategyNumber, we need to start at the leftmost
  57  * key, and work forward until the supplied query datum (which must be
  58  * sent along inside the QueryInfo structure).
  59  */
  60
  61 #define GIN_EXTRACT_QUERY(type)                                                                                         \
  62 PG_FUNCTION_INFO_V1(gin_extract_query_##type);                                                          \
  63 Datum           gin_extract_query_##type(PG_FUNCTION_ARGS);                                             \
  64 Datum                                                                                                                                           \
  65 gin_extract_query_##type(PG_FUNCTION_ARGS)                                                                      \
  66 {                                                                                                                                                       \
  67         Datum           datum = PG_GETARG_DATUM(0);                                                                     \
  68         int32      *nentries = (int32 *) PG_GETARG_POINTER(1);                                  \
  69         StrategyNumber strategy = PG_GETARG_UINT16(2);                                                  \
  70         bool      **partialmatch = (bool **) PG_GETARG_POINTER(3);                              \
  71         Pointer   **extra_data = (Pointer **) PG_GETARG_POINTER(4);                             \
  72         Datum      *entries = (Datum *) palloc(sizeof(Datum));                                  \
  73         QueryInfo  *data = (QueryInfo *) palloc(sizeof(QueryInfo));                             \
  74         bool       *ptr_partialmatch;                                                                                   \
  75                                                                                                                                                         \
  76         *nentries = 1;                                                                                                                  \
  77         ptr_partialmatch = *partialmatch = (bool *) palloc(sizeof(bool));               \
  78         *ptr_partialmatch = false;                                                                                              \
  79         if ( TypeInfo_##type.is_varlena )                                                                               \
  80                 datum = PointerGetDatum(PG_DETOAST_DATUM(datum));                                       \
  81         data->strategy = strategy;                                                                                              \
  82         data->datum = datum;                                                                                                    \
  83         *extra_data = (Pointer *) palloc(sizeof(Pointer));                                              \
  84         **extra_data = (Pointer) data;                                                                                  \
  85                                                                                                                                                         \
  86         switch (strategy)                                                                                                               \
  87         {                                                                                                                                               \
  88                 case BTLessStrategyNumber:                                                                                      \
  89                 case BTLessEqualStrategyNumber:                                                                         \
  90                         entries[0] = TypeInfo_##type.leftmostvalue();                                   \
  91                         *ptr_partialmatch = true;                                                                               \
  92                         break;                                                                                                                  \
  93                 case BTGreaterEqualStrategyNumber:                                                                      \
  94                 case BTGreaterStrategyNumber:                                                                           \
  95                         *ptr_partialmatch = true;                                                                               \
  96                 case BTEqualStrategyNumber:                                                                                     \
  97                         entries[0] = datum;                                                                                             \
  98                         break;                                                                                                                  \
  99                 default:                                                                                                                        \
 100                         elog(ERROR, "unrecognized strategy number: %d", strategy);              \
 101         }                                                                                                                                               \
 102                                                                                                                                                         \
 103         PG_RETURN_POINTER(entries);                                                                                             \
 104 }
 105
 106 /*
 107  * Datum a is a value from extract_query method and for BTLess*
 108  * strategy it is a left-most value.  So, use original datum from QueryInfo
 109  * to decide to stop scanning or not.  Datum b is always from index.
 110  */
 111 #define GIN_COMPARE_PREFIX(type)                                                                                        \
 112 PG_FUNCTION_INFO_V1(gin_compare_prefix_##type);                                                         \
 113 Datum           gin_compare_prefix_##type(PG_FUNCTION_ARGS);                                    \
 114 Datum                                                                                                                                           \
 115 gin_compare_prefix_##type(PG_FUNCTION_ARGS)                                                                     \
 116 {                                                                                                                                                       \
 117         Datum           a = PG_GETARG_DATUM(0);                                                                         \
 118         Datum           b = PG_GETARG_DATUM(1);                                                                         \
 119         QueryInfo  *data = (QueryInfo *) PG_GETARG_POINTER(3);                                  \
 120         int32           res,                                                                                                            \
 121                                 cmp;                                                                                                            \
 122                                                                                                                                                         \
 123         cmp = DatumGetInt32(DirectFunctionCall2(                                                                \
 124                                 TypeInfo_##type.typecmp,                                                                        \
 125                                 (data->strategy == BTLessStrategyNumber ||                                      \
 126                                  data->strategy == BTLessEqualStrategyNumber)                           \
 127                                  ? data->datum : a,                                                                                     \
 128                                 b));                                                                                                            \
 129                                                                                                                                                         \
 130         switch (data->strategy)                                                                                                 \
 131         {                                                                                                                                               \
 132                 case BTLessStrategyNumber:                                                                                      \
 133                         /* If original datum > indexed one then return match */                 \
 134                         if (cmp > 0)                                                                                                    \
 135                                 res = 0;                                                                                                        \
 136                         else                                                                                                                    \
 137                                 res = 1;                                                                                                        \
 138                         break;                                                                                                                  \
 139                 case BTLessEqualStrategyNumber:                                                                         \
 140                         /* The same except equality */                                                                  \
 141                         if (cmp >= 0)                                                                                                   \
 142                                 res = 0;                                                                                                        \
 143                         else                                                                                                                    \
 144                                 res = 1;                                                                                                        \
 145                         break;                                                                                                                  \
 146                 case BTEqualStrategyNumber:                                                                                     \
 147                         if (cmp != 0)                                                                                                   \
 148                                 res = 1;                                                                                                        \
 149                         else                                                                                                                    \
 150                                 res = 0;                                                                                                        \
 151                         break;                                                                                                                  \
 152                 case BTGreaterEqualStrategyNumber:                                                                      \
 153                         /* If original datum <= indexed one then return match */                \
 154                         if (cmp <= 0)                                                                                                   \
 155                                 res = 0;                                                                                                        \
 156                         else                                                                                                                    \
 157                                 res = 1;                                                                                                        \
 158                         break;                                                                                                                  \
 159                 case BTGreaterStrategyNumber:                                                                           \
 160                         /* If original datum <= indexed one then return match */                \
 161                         /* If original datum == indexed one then continue scan */               \
 162                         if (cmp < 0)                                                                                                    \
 163                                 res = 0;                                                                                                        \
 164                         else if (cmp == 0)                                                                                              \
 165                                 res = -1;                                                                                                       \
 166                         else                                                                                                                    \
 167                                 res = 1;                                                                                                        \
 168                         break;                                                                                                                  \
 169                 default:                                                                                                                        \
 170                         elog(ERROR, "unrecognized strategy number: %d",                                 \
 171                                  data->strategy);                                                                                       \
 172                         res = 0;                                                                                                                \
 173         }                                                                                                                                               \
 174                                                                                                                                                         \
 175         PG_RETURN_INT32(res);                                                                                                   \
 176 }
 177
 178 #define GIN_SUPPORT(type)                       \
 179         GIN_EXTRACT_VALUE(type)                 \
 180         GIN_EXTRACT_QUERY(type)                 \
 181         GIN_COMPARE_PREFIX(type)
 182
 183
 184 PG_FUNCTION_INFO_V1(gin_btree_consistent);
 185 Datum           gin_btree_consistent(PG_FUNCTION_ARGS);
 186 Datum
 187 gin_btree_consistent(PG_FUNCTION_ARGS)
 188 {
 189         bool       *recheck = (bool *) PG_GETARG_POINTER(5);
 190
 191         *recheck = false;
 192         PG_RETURN_BOOL(true);
 193 }
 194
 195 static Datum
 196 leftmostvalue_int2(void)
 197 {
 198         return Int16GetDatum(SHRT_MIN);
 199 }
 200 static TypeInfo TypeInfo_int2 = {false, leftmostvalue_int2, btint2cmp};
 201
 202 GIN_SUPPORT(int2)
 203
 204 static Datum
 205 leftmostvalue_int4(void)
 206 {
 207         return Int32GetDatum(INT_MIN);
 208 }
 209 static TypeInfo TypeInfo_int4 = {false, leftmostvalue_int4, btint4cmp};
 210
 211 GIN_SUPPORT(int4)
 212
 213 static Datum
 214 leftmostvalue_int8(void)
 215 {
 216         /*
 217          * Use sequence's definition to keep compatibility.
 218          */
 219         return Int64GetDatum(SEQ_MINVALUE);
 220 }
 221 static TypeInfo TypeInfo_int8 = {false, leftmostvalue_int8, btint8cmp};
 222
 223 GIN_SUPPORT(int8)
 224
 225 static Datum
 226 leftmostvalue_float4(void)
 227 {
 228         return Float4GetDatum(-get_float4_infinity());
 229 }
 230 static TypeInfo TypeInfo_float4 = {false, leftmostvalue_float4, btfloat4cmp};
 231
 232 GIN_SUPPORT(float4)
 233
 234 static Datum
 235 leftmostvalue_float8(void)
 236 {
 237         return Float8GetDatum(-get_float8_infinity());
 238 }
 239 static TypeInfo TypeInfo_float8 = {false, leftmostvalue_float8, btfloat8cmp};
 240
 241 GIN_SUPPORT(float8)
 242
 243 static Datum
 244 leftmostvalue_money(void)
 245 {
 246         /*
 247          * Use sequence's definition to keep compatibility.
 248          */
 249         return Int64GetDatum(SEQ_MINVALUE);
 250 }
 251 static TypeInfo TypeInfo_money = {false, leftmostvalue_money, cash_cmp};
 252
 253 GIN_SUPPORT(money)
 254
 255 static Datum
 256 leftmostvalue_oid(void)
 257 {
 258         return ObjectIdGetDatum(0);
 259 }
 260 static TypeInfo TypeInfo_oid = {false, leftmostvalue_oid, btoidcmp};
 261
 262 GIN_SUPPORT(oid)
 263
 264 static Datum
 265 leftmostvalue_timestamp(void)
 266 {
 267         return TimestampGetDatum(DT_NOBEGIN);
 268 }
 269 static TypeInfo TypeInfo_timestamp = {false, leftmostvalue_timestamp, timestamp_cmp};
 270
 271 GIN_SUPPORT(timestamp)
 272
 273 static TypeInfo TypeInfo_timestamptz = {false, leftmostvalue_timestamp, timestamp_cmp};
 274
 275 GIN_SUPPORT(timestamptz)
 276
 277 static Datum
 278 leftmostvalue_time(void)
 279 {
 280         return TimeADTGetDatum(0);
 281 }
 282 static TypeInfo TypeInfo_time = {false, leftmostvalue_time, time_cmp};
 283
 284 GIN_SUPPORT(time)
 285
 286 static Datum
 287 leftmostvalue_timetz(void)
 288 {
 289         TimeTzADT  *v = palloc(sizeof(TimeTzADT));
 290
 291         v->time = 0;
 292         v->zone = -24 * 3600;           /* XXX is that true? */
 293
 294         return TimeTzADTPGetDatum(v);
 295 }
 296 static TypeInfo TypeInfo_timetz = {false, leftmostvalue_timetz, timetz_cmp};
 297
 298 GIN_SUPPORT(timetz)
 299
 300 static Datum
 301 leftmostvalue_date(void)
 302 {
 303         return DateADTGetDatum(DATEVAL_NOBEGIN);
 304 }
 305 static TypeInfo TypeInfo_date = {false, leftmostvalue_date, date_cmp};
 306
 307 GIN_SUPPORT(date)
 308
 309 static Datum
 310 leftmostvalue_interval(void)
 311 {
 312         Interval   *v = palloc(sizeof(Interval));
 313
 314         v->time = DT_NOBEGIN;
 315         v->day = 0;
 316         v->month = 0;
 317         return IntervalPGetDatum(v);
 318 }
 319 static TypeInfo TypeInfo_interval = {false, leftmostvalue_interval, interval_cmp};
 320
 321 GIN_SUPPORT(interval)
 322
 323 static Datum
 324 leftmostvalue_macaddr(void)
 325 {
 326         macaddr    *v = palloc0(sizeof(macaddr));
 327
 328         return MacaddrPGetDatum(v);
 329 }
 330 static TypeInfo TypeInfo_macaddr = {false, leftmostvalue_macaddr, macaddr_cmp};
 331
 332 GIN_SUPPORT(macaddr)
 333
 334 static Datum
 335 leftmostvalue_inet(void)
 336 {
 337         return DirectFunctionCall3(inet_in,
 338                                                            CStringGetDatum("0.0.0.0/0"),
 339                                                            ObjectIdGetDatum(0),
 340                                                            Int32GetDatum(-1));
 341 }
 342 static TypeInfo TypeInfo_inet = {true, leftmostvalue_inet, network_cmp};
 343
 344 GIN_SUPPORT(inet)
 345
 346 static TypeInfo TypeInfo_cidr = {true, leftmostvalue_inet, network_cmp};
 347
 348 GIN_SUPPORT(cidr)
 349
 350 static Datum
 351 leftmostvalue_text(void)
 352 {
 353         return PointerGetDatum(cstring_to_text_with_len("", 0));
 354 }
 355 static TypeInfo TypeInfo_text = {true, leftmostvalue_text, bttextcmp};
 356
 357 GIN_SUPPORT(text)
 358
 359 static Datum
 360 leftmostvalue_char(void)
 361 {
 362         return CharGetDatum(SCHAR_MIN);
 363 }
 364 static TypeInfo TypeInfo_char = {false, leftmostvalue_char, btcharcmp};
 365
 366 GIN_SUPPORT(char)
 367
 368 static TypeInfo TypeInfo_bytea = {true, leftmostvalue_text, byteacmp};
 369
 370 GIN_SUPPORT(bytea)
 371
 372 static Datum
 373 leftmostvalue_bit(void)
 374 {
 375         return DirectFunctionCall3(bit_in,
 376                                                            CStringGetDatum(""),
 377                                                            ObjectIdGetDatum(0),
 378                                                            Int32GetDatum(-1));
 379 }
 380 static TypeInfo TypeInfo_bit = {true, leftmostvalue_bit, bitcmp};
 381
 382 GIN_SUPPORT(bit)
 383
 384 static Datum
 385 leftmostvalue_varbit(void)
 386 {
 387         return DirectFunctionCall3(varbit_in,
 388                                                            CStringGetDatum(""),
 389                                                            ObjectIdGetDatum(0),
 390                                                            Int32GetDatum(-1));
 391 }
 392 static TypeInfo TypeInfo_varbit = {true, leftmostvalue_varbit, bitcmp};
 393
 394 GIN_SUPPORT(varbit)
 395
 396 /*
 397  * Numeric type hasn't a real left-most value, so we use PointerGetDatum(NULL)
 398  * (*not* a SQL NULL) to represent that.  We can get away with that because
 399  * the value returned by our leftmostvalue function will never be stored in
 400  * the index nor passed to anything except our compare and prefix-comparison
 401  * functions.  The same trick could be used for other pass-by-reference types.
 402  */
 403
 404 #define NUMERIC_IS_LEFTMOST(x)  ((x) == NULL)
 405
 406 PG_FUNCTION_INFO_V1(gin_numeric_cmp);
 407 Datum           gin_numeric_cmp(PG_FUNCTION_ARGS);
 408
 409 Datum
 410 gin_numeric_cmp(PG_FUNCTION_ARGS)
 411 {
 412         Numeric         a = (Numeric) PG_GETARG_POINTER(0);
 413         Numeric         b = (Numeric) PG_GETARG_POINTER(1);
 414         int                     res = 0;
 415
 416         if (NUMERIC_IS_LEFTMOST(a))
 417         {
 418                 res = (NUMERIC_IS_LEFTMOST(b)) ? 0 : -1;
 419         }
 420         else if (NUMERIC_IS_LEFTMOST(b))
 421         {
 422                 res = 1;
 423         }
 424         else
 425         {
 426                 res = DatumGetInt32(DirectFunctionCall2(numeric_cmp,
 427                                                                                                 NumericGetDatum(a),
 428                                                                                                 NumericGetDatum(b)));
 429         }
 430
 431         PG_RETURN_INT32(res);
 432 }
 433
 434 static Datum
 435 leftmostvalue_numeric(void)
 436 {
 437         return PointerGetDatum(NULL);
 438 }
 439
 440 static TypeInfo TypeInfo_numeric = {true, leftmostvalue_numeric, gin_numeric_cmp};
 441
 442 GIN_SUPPORT(numeric)