Branch data Line data Source code
1 : : /*
2 : : * contrib/citext/citext.c
3 : : */
4 : : #include "postgres.h"
5 : :
6 : : #include "catalog/pg_collation.h"
7 : : #include "common/hashfn.h"
8 : : #include "fmgr.h"
9 : : #include "utils/formatting.h"
10 : : #include "utils/varlena.h"
11 : : #include "varatt.h"
12 : :
13 : 3 : PG_MODULE_MAGIC_EXT(
14 : : .name = "citext",
15 : : .version = PG_VERSION
16 : : );
17 : :
18 : : /*
19 : : * ====================
20 : : * FORWARD DECLARATIONS
21 : : * ====================
22 : : */
23 : :
24 : : static int32 citextcmp(text *left, text *right, Oid collid);
25 : : static int32 internal_citext_pattern_cmp(text *left, text *right, Oid collid);
26 : :
27 : : /*
28 : : * =================
29 : : * UTILITY FUNCTIONS
30 : : * =================
31 : : */
32 : :
33 : : /*
34 : : * citextcmp()
35 : : * Internal comparison function for citext strings.
36 : : * Returns int32 negative, zero, or positive.
37 : : */
38 : : static int32
39 : 150 : citextcmp(text *left, text *right, Oid collid)
40 : : {
41 : : char *lcstr,
42 : : *rcstr;
43 : : int32 result;
44 : :
45 : : /*
46 : : * We must do our str_tolower calls with DEFAULT_COLLATION_OID, not the
47 : : * input collation as you might expect. This is so that the behavior of
48 : : * citext's equality and hashing functions is not collation-dependent. We
49 : : * should change this once the core infrastructure is able to cope with
50 : : * collation-dependent equality and hashing functions.
51 : : */
52 : :
53 : 150 : lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left), DEFAULT_COLLATION_OID);
54 : 150 : rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right), DEFAULT_COLLATION_OID);
55 : :
56 : 150 : result = varstr_cmp(lcstr, strlen(lcstr),
57 : 150 : rcstr, strlen(rcstr),
58 : : collid);
59 : :
60 : 150 : pfree(lcstr);
61 : 150 : pfree(rcstr);
62 : :
63 : 150 : return result;
64 : : }
65 : :
66 : : /*
67 : : * citext_pattern_cmp()
68 : : * Internal character-by-character comparison function for citext strings.
69 : : * Returns int32 negative, zero, or positive.
70 : : */
71 : : static int32
72 : 54 : internal_citext_pattern_cmp(text *left, text *right, Oid collid)
73 : : {
74 : : char *lcstr,
75 : : *rcstr;
76 : : int llen,
77 : : rlen;
78 : : int32 result;
79 : :
80 : 54 : lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left), DEFAULT_COLLATION_OID);
81 : 54 : rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right), DEFAULT_COLLATION_OID);
82 : :
83 : 54 : llen = strlen(lcstr);
84 : 54 : rlen = strlen(rcstr);
85 : :
86 : 54 : result = memcmp(lcstr, rcstr, Min(llen, rlen));
87 [ + + ]: 54 : if (result == 0)
88 : : {
89 [ + + ]: 20 : if (llen < rlen)
90 : 1 : result = -1;
91 [ + + ]: 19 : else if (llen > rlen)
92 : 1 : result = 1;
93 : : }
94 : :
95 : 54 : pfree(lcstr);
96 : 54 : pfree(rcstr);
97 : :
98 : 54 : return result;
99 : : }
100 : :
101 : : /*
102 : : * ==================
103 : : * INDEXING FUNCTIONS
104 : : * ==================
105 : : */
106 : :
107 : 5 : PG_FUNCTION_INFO_V1(citext_cmp);
108 : :
109 : : Datum
110 : 131 : citext_cmp(PG_FUNCTION_ARGS)
111 : : {
112 : 131 : text *left = PG_GETARG_TEXT_PP(0);
113 : 131 : text *right = PG_GETARG_TEXT_PP(1);
114 : : int32 result;
115 : :
116 : 131 : result = citextcmp(left, right, PG_GET_COLLATION());
117 : :
118 [ - + ]: 131 : PG_FREE_IF_COPY(left, 0);
119 [ - + ]: 131 : PG_FREE_IF_COPY(right, 1);
120 : :
121 : 131 : PG_RETURN_INT32(result);
122 : : }
123 : :
124 : 4 : PG_FUNCTION_INFO_V1(citext_pattern_cmp);
125 : :
126 : : Datum
127 : 10 : citext_pattern_cmp(PG_FUNCTION_ARGS)
128 : : {
129 : 10 : text *left = PG_GETARG_TEXT_PP(0);
130 : 10 : text *right = PG_GETARG_TEXT_PP(1);
131 : : int32 result;
132 : :
133 : 10 : result = internal_citext_pattern_cmp(left, right, PG_GET_COLLATION());
134 : :
135 [ - + ]: 10 : PG_FREE_IF_COPY(left, 0);
136 [ - + ]: 10 : PG_FREE_IF_COPY(right, 1);
137 : :
138 : 10 : PG_RETURN_INT32(result);
139 : : }
140 : :
141 : 3 : PG_FUNCTION_INFO_V1(citext_hash);
142 : :
143 : : Datum
144 : 10 : citext_hash(PG_FUNCTION_ARGS)
145 : : {
146 : 10 : text *txt = PG_GETARG_TEXT_PP(0);
147 : : char *str;
148 : : Datum result;
149 : :
150 : 10 : str = str_tolower(VARDATA_ANY(txt), VARSIZE_ANY_EXHDR(txt), DEFAULT_COLLATION_OID);
151 : 10 : result = hash_any((unsigned char *) str, strlen(str));
152 : 10 : pfree(str);
153 : :
154 : : /* Avoid leaking memory for toasted inputs */
155 [ - + ]: 10 : PG_FREE_IF_COPY(txt, 0);
156 : :
157 : 10 : PG_RETURN_DATUM(result);
158 : : }
159 : :
160 : 3 : PG_FUNCTION_INFO_V1(citext_hash_extended);
161 : :
162 : : Datum
163 : 10 : citext_hash_extended(PG_FUNCTION_ARGS)
164 : : {
165 : 10 : text *txt = PG_GETARG_TEXT_PP(0);
166 : 10 : uint64 seed = PG_GETARG_INT64(1);
167 : : char *str;
168 : : Datum result;
169 : :
170 : 10 : str = str_tolower(VARDATA_ANY(txt), VARSIZE_ANY_EXHDR(txt), DEFAULT_COLLATION_OID);
171 : 10 : result = hash_any_extended((unsigned char *) str, strlen(str), seed);
172 : 10 : pfree(str);
173 : :
174 : : /* Avoid leaking memory for toasted inputs */
175 [ - + ]: 10 : PG_FREE_IF_COPY(txt, 0);
176 : :
177 : 10 : PG_RETURN_DATUM(result);
178 : : }
179 : :
180 : : /*
181 : : * ==================
182 : : * OPERATOR FUNCTIONS
183 : : * ==================
184 : : */
185 : :
186 : 5 : PG_FUNCTION_INFO_V1(citext_eq);
187 : :
188 : : Datum
189 : 85 : citext_eq(PG_FUNCTION_ARGS)
190 : : {
191 : 85 : text *left = PG_GETARG_TEXT_PP(0);
192 : 85 : text *right = PG_GETARG_TEXT_PP(1);
193 : : char *lcstr,
194 : : *rcstr;
195 : : bool result;
196 : :
197 : : /* We can't compare lengths in advance of downcasing ... */
198 : :
199 : 85 : lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left), DEFAULT_COLLATION_OID);
200 : 85 : rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right), DEFAULT_COLLATION_OID);
201 : :
202 : : /*
203 : : * Since we only care about equality or not-equality, we can avoid all the
204 : : * expense of strcoll() here, and just do bitwise comparison.
205 : : */
206 : 85 : result = (strcmp(lcstr, rcstr) == 0);
207 : :
208 : 85 : pfree(lcstr);
209 : 85 : pfree(rcstr);
210 [ - + ]: 85 : PG_FREE_IF_COPY(left, 0);
211 [ - + ]: 85 : PG_FREE_IF_COPY(right, 1);
212 : :
213 : 85 : PG_RETURN_BOOL(result);
214 : : }
215 : :
216 : 4 : PG_FUNCTION_INFO_V1(citext_ne);
217 : :
218 : : Datum
219 : 22 : citext_ne(PG_FUNCTION_ARGS)
220 : : {
221 : 22 : text *left = PG_GETARG_TEXT_PP(0);
222 : 22 : text *right = PG_GETARG_TEXT_PP(1);
223 : : char *lcstr,
224 : : *rcstr;
225 : : bool result;
226 : :
227 : : /* We can't compare lengths in advance of downcasing ... */
228 : :
229 : 22 : lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left), DEFAULT_COLLATION_OID);
230 : 22 : rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right), DEFAULT_COLLATION_OID);
231 : :
232 : : /*
233 : : * Since we only care about equality or not-equality, we can avoid all the
234 : : * expense of strcoll() here, and just do bitwise comparison.
235 : : */
236 : 22 : result = (strcmp(lcstr, rcstr) != 0);
237 : :
238 : 22 : pfree(lcstr);
239 : 22 : pfree(rcstr);
240 [ - + ]: 22 : PG_FREE_IF_COPY(left, 0);
241 [ - + ]: 22 : PG_FREE_IF_COPY(right, 1);
242 : :
243 : 22 : PG_RETURN_BOOL(result);
244 : : }
245 : :
246 : 3 : PG_FUNCTION_INFO_V1(citext_lt);
247 : :
248 : : Datum
249 : 1 : citext_lt(PG_FUNCTION_ARGS)
250 : : {
251 : 1 : text *left = PG_GETARG_TEXT_PP(0);
252 : 1 : text *right = PG_GETARG_TEXT_PP(1);
253 : : bool result;
254 : :
255 : 1 : result = citextcmp(left, right, PG_GET_COLLATION()) < 0;
256 : :
257 [ - + ]: 1 : PG_FREE_IF_COPY(left, 0);
258 [ - + ]: 1 : PG_FREE_IF_COPY(right, 1);
259 : :
260 : 1 : PG_RETURN_BOOL(result);
261 : : }
262 : :
263 : 3 : PG_FUNCTION_INFO_V1(citext_le);
264 : :
265 : : Datum
266 : 1 : citext_le(PG_FUNCTION_ARGS)
267 : : {
268 : 1 : text *left = PG_GETARG_TEXT_PP(0);
269 : 1 : text *right = PG_GETARG_TEXT_PP(1);
270 : : bool result;
271 : :
272 : 1 : result = citextcmp(left, right, PG_GET_COLLATION()) <= 0;
273 : :
274 [ - + ]: 1 : PG_FREE_IF_COPY(left, 0);
275 [ - + ]: 1 : PG_FREE_IF_COPY(right, 1);
276 : :
277 : 1 : PG_RETURN_BOOL(result);
278 : : }
279 : :
280 : 3 : PG_FUNCTION_INFO_V1(citext_gt);
281 : :
282 : : Datum
283 : 3 : citext_gt(PG_FUNCTION_ARGS)
284 : : {
285 : 3 : text *left = PG_GETARG_TEXT_PP(0);
286 : 3 : text *right = PG_GETARG_TEXT_PP(1);
287 : : bool result;
288 : :
289 : 3 : result = citextcmp(left, right, PG_GET_COLLATION()) > 0;
290 : :
291 [ - + ]: 3 : PG_FREE_IF_COPY(left, 0);
292 [ - + ]: 3 : PG_FREE_IF_COPY(right, 1);
293 : :
294 : 3 : PG_RETURN_BOOL(result);
295 : : }
296 : :
297 : 3 : PG_FUNCTION_INFO_V1(citext_ge);
298 : :
299 : : Datum
300 : 1 : citext_ge(PG_FUNCTION_ARGS)
301 : : {
302 : 1 : text *left = PG_GETARG_TEXT_PP(0);
303 : 1 : text *right = PG_GETARG_TEXT_PP(1);
304 : : bool result;
305 : :
306 : 1 : result = citextcmp(left, right, PG_GET_COLLATION()) >= 0;
307 : :
308 [ - + ]: 1 : PG_FREE_IF_COPY(left, 0);
309 [ - + ]: 1 : PG_FREE_IF_COPY(right, 1);
310 : :
311 : 1 : PG_RETURN_BOOL(result);
312 : : }
313 : :
314 : 4 : PG_FUNCTION_INFO_V1(citext_pattern_lt);
315 : :
316 : : Datum
317 : 9 : citext_pattern_lt(PG_FUNCTION_ARGS)
318 : : {
319 : 9 : text *left = PG_GETARG_TEXT_PP(0);
320 : 9 : text *right = PG_GETARG_TEXT_PP(1);
321 : : bool result;
322 : :
323 : 9 : result = internal_citext_pattern_cmp(left, right, PG_GET_COLLATION()) < 0;
324 : :
325 [ - + ]: 9 : PG_FREE_IF_COPY(left, 0);
326 [ - + ]: 9 : PG_FREE_IF_COPY(right, 1);
327 : :
328 : 9 : PG_RETURN_BOOL(result);
329 : : }
330 : :
331 : 4 : PG_FUNCTION_INFO_V1(citext_pattern_le);
332 : :
333 : : Datum
334 : 13 : citext_pattern_le(PG_FUNCTION_ARGS)
335 : : {
336 : 13 : text *left = PG_GETARG_TEXT_PP(0);
337 : 13 : text *right = PG_GETARG_TEXT_PP(1);
338 : : bool result;
339 : :
340 : 13 : result = internal_citext_pattern_cmp(left, right, PG_GET_COLLATION()) <= 0;
341 : :
342 [ - + ]: 13 : PG_FREE_IF_COPY(left, 0);
343 [ - + ]: 13 : PG_FREE_IF_COPY(right, 1);
344 : :
345 : 13 : PG_RETURN_BOOL(result);
346 : : }
347 : :
348 : 4 : PG_FUNCTION_INFO_V1(citext_pattern_gt);
349 : :
350 : : Datum
351 : 10 : citext_pattern_gt(PG_FUNCTION_ARGS)
352 : : {
353 : 10 : text *left = PG_GETARG_TEXT_PP(0);
354 : 10 : text *right = PG_GETARG_TEXT_PP(1);
355 : : bool result;
356 : :
357 : 10 : result = internal_citext_pattern_cmp(left, right, PG_GET_COLLATION()) > 0;
358 : :
359 [ - + ]: 10 : PG_FREE_IF_COPY(left, 0);
360 [ - + ]: 10 : PG_FREE_IF_COPY(right, 1);
361 : :
362 : 10 : PG_RETURN_BOOL(result);
363 : : }
364 : :
365 : 4 : PG_FUNCTION_INFO_V1(citext_pattern_ge);
366 : :
367 : : Datum
368 : 12 : citext_pattern_ge(PG_FUNCTION_ARGS)
369 : : {
370 : 12 : text *left = PG_GETARG_TEXT_PP(0);
371 : 12 : text *right = PG_GETARG_TEXT_PP(1);
372 : : bool result;
373 : :
374 : 12 : result = internal_citext_pattern_cmp(left, right, PG_GET_COLLATION()) >= 0;
375 : :
376 [ - + ]: 12 : PG_FREE_IF_COPY(left, 0);
377 [ - + ]: 12 : PG_FREE_IF_COPY(right, 1);
378 : :
379 : 12 : PG_RETURN_BOOL(result);
380 : : }
381 : :
382 : : /*
383 : : * ===================
384 : : * AGGREGATE FUNCTIONS
385 : : * ===================
386 : : */
387 : :
388 : 3 : PG_FUNCTION_INFO_V1(citext_smaller);
389 : :
390 : : Datum
391 : 7 : citext_smaller(PG_FUNCTION_ARGS)
392 : : {
393 : 7 : text *left = PG_GETARG_TEXT_PP(0);
394 : 7 : text *right = PG_GETARG_TEXT_PP(1);
395 : : text *result;
396 : :
397 [ + + ]: 7 : result = citextcmp(left, right, PG_GET_COLLATION()) < 0 ? left : right;
398 : 7 : PG_RETURN_TEXT_P(result);
399 : : }
400 : :
401 : 3 : PG_FUNCTION_INFO_V1(citext_larger);
402 : :
403 : : Datum
404 : 6 : citext_larger(PG_FUNCTION_ARGS)
405 : : {
406 : 6 : text *left = PG_GETARG_TEXT_PP(0);
407 : 6 : text *right = PG_GETARG_TEXT_PP(1);
408 : : text *result;
409 : :
410 [ + + ]: 6 : result = citextcmp(left, right, PG_GET_COLLATION()) > 0 ? left : right;
411 : 6 : PG_RETURN_TEXT_P(result);
412 : : }
|
