contrib/citext/citext.c

   1 /*
   2  * $PostgreSQL$
   3  */
   4 #include "postgres.h"
   5
   6 #include "access/hash.h"
   7 #include "fmgr.h"
   8 #include "utils/builtins.h"
   9 #include "utils/formatting.h"
  10
  11 #ifdef PG_MODULE_MAGIC
  12 PG_MODULE_MAGIC;
  13 #endif
  14
  15 /*
  16  *              ====================
  17  *              FORWARD DECLARATIONS
  18  *              ====================
  19  */
  20
  21 static int32 citextcmp(text *left, text *right);
  22 extern Datum citext_cmp(PG_FUNCTION_ARGS);
  23 extern Datum citext_hash(PG_FUNCTION_ARGS);
  24 extern Datum citext_eq(PG_FUNCTION_ARGS);
  25 extern Datum citext_ne(PG_FUNCTION_ARGS);
  26 extern Datum citext_gt(PG_FUNCTION_ARGS);
  27 extern Datum citext_ge(PG_FUNCTION_ARGS);
  28 extern Datum citext_lt(PG_FUNCTION_ARGS);
  29 extern Datum citext_le(PG_FUNCTION_ARGS);
  30 extern Datum citext_smaller(PG_FUNCTION_ARGS);
  31 extern Datum citext_larger(PG_FUNCTION_ARGS);
  32
  33 /*
  34  *              =================
  35  *              UTILITY FUNCTIONS
  36  *              =================
  37  */
  38
  39 /*
  40  * citextcmp()
  41  * Internal comparison function for citext strings.
  42  * Returns int32 negative, zero, or positive.
  43  */
  44 static int32
  45 citextcmp(text *left, text *right)
  46 {
  47         char       *lcstr,
  48                            *rcstr;
  49         int32           result;
  50
  51         lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
  52         rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
  53
  54         result = varstr_cmp(lcstr, strlen(lcstr),
  55                                                 rcstr, strlen(rcstr));
  56
  57         pfree(lcstr);
  58         pfree(rcstr);
  59
  60         return result;
  61 }
  62
  63 /*
  64  *              ==================
  65  *              INDEXING FUNCTIONS
  66  *              ==================
  67  */
  68
  69 PG_FUNCTION_INFO_V1(citext_cmp);
  70
  71 Datum
  72 citext_cmp(PG_FUNCTION_ARGS)
  73 {
  74         text       *left = PG_GETARG_TEXT_PP(0);
  75         text       *right = PG_GETARG_TEXT_PP(1);
  76         int32           result;
  77
  78         result = citextcmp(left, right);
  79
  80         PG_FREE_IF_COPY(left, 0);
  81         PG_FREE_IF_COPY(right, 1);
  82
  83         PG_RETURN_INT32(result);
  84 }
  85
  86 PG_FUNCTION_INFO_V1(citext_hash);
  87
  88 Datum
  89 citext_hash(PG_FUNCTION_ARGS)
  90 {
  91         text       *txt = PG_GETARG_TEXT_PP(0);
  92         char       *str;
  93         Datum           result;
  94
  95         str = str_tolower(VARDATA_ANY(txt), VARSIZE_ANY_EXHDR(txt));
  96         result = hash_any((unsigned char *) str, strlen(str));
  97         pfree(str);
  98
  99         /* Avoid leaking memory for toasted inputs */
 100         PG_FREE_IF_COPY(txt, 0);
 101
 102         PG_RETURN_DATUM(result);
 103 }
 104
 105 /*
 106  *              ==================
 107  *              OPERATOR FUNCTIONS
 108  *              ==================
 109  */
 110
 111 PG_FUNCTION_INFO_V1(citext_eq);
 112
 113 Datum
 114 citext_eq(PG_FUNCTION_ARGS)
 115 {
 116         text       *left = PG_GETARG_TEXT_PP(0);
 117         text       *right = PG_GETARG_TEXT_PP(1);
 118         char       *lcstr,
 119                            *rcstr;
 120         bool            result;
 121
 122         /* We can't compare lengths in advance of downcasing ... */
 123
 124         lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
 125         rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
 126
 127         /*
 128          * Since we only care about equality or not-equality, we can avoid all the
 129          * expense of strcoll() here, and just do bitwise comparison.
 130          */
 131         result = (strcmp(lcstr, rcstr) == 0);
 132
 133         pfree(lcstr);
 134         pfree(rcstr);
 135         PG_FREE_IF_COPY(left, 0);
 136         PG_FREE_IF_COPY(right, 1);
 137
 138         PG_RETURN_BOOL(result);
 139 }
 140
 141 PG_FUNCTION_INFO_V1(citext_ne);
 142
 143 Datum
 144 citext_ne(PG_FUNCTION_ARGS)
 145 {
 146         text       *left = PG_GETARG_TEXT_PP(0);
 147         text       *right = PG_GETARG_TEXT_PP(1);
 148         char       *lcstr,
 149                            *rcstr;
 150         bool            result;
 151
 152         /* We can't compare lengths in advance of downcasing ... */
 153
 154         lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
 155         rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
 156
 157         /*
 158          * Since we only care about equality or not-equality, we can avoid all the
 159          * expense of strcoll() here, and just do bitwise comparison.
 160          */
 161         result = (strcmp(lcstr, rcstr) != 0);
 162
 163         pfree(lcstr);
 164         pfree(rcstr);
 165         PG_FREE_IF_COPY(left, 0);
 166         PG_FREE_IF_COPY(right, 1);
 167
 168         PG_RETURN_BOOL(result);
 169 }
 170
 171 PG_FUNCTION_INFO_V1(citext_lt);
 172
 173 Datum
 174 citext_lt(PG_FUNCTION_ARGS)
 175 {
 176         text       *left = PG_GETARG_TEXT_PP(0);
 177         text       *right = PG_GETARG_TEXT_PP(1);
 178         bool            result;
 179
 180         result = citextcmp(left, right) < 0;
 181
 182         PG_FREE_IF_COPY(left, 0);
 183         PG_FREE_IF_COPY(right, 1);
 184
 185         PG_RETURN_BOOL(result);
 186 }
 187
 188 PG_FUNCTION_INFO_V1(citext_le);
 189
 190 Datum
 191 citext_le(PG_FUNCTION_ARGS)
 192 {
 193         text       *left = PG_GETARG_TEXT_PP(0);
 194         text       *right = PG_GETARG_TEXT_PP(1);
 195         bool            result;
 196
 197         result = citextcmp(left, right) <= 0;
 198
 199         PG_FREE_IF_COPY(left, 0);
 200         PG_FREE_IF_COPY(right, 1);
 201
 202         PG_RETURN_BOOL(result);
 203 }
 204
 205 PG_FUNCTION_INFO_V1(citext_gt);
 206
 207 Datum
 208 citext_gt(PG_FUNCTION_ARGS)
 209 {
 210         text       *left = PG_GETARG_TEXT_PP(0);
 211         text       *right = PG_GETARG_TEXT_PP(1);
 212         bool            result;
 213
 214         result = citextcmp(left, right) > 0;
 215
 216         PG_FREE_IF_COPY(left, 0);
 217         PG_FREE_IF_COPY(right, 1);
 218
 219         PG_RETURN_BOOL(result);
 220 }
 221
 222 PG_FUNCTION_INFO_V1(citext_ge);
 223
 224 Datum
 225 citext_ge(PG_FUNCTION_ARGS)
 226 {
 227         text       *left = PG_GETARG_TEXT_PP(0);
 228         text       *right = PG_GETARG_TEXT_PP(1);
 229         bool            result;
 230
 231         result = citextcmp(left, right) >= 0;
 232
 233         PG_FREE_IF_COPY(left, 0);
 234         PG_FREE_IF_COPY(right, 1);
 235
 236         PG_RETURN_BOOL(result);
 237 }
 238
 239 /*
 240  *              ===================
 241  *              AGGREGATE FUNCTIONS
 242  *              ===================
 243  */
 244
 245 PG_FUNCTION_INFO_V1(citext_smaller);
 246
 247 Datum
 248 citext_smaller(PG_FUNCTION_ARGS)
 249 {
 250         text       *left = PG_GETARG_TEXT_PP(0);
 251         text       *right = PG_GETARG_TEXT_PP(1);
 252         text       *result;
 253
 254         result = citextcmp(left, right) < 0 ? left : right;
 255         PG_RETURN_TEXT_P(result);
 256 }
 257
 258 PG_FUNCTION_INFO_V1(citext_larger);
 259
 260 Datum
 261 citext_larger(PG_FUNCTION_ARGS)
 262 {
 263         text       *left = PG_GETARG_TEXT_PP(0);
 264         text       *right = PG_GETARG_TEXT_PP(1);
 265         text       *result;
 266
 267         result = citextcmp(left, right) > 0 ? left : right;
 268         PG_RETURN_TEXT_P(result);
 269 }