Branch data Line data Source code
1 : : /*-----------------------------------------------------------------------
2 : : *
3 : : * PostgreSQL locale utilities for ICU
4 : : *
5 : : * Portions Copyright (c) 2002-2026, PostgreSQL Global Development Group
6 : : *
7 : : * src/backend/utils/adt/pg_locale_icu.c
8 : : *
9 : : *-----------------------------------------------------------------------
10 : : */
11 : :
12 : : #include "postgres.h"
13 : :
14 : : #ifdef USE_ICU
15 : : #include <unicode/ucasemap.h>
16 : : #include <unicode/ucnv.h>
17 : : #include <unicode/ucol.h>
18 : : #include <unicode/ustring.h>
19 : :
20 : : /*
21 : : * ucol_strcollUTF8() was introduced in ICU 50, but it is buggy before ICU 53.
22 : : * (see
23 : : * <https://www.postgresql.org/message-id/flat/f1438ec6-22aa-4029-9a3b-26f79d330e72%40manitou-mail.org>)
24 : : */
25 : : #if U_ICU_VERSION_MAJOR_NUM >= 53
26 : : #define HAVE_UCOL_STRCOLLUTF8 1
27 : : #else
28 : : #undef HAVE_UCOL_STRCOLLUTF8
29 : : #endif
30 : :
31 : : #endif
32 : :
33 : : #include "access/htup_details.h"
34 : : #include "catalog/pg_database.h"
35 : : #include "catalog/pg_collation.h"
36 : : #include "mb/pg_wchar.h"
37 : : #include "miscadmin.h"
38 : : #include "utils/builtins.h"
39 : : #include "utils/formatting.h"
40 : : #include "utils/memutils.h"
41 : : #include "utils/pg_locale.h"
42 : : #include "utils/syscache.h"
43 : :
44 : : /*
45 : : * Size of stack buffer to use for string transformations, used to avoid heap
46 : : * allocations in typical cases. This should be large enough that most strings
47 : : * will fit, but small enough that we feel comfortable putting it on the
48 : : * stack.
49 : : */
50 : : #define TEXTBUFLEN 1024
51 : :
52 : : extern pg_locale_t create_pg_locale_icu(Oid collid, MemoryContext context);
53 : :
54 : : #ifdef USE_ICU
55 : :
56 : : extern UCollator *pg_ucol_open(const char *loc_str);
57 : : static UCaseMap *pg_ucasemap_open(const char *loc_str);
58 : :
59 : : static size_t strlower_icu(char *dest, size_t destsize, const char *src,
60 : : size_t srclen, pg_locale_t locale);
61 : : static size_t strtitle_icu(char *dest, size_t destsize, const char *src,
62 : : size_t srclen, pg_locale_t locale);
63 : : static size_t strupper_icu(char *dest, size_t destsize, const char *src,
64 : : size_t srclen, pg_locale_t locale);
65 : : static size_t strfold_icu(char *dest, size_t destsize, const char *src,
66 : : size_t srclen, pg_locale_t locale);
67 : : static size_t strlower_icu_utf8(char *dest, size_t destsize, const char *src,
68 : : size_t srclen, pg_locale_t locale);
69 : : static size_t strtitle_icu_utf8(char *dest, size_t destsize, const char *src,
70 : : size_t srclen, pg_locale_t locale);
71 : : static size_t strupper_icu_utf8(char *dest, size_t destsize, const char *src,
72 : : size_t srclen, pg_locale_t locale);
73 : : static size_t strfold_icu_utf8(char *dest, size_t destsize, const char *src,
74 : : size_t srclen, pg_locale_t locale);
75 : : static size_t downcase_ident_icu(char *dst, size_t dstsize, const char *src,
76 : : size_t srclen, pg_locale_t locale);
77 : : static int strncoll_icu(const char *arg1, size_t len1,
78 : : const char *arg2, size_t len2,
79 : : pg_locale_t locale);
80 : : static int strcoll_icu(const char *arg1, const char *arg2,
81 : : pg_locale_t locale);
82 : : static size_t strnxfrm_icu(char *dest, size_t destsize,
83 : : const char *src, size_t srclen,
84 : : pg_locale_t locale);
85 : : static size_t strxfrm_icu(char *dest, size_t destsize, const char *src,
86 : : pg_locale_t locale);
87 : : extern char *get_collation_actual_version_icu(const char *collcollate);
88 : :
89 : : typedef int32_t (*ICU_Convert_Func) (UChar *dest, int32_t destCapacity,
90 : : const UChar *src, int32_t srcLength,
91 : : const char *locale,
92 : : UErrorCode *pErrorCode);
93 : :
94 : : /*
95 : : * Converter object for converting between ICU's UChar strings and C strings
96 : : * in database encoding. Since the database encoding doesn't change, we only
97 : : * need one of these per session.
98 : : */
99 : : static UConverter *icu_converter = NULL;
100 : :
101 : : static UCollator *make_icu_collator(const char *iculocstr,
102 : : const char *icurules);
103 : : static size_t strnxfrm_prefix_icu(char *dest, size_t destsize,
104 : : const char *src, size_t srclen,
105 : : pg_locale_t locale);
106 : : static size_t strxfrm_prefix_icu(char *dest, size_t destsize, const char *src,
107 : : pg_locale_t locale);
108 : : #ifdef HAVE_UCOL_STRCOLLUTF8
109 : : static int strncoll_icu_utf8(const char *arg1, size_t len1,
110 : : const char *arg2, size_t len2,
111 : : pg_locale_t locale);
112 : : static int strcoll_icu_utf8(const char *arg1,
113 : : const char *arg2,
114 : : pg_locale_t locale);
115 : : #endif
116 : : static size_t strnxfrm_prefix_icu_utf8(char *dest, size_t destsize,
117 : : const char *src, size_t srclen,
118 : : pg_locale_t locale);
119 : : static size_t strxfrm_prefix_icu_utf8(char *dest, size_t destsize, const char *src,
120 : : pg_locale_t locale);
121 : : static void init_icu_converter(void);
122 : : static int32_t uchar_length(UConverter *converter,
123 : : const char *str, int32_t len);
124 : : static int32_t uchar_convert(UConverter *converter,
125 : : UChar *dest, int32_t destlen,
126 : : const char *src, int32_t srclen);
127 : : static int32_t icu_to_uchar(UChar **buff_uchar, const char *buff,
128 : : size_t nbytes);
129 : : static size_t icu_from_uchar(char *dest, size_t destsize,
130 : : const UChar *buff_uchar, int32_t len_uchar);
131 : : static void icu_set_collation_attributes(UCollator *collator, const char *loc,
132 : : UErrorCode *status);
133 : : static int32_t icu_convert_case(ICU_Convert_Func func, char *dest,
134 : : size_t destsize, const char *src,
135 : : size_t srclen, pg_locale_t locale);
136 : : static int32_t u_strToTitle_default_BI(UChar *dest, int32_t destCapacity,
137 : : const UChar *src, int32_t srcLength,
138 : : const char *locale,
139 : : UErrorCode *pErrorCode);
140 : : static int32_t u_strFoldCase_default(UChar *dest, int32_t destCapacity,
141 : : const UChar *src, int32_t srcLength,
142 : : const char *locale,
143 : : UErrorCode *pErrorCode);
144 : : static int32_t foldcase_options(const char *locale);
145 : :
146 : : /*
147 : : * XXX: many of the functions below rely on casts directly from pg_wchar to
148 : : * UChar32, which is correct for UTF-8 and LATIN1, but not in general.
149 : : */
150 : :
151 : : static pg_wchar
152 : 72 : toupper_icu(pg_wchar wc, pg_locale_t locale)
153 : : {
154 : 72 : return u_toupper(wc);
155 : : }
156 : :
157 : : static pg_wchar
158 : 72 : tolower_icu(pg_wchar wc, pg_locale_t locale)
159 : : {
160 : 72 : return u_tolower(wc);
161 : : }
162 : :
163 : : static const struct collate_methods collate_methods_icu = {
164 : : .strncoll = strncoll_icu,
165 : : .strcoll = strcoll_icu,
166 : : .strnxfrm = strnxfrm_icu,
167 : : .strxfrm = strxfrm_icu,
168 : : .strnxfrm_prefix = strnxfrm_prefix_icu,
169 : : .strxfrm_prefix = strxfrm_prefix_icu,
170 : : .strxfrm_is_safe = true,
171 : : };
172 : :
173 : : static const struct collate_methods collate_methods_icu_utf8 = {
174 : : #ifdef HAVE_UCOL_STRCOLLUTF8
175 : : .strncoll = strncoll_icu_utf8,
176 : : .strcoll = strcoll_icu_utf8,
177 : : #else
178 : : .strncoll = strncoll_icu,
179 : : .strcoll = strcoll_icu,
180 : : #endif
181 : : .strnxfrm = strnxfrm_icu,
182 : : .strxfrm = strxfrm_icu,
183 : : .strnxfrm_prefix = strnxfrm_prefix_icu_utf8,
184 : : .strxfrm_prefix = strxfrm_prefix_icu_utf8,
185 : : .strxfrm_is_safe = true,
186 : : };
187 : :
188 : : static bool
189 : 8192 : wc_isdigit_icu(pg_wchar wc, pg_locale_t locale)
190 : : {
191 : 8192 : return u_isdigit(wc);
192 : : }
193 : :
194 : : static bool
195 : 8192 : wc_isalpha_icu(pg_wchar wc, pg_locale_t locale)
196 : : {
197 : 8192 : return u_isalpha(wc);
198 : : }
199 : :
200 : : static bool
201 : 8192 : wc_isalnum_icu(pg_wchar wc, pg_locale_t locale)
202 : : {
203 : 8192 : return u_isalnum(wc);
204 : : }
205 : :
206 : : static bool
207 : 8192 : wc_isupper_icu(pg_wchar wc, pg_locale_t locale)
208 : : {
209 : 8192 : return u_isupper(wc);
210 : : }
211 : :
212 : : static bool
213 : 8192 : wc_islower_icu(pg_wchar wc, pg_locale_t locale)
214 : : {
215 : 8192 : return u_islower(wc);
216 : : }
217 : :
218 : : static bool
219 : 8192 : wc_isgraph_icu(pg_wchar wc, pg_locale_t locale)
220 : : {
221 : 8192 : return u_isgraph(wc);
222 : : }
223 : :
224 : : static bool
225 : 8192 : wc_isprint_icu(pg_wchar wc, pg_locale_t locale)
226 : : {
227 : 8192 : return u_isprint(wc);
228 : : }
229 : :
230 : : static bool
231 : 8192 : wc_ispunct_icu(pg_wchar wc, pg_locale_t locale)
232 : : {
233 : 8192 : return u_ispunct(wc);
234 : : }
235 : :
236 : : static bool
237 : 8192 : wc_isspace_icu(pg_wchar wc, pg_locale_t locale)
238 : : {
239 : 8192 : return u_isspace(wc);
240 : : }
241 : :
242 : : static bool
243 : 0 : wc_isxdigit_icu(pg_wchar wc, pg_locale_t locale)
244 : : {
245 : 0 : return u_isxdigit(wc);
246 : : }
247 : :
248 : : static bool
249 : 105 : wc_iscased_icu(pg_wchar wc, pg_locale_t locale)
250 : : {
251 : 105 : return u_hasBinaryProperty(wc, UCHAR_CASED);
252 : : }
253 : :
254 : : static const struct ctype_methods ctype_methods_icu = {
255 : : .strlower = strlower_icu,
256 : : .strtitle = strtitle_icu,
257 : : .strupper = strupper_icu,
258 : : .strfold = strfold_icu,
259 : : .downcase_ident = downcase_ident_icu,
260 : : .wc_isdigit = wc_isdigit_icu,
261 : : .wc_isalpha = wc_isalpha_icu,
262 : : .wc_isalnum = wc_isalnum_icu,
263 : : .wc_isupper = wc_isupper_icu,
264 : : .wc_islower = wc_islower_icu,
265 : : .wc_isgraph = wc_isgraph_icu,
266 : : .wc_isprint = wc_isprint_icu,
267 : : .wc_ispunct = wc_ispunct_icu,
268 : : .wc_isspace = wc_isspace_icu,
269 : : .wc_isxdigit = wc_isxdigit_icu,
270 : : .wc_iscased = wc_iscased_icu,
271 : : .wc_toupper = toupper_icu,
272 : : .wc_tolower = tolower_icu,
273 : : };
274 : :
275 : : static const struct ctype_methods ctype_methods_icu_utf8 = {
276 : : .strlower = strlower_icu_utf8,
277 : : .strtitle = strtitle_icu_utf8,
278 : : .strupper = strupper_icu_utf8,
279 : : .strfold = strfold_icu_utf8,
280 : : /* uses plain ASCII semantics for historical reasons */
281 : : .downcase_ident = NULL,
282 : : .wc_isdigit = wc_isdigit_icu,
283 : : .wc_isalpha = wc_isalpha_icu,
284 : : .wc_isalnum = wc_isalnum_icu,
285 : : .wc_isupper = wc_isupper_icu,
286 : : .wc_islower = wc_islower_icu,
287 : : .wc_isgraph = wc_isgraph_icu,
288 : : .wc_isprint = wc_isprint_icu,
289 : : .wc_ispunct = wc_ispunct_icu,
290 : : .wc_isspace = wc_isspace_icu,
291 : : .wc_isxdigit = wc_isxdigit_icu,
292 : : .wc_iscased = wc_iscased_icu,
293 : : .wc_toupper = toupper_icu,
294 : : .wc_tolower = tolower_icu,
295 : : };
296 : :
297 : : /*
298 : : * ICU still depends on libc for compatibility with certain historical
299 : : * behavior for single-byte encodings. See downcase_ident_icu().
300 : : *
301 : : * XXX: consider fixing by decoding the single byte into a code point, and
302 : : * using u_tolower().
303 : : */
304 : : static locale_t
305 : 0 : make_libc_ctype_locale(const char *ctype)
306 : : {
307 : : locale_t loc;
308 : :
309 : : #ifndef WIN32
310 : 0 : loc = newlocale(LC_CTYPE_MASK, ctype, NULL);
311 : : #else
312 : : loc = _create_locale(LC_ALL, ctype);
313 : : #endif
314 [ # # ]: 0 : if (!loc)
315 : 0 : report_newlocale_failure(ctype);
316 : :
317 : 0 : return loc;
318 : : }
319 : : #endif
320 : :
321 : : pg_locale_t
322 : 137 : create_pg_locale_icu(Oid collid, MemoryContext context)
323 : : {
324 : : #ifdef USE_ICU
325 : : bool deterministic;
326 : : const char *iculocstr;
327 : 137 : const char *icurules = NULL;
328 : : UCollator *collator;
329 : 137 : locale_t loc = (locale_t) 0;
330 : : pg_locale_t result;
331 : :
332 [ + + ]: 137 : if (collid == DEFAULT_COLLATION_OID)
333 : : {
334 : : HeapTuple tp;
335 : : Datum datum;
336 : : bool isnull;
337 : :
338 : 13 : tp = SearchSysCache1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));
339 [ - + ]: 13 : if (!HeapTupleIsValid(tp))
340 [ # # ]: 0 : elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);
341 : :
342 : : /* default database collation is always deterministic */
343 : 13 : deterministic = true;
344 : 13 : datum = SysCacheGetAttrNotNull(DATABASEOID, tp,
345 : : Anum_pg_database_datlocale);
346 : 13 : iculocstr = TextDatumGetCString(datum);
347 : 13 : datum = SysCacheGetAttr(DATABASEOID, tp,
348 : : Anum_pg_database_daticurules, &isnull);
349 [ - + ]: 13 : if (!isnull)
350 : 0 : icurules = TextDatumGetCString(datum);
351 : :
352 : : /* libc only needed for default locale and single-byte encoding */
353 [ - + ]: 13 : if (pg_database_encoding_max_length() == 1)
354 : : {
355 : : const char *ctype;
356 : :
357 : 0 : datum = SysCacheGetAttrNotNull(DATABASEOID, tp,
358 : : Anum_pg_database_datctype);
359 : 0 : ctype = TextDatumGetCString(datum);
360 : :
361 : 0 : loc = make_libc_ctype_locale(ctype);
362 : : }
363 : :
364 : 13 : ReleaseSysCache(tp);
365 : : }
366 : : else
367 : : {
368 : : Form_pg_collation collform;
369 : : HeapTuple tp;
370 : : Datum datum;
371 : : bool isnull;
372 : :
373 : 124 : tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
374 [ - + ]: 124 : if (!HeapTupleIsValid(tp))
375 [ # # ]: 0 : elog(ERROR, "cache lookup failed for collation %u", collid);
376 : 124 : collform = (Form_pg_collation) GETSTRUCT(tp);
377 : 124 : deterministic = collform->collisdeterministic;
378 : 124 : datum = SysCacheGetAttrNotNull(COLLOID, tp,
379 : : Anum_pg_collation_colllocale);
380 : 124 : iculocstr = TextDatumGetCString(datum);
381 : 124 : datum = SysCacheGetAttr(COLLOID, tp,
382 : : Anum_pg_collation_collicurules, &isnull);
383 [ + + ]: 124 : if (!isnull)
384 : 12 : icurules = TextDatumGetCString(datum);
385 : :
386 : 124 : ReleaseSysCache(tp);
387 : : }
388 : :
389 : 137 : collator = make_icu_collator(iculocstr, icurules);
390 : :
391 : 131 : result = MemoryContextAllocZero(context, sizeof(struct pg_locale_struct));
392 : 131 : result->icu.locale = MemoryContextStrdup(context, iculocstr);
393 : 131 : result->icu.ucol = collator;
394 : 131 : result->icu.lt = loc;
395 : 131 : result->deterministic = deterministic;
396 : 131 : result->collate_is_c = false;
397 : 131 : result->ctype_is_c = false;
398 [ + - ]: 131 : if (GetDatabaseEncoding() == PG_UTF8)
399 : : {
400 : 131 : result->icu.ucasemap = pg_ucasemap_open(iculocstr);
401 : 131 : result->collate = &collate_methods_icu_utf8;
402 : 131 : result->ctype = &ctype_methods_icu_utf8;
403 : : }
404 : : else
405 : : {
406 : 0 : result->collate = &collate_methods_icu;
407 : 0 : result->ctype = &ctype_methods_icu;
408 : : }
409 : :
410 : 131 : return result;
411 : : #else
412 : : /* could get here if a collation was created by a build with ICU */
413 : : ereport(ERROR,
414 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
415 : : errmsg("ICU is not supported in this build")));
416 : :
417 : : return NULL;
418 : : #endif
419 : : }
420 : :
421 : : #ifdef USE_ICU
422 : :
423 : : /*
424 : : * Check locale string and fix it if necessary. Returns a new palloc'd string.
425 : : *
426 : : * In ICU versions 54 and earlier, "und" is not a recognized spelling of the
427 : : * root locale. If the first component of the locale is "und", replace with
428 : : * "root" before opening.
429 : : */
430 : : static char *
431 : 48512 : fix_icu_locale_str(const char *loc_str)
432 : : {
433 : : /*
434 : : * Must never open default collator, because it depends on the environment
435 : : * and may change at any time. Should not happen, but check here to catch
436 : : * bugs that might be hard to catch otherwise.
437 : : *
438 : : * NB: the default collator is not the same as the collator for the root
439 : : * locale. The root locale may be specified as the empty string, "und", or
440 : : * "root". The default collator is opened by passing NULL to ucol_open().
441 : : */
442 [ - + ]: 48512 : if (loc_str == NULL)
443 [ # # ]: 0 : elog(ERROR, "opening default collator is not supported");
444 : :
445 : : if (U_ICU_VERSION_MAJOR_NUM < 55)
446 : : {
447 : : char lang[ULOC_LANG_CAPACITY];
448 : : UErrorCode status = U_ZERO_ERROR;
449 : :
450 : : uloc_getLanguage(loc_str, lang, ULOC_LANG_CAPACITY, &status);
451 : : if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
452 : : {
453 : : ereport(ERROR,
454 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
455 : : errmsg("could not get language from locale \"%s\": %s",
456 : : loc_str, u_errorName(status))));
457 : : }
458 : :
459 : : if (strcmp(lang, "und") == 0)
460 : : {
461 : : const char *remainder = loc_str + strlen("und");
462 : : char *fixed_str;
463 : :
464 : : fixed_str = palloc(strlen("root") + strlen(remainder) + 1);
465 : : strcpy(fixed_str, "root");
466 : : strcat(fixed_str, remainder);
467 : :
468 : : return fixed_str;
469 : : }
470 : : }
471 : :
472 : 48512 : return pstrdup(loc_str);
473 : : }
474 : :
475 : : /*
476 : : * Wrapper around ucol_open() to handle API differences for older ICU
477 : : * versions.
478 : : *
479 : : * Ensure that no path leaks a UCollator.
480 : : */
481 : : UCollator *
482 : 48381 : pg_ucol_open(const char *loc_str)
483 : : {
484 : : UCollator *collator;
485 : : UErrorCode status;
486 : : char *fixed_str;
487 : :
488 : 48381 : fixed_str = fix_icu_locale_str(loc_str);
489 : :
490 : 48381 : status = U_ZERO_ERROR;
491 : 48381 : collator = ucol_open(fixed_str, &status);
492 [ + + ]: 48381 : if (U_FAILURE(status))
493 [ + - ]: 7 : ereport(ERROR,
494 : : /* use original string for error report */
495 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
496 : : errmsg("could not open collator for locale \"%s\": %s",
497 : : loc_str, u_errorName(status))));
498 : :
499 : : if (U_ICU_VERSION_MAJOR_NUM < 54)
500 : : {
501 : : status = U_ZERO_ERROR;
502 : : icu_set_collation_attributes(collator, fixed_str, &status);
503 : :
504 : : /*
505 : : * Pretend the error came from ucol_open(), for consistent error
506 : : * message across ICU versions.
507 : : */
508 : : if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
509 : : {
510 : : ucol_close(collator);
511 : : ereport(ERROR,
512 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
513 : : errmsg("could not open collator for locale \"%s\": %s",
514 : : loc_str, u_errorName(status))));
515 : : }
516 : : }
517 : :
518 : 48374 : pfree(fixed_str);
519 : :
520 : 48374 : return collator;
521 : : }
522 : :
523 : : /*
524 : : * Wrapper around ucasemap_open() to handle API differences for older ICU
525 : : * versions.
526 : : *
527 : : * Additionally makes sure we get the right options for case folding.
528 : : */
529 : : static UCaseMap *
530 : 131 : pg_ucasemap_open(const char *loc_str)
531 : : {
532 : 131 : UErrorCode status = U_ZERO_ERROR;
533 : : UCaseMap *casemap;
534 : : char *fixed_str;
535 : :
536 : 131 : fixed_str = fix_icu_locale_str(loc_str);
537 : :
538 : 131 : casemap = ucasemap_open(fixed_str, foldcase_options(fixed_str), &status);
539 [ - + ]: 131 : if (U_FAILURE(status))
540 : : /* use original string for error report */
541 [ # # ]: 0 : ereport(ERROR,
542 : : errcode(ERRCODE_INVALID_PARAMETER_VALUE),
543 : : errmsg("could not open casemap for locale \"%s\": %s",
544 : : loc_str, u_errorName(status)));
545 : :
546 : 131 : pfree(fixed_str);
547 : :
548 : 131 : return casemap;
549 : : }
550 : :
551 : : /*
552 : : * Create a UCollator with the given locale string and rules.
553 : : *
554 : : * Ensure that no path leaks a UCollator.
555 : : */
556 : : static UCollator *
557 : 137 : make_icu_collator(const char *iculocstr, const char *icurules)
558 : : {
559 [ + + ]: 137 : if (!icurules)
560 : : {
561 : : /* simple case without rules */
562 : 125 : return pg_ucol_open(iculocstr);
563 : : }
564 : : else
565 : : {
566 : : UCollator *collator_std_rules;
567 : : UCollator *collator_all_rules;
568 : : const UChar *std_rules;
569 : : UChar *my_rules;
570 : : UChar *all_rules;
571 : : int32_t length;
572 : : int32_t total;
573 : : UErrorCode status;
574 : :
575 : : /*
576 : : * If rules are specified, we extract the rules of the standard
577 : : * collation, add our own rules, and make a new collator with the
578 : : * combined rules.
579 : : */
580 : 12 : icu_to_uchar(&my_rules, icurules, strlen(icurules));
581 : :
582 : 12 : collator_std_rules = pg_ucol_open(iculocstr);
583 : :
584 : 12 : std_rules = ucol_getRules(collator_std_rules, &length);
585 : :
586 : 12 : total = u_strlen(std_rules) + u_strlen(my_rules) + 1;
587 : :
588 : : /* avoid leaking collator on OOM */
589 : 12 : all_rules = palloc_array_extended(UChar, total, MCXT_ALLOC_NO_OOM);
590 [ - + ]: 12 : if (!all_rules)
591 : : {
592 : 0 : ucol_close(collator_std_rules);
593 [ # # ]: 0 : ereport(ERROR,
594 : : (errcode(ERRCODE_OUT_OF_MEMORY),
595 : : errmsg("out of memory")));
596 : : }
597 : :
598 : 12 : u_strcpy(all_rules, std_rules);
599 : 12 : u_strcat(all_rules, my_rules);
600 : :
601 : 12 : ucol_close(collator_std_rules);
602 : :
603 : 12 : status = U_ZERO_ERROR;
604 : 12 : collator_all_rules = ucol_openRules(all_rules, u_strlen(all_rules),
605 : : UCOL_DEFAULT, UCOL_DEFAULT,
606 : : NULL, &status);
607 [ + + ]: 12 : if (U_FAILURE(status))
608 : : {
609 [ + - ]: 4 : ereport(ERROR,
610 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
611 : : errmsg("could not open collator for locale \"%s\" with rules \"%s\": %s",
612 : : iculocstr, icurules, u_errorName(status))));
613 : : }
614 : :
615 : 8 : pfree(my_rules);
616 : 8 : pfree(all_rules);
617 : 8 : return collator_all_rules;
618 : : }
619 : : }
620 : :
621 : : static size_t
622 : 0 : strlower_icu(char *dest, size_t destsize, const char *src, size_t srclen,
623 : : pg_locale_t locale)
624 : : {
625 : 0 : return icu_convert_case(u_strToLower, dest, destsize, src, srclen, locale);
626 : : }
627 : :
628 : : static size_t
629 : 0 : strtitle_icu(char *dest, size_t destsize, const char *src, size_t srclen,
630 : : pg_locale_t locale)
631 : : {
632 : 0 : return icu_convert_case(u_strToTitle_default_BI, dest, destsize, src, srclen, locale);
633 : : }
634 : :
635 : : static size_t
636 : 0 : strupper_icu(char *dest, size_t destsize, const char *src, size_t srclen,
637 : : pg_locale_t locale)
638 : : {
639 : 0 : return icu_convert_case(u_strToUpper, dest, destsize, src, srclen, locale);
640 : : }
641 : :
642 : : static size_t
643 : 0 : strfold_icu(char *dest, size_t destsize, const char *src, size_t srclen,
644 : : pg_locale_t locale)
645 : : {
646 : 0 : return icu_convert_case(u_strFoldCase_default, dest, destsize, src, srclen, locale);
647 : : }
648 : :
649 : : static size_t
650 : 364 : strlower_icu_utf8(char *dest, size_t destsize, const char *src, size_t srclen,
651 : : pg_locale_t locale)
652 : : {
653 : 364 : UErrorCode status = U_ZERO_ERROR;
654 : : int32_t needed;
655 : :
656 : 364 : needed = ucasemap_utf8ToLower(locale->icu.ucasemap, dest, destsize, src, srclen, &status);
657 [ - + - - ]: 364 : if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
658 [ # # ]: 0 : ereport(ERROR,
659 : : errmsg("case conversion failed: %s", u_errorName(status)));
660 : 364 : return needed;
661 : : }
662 : :
663 : : static size_t
664 : 20 : strtitle_icu_utf8(char *dest, size_t destsize, const char *src, size_t srclen,
665 : : pg_locale_t locale)
666 : : {
667 : 20 : UErrorCode status = U_ZERO_ERROR;
668 : : int32_t needed;
669 : :
670 : 20 : needed = ucasemap_utf8ToTitle(locale->icu.ucasemap, dest, destsize, src, srclen, &status);
671 [ - + - - ]: 20 : if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
672 [ # # ]: 0 : ereport(ERROR,
673 : : errmsg("case conversion failed: %s", u_errorName(status)));
674 : 20 : return needed;
675 : : }
676 : :
677 : : static size_t
678 : 72 : strupper_icu_utf8(char *dest, size_t destsize, const char *src, size_t srclen,
679 : : pg_locale_t locale)
680 : : {
681 : 72 : UErrorCode status = U_ZERO_ERROR;
682 : : int32_t needed;
683 : :
684 : 72 : needed = ucasemap_utf8ToUpper(locale->icu.ucasemap, dest, destsize, src, srclen, &status);
685 [ - + - - ]: 72 : if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
686 [ # # ]: 0 : ereport(ERROR,
687 : : errmsg("case conversion failed: %s", u_errorName(status)));
688 : 72 : return needed;
689 : : }
690 : :
691 : : static size_t
692 : 10 : strfold_icu_utf8(char *dest, size_t destsize, const char *src, size_t srclen,
693 : : pg_locale_t locale)
694 : : {
695 : 10 : UErrorCode status = U_ZERO_ERROR;
696 : : int32_t needed;
697 : :
698 : 10 : needed = ucasemap_utf8FoldCase(locale->icu.ucasemap, dest, destsize, src, srclen, &status);
699 [ - + - - ]: 10 : if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
700 [ # # ]: 0 : ereport(ERROR,
701 : : errmsg("case conversion failed: %s", u_errorName(status)));
702 : 10 : return needed;
703 : : }
704 : :
705 : : /*
706 : : * For historical compatibility, behavior is not multibyte-aware.
707 : : *
708 : : * NB: uses libc tolower() for single-byte encodings (also for historical
709 : : * compatibility), and therefore relies on the global LC_CTYPE setting.
710 : : */
711 : : static size_t
712 : 0 : downcase_ident_icu(char *dst, size_t dstsize, const char *src,
713 : : size_t srclen, pg_locale_t locale)
714 : : {
715 : : size_t i;
716 : : bool libc_lower;
717 : 0 : locale_t lt = locale->icu.lt;
718 : :
719 [ # # # # ]: 0 : libc_lower = lt && (pg_database_encoding_max_length() == 1);
720 : :
721 [ # # # # ]: 0 : for (i = 0; i < srclen && i < dstsize; i++)
722 : : {
723 : 0 : unsigned char ch = (unsigned char) src[i];
724 : :
725 [ # # # # ]: 0 : if (ch >= 'A' && ch <= 'Z')
726 : 0 : ch = pg_ascii_tolower(ch);
727 [ # # # # : 0 : else if (libc_lower && IS_HIGHBIT_SET(ch) && isupper_l(ch, lt))
# # ]
728 : 0 : ch = tolower_l(ch, lt);
729 : 0 : dst[i] = (char) ch;
730 : : }
731 : :
732 [ # # ]: 0 : if (i < dstsize)
733 : 0 : dst[i] = '\0';
734 : :
735 : 0 : return srclen;
736 : : }
737 : :
738 : : /*
739 : : * strncoll_icu_utf8
740 : : *
741 : : * Call ucol_strcollUTF8() or ucol_strcoll() as appropriate for the given
742 : : * database encoding.
743 : : */
744 : : #ifdef HAVE_UCOL_STRCOLLUTF8
745 : : int
746 : 17619 : strncoll_icu_utf8(const char *arg1, size_t len1, const char *arg2, size_t len2,
747 : : pg_locale_t locale)
748 : : {
749 : : int result;
750 : : UErrorCode status;
751 : :
752 : : Assert(GetDatabaseEncoding() == PG_UTF8);
753 : :
754 : 17619 : status = U_ZERO_ERROR;
755 : 17619 : result = ucol_strcollUTF8(locale->icu.ucol,
756 : : arg1, len1,
757 : : arg2, len2,
758 : : &status);
759 [ - + ]: 17619 : if (U_FAILURE(status))
760 [ # # ]: 0 : ereport(ERROR,
761 : : (errmsg("collation failed: %s", u_errorName(status))));
762 : :
763 : 17619 : return result;
764 : : }
765 : :
766 : : int
767 : 1140 : strcoll_icu_utf8(const char *arg1, const char *arg2, pg_locale_t locale)
768 : : {
769 : : int result;
770 : : UErrorCode status;
771 : :
772 : : Assert(GetDatabaseEncoding() == PG_UTF8);
773 : :
774 : 1140 : status = U_ZERO_ERROR;
775 : 1140 : result = ucol_strcollUTF8(locale->icu.ucol,
776 : : arg1, -1,
777 : : arg2, -1,
778 : : &status);
779 [ - + ]: 1140 : if (U_FAILURE(status))
780 [ # # ]: 0 : ereport(ERROR,
781 : : (errmsg("collation failed: %s", u_errorName(status))));
782 : :
783 : 1140 : return result;
784 : : }
785 : : #endif
786 : :
787 : : static size_t
788 : 8328 : strnxfrm_icu_internal(char *dest, size_t destsize, const char *src, ssize_t srclen,
789 : : pg_locale_t locale)
790 : : {
791 : : UChar sbuf[TEXTBUFLEN / sizeof(UChar)];
792 : 8328 : UChar *uchar = sbuf;
793 : : int32_t ulen;
794 : : Size result_bsize;
795 : :
796 : 8328 : init_icu_converter();
797 : :
798 : 8328 : ulen = uchar_length(icu_converter, src, srclen);
799 : :
800 [ - + ]: 8328 : if (ulen >= lengthof(sbuf))
801 : 0 : uchar = palloc_array(UChar, ulen + 1);
802 : :
803 : 8328 : ulen = uchar_convert(icu_converter, uchar, ulen + 1, src, srclen);
804 : :
805 : 8328 : result_bsize = ucol_getSortKey(locale->icu.ucol,
806 : : uchar, ulen,
807 : : (uint8_t *) dest, destsize);
808 : :
809 : : /*
810 : : * ucol_getSortKey() counts the nul-terminator in the result length, but
811 : : * this function should not.
812 : : */
813 : : Assert(result_bsize > 0);
814 : 8328 : result_bsize--;
815 : :
816 [ - + ]: 8328 : if (uchar != sbuf)
817 : 0 : pfree(uchar);
818 : :
819 : : /* if dest is defined, it should be nul-terminated */
820 : : Assert(result_bsize >= destsize || dest[result_bsize] == '\0');
821 : :
822 : 8328 : return result_bsize;
823 : : }
824 : :
825 : : static size_t
826 : 8328 : strnxfrm_icu(char *dest, size_t destsize, const char *src, size_t srclen,
827 : : pg_locale_t locale)
828 : : {
829 : 8328 : return strnxfrm_icu_internal(dest, destsize, src, srclen, locale);
830 : : }
831 : :
832 : : static size_t
833 : 0 : strxfrm_icu(char *dest, size_t destsize, const char *src,
834 : : pg_locale_t locale)
835 : : {
836 : 0 : return strnxfrm_icu_internal(dest, destsize, src, -1, locale);
837 : : }
838 : :
839 : : static size_t
840 : 1302 : strnxfrm_prefix_icu_utf8_internal(char *dest, size_t destsize,
841 : : const char *src, ssize_t srclen,
842 : : pg_locale_t locale)
843 : : {
844 : : size_t result;
845 : : UCharIterator iter;
846 : : uint32_t state[2];
847 : : UErrorCode status;
848 : :
849 : : Assert(GetDatabaseEncoding() == PG_UTF8);
850 : :
851 : 1302 : uiter_setUTF8(&iter, src, srclen);
852 : 1302 : state[0] = state[1] = 0; /* won't need that again */
853 : 1302 : status = U_ZERO_ERROR;
854 : 1302 : result = ucol_nextSortKeyPart(locale->icu.ucol,
855 : : &iter,
856 : : state,
857 : : (uint8_t *) dest,
858 : : destsize,
859 : : &status);
860 [ - + ]: 1302 : if (U_FAILURE(status))
861 [ # # ]: 0 : ereport(ERROR,
862 : : (errmsg("sort key generation failed: %s",
863 : : u_errorName(status))));
864 : :
865 : 1302 : return result;
866 : : }
867 : :
868 : : static size_t
869 : 0 : strnxfrm_prefix_icu_utf8(char *dest, size_t destsize,
870 : : const char *src, size_t srclen,
871 : : pg_locale_t locale)
872 : : {
873 : 0 : return strnxfrm_prefix_icu_utf8_internal(dest, destsize, src, srclen, locale);
874 : : }
875 : :
876 : : static size_t
877 : 1302 : strxfrm_prefix_icu_utf8(char *dest, size_t destsize, const char *src,
878 : : pg_locale_t locale)
879 : : {
880 : 1302 : return strnxfrm_prefix_icu_utf8_internal(dest, destsize, src, -1, locale);
881 : : }
882 : :
883 : : char *
884 : 48147 : get_collation_actual_version_icu(const char *collcollate)
885 : : {
886 : : UCollator *collator;
887 : : UVersionInfo versioninfo;
888 : : char buf[U_MAX_VERSION_STRING_LENGTH];
889 : :
890 : 48147 : collator = pg_ucol_open(collcollate);
891 : :
892 : 48147 : ucol_getVersion(collator, versioninfo);
893 : 48147 : ucol_close(collator);
894 : :
895 : 48147 : u_versionToString(versioninfo, buf);
896 : 48147 : return pstrdup(buf);
897 : : }
898 : :
899 : : /*
900 : : * Convert a string in the database encoding into a string of UChars.
901 : : *
902 : : * The source string at buff is of length nbytes
903 : : * (it needn't be nul-terminated)
904 : : *
905 : : * *buff_uchar receives a pointer to the palloc'd result string, and
906 : : * the function's result is the number of UChars generated.
907 : : *
908 : : * The result string is nul-terminated, though most callers rely on the
909 : : * result length instead.
910 : : */
911 : : static int32_t
912 : 12 : icu_to_uchar(UChar **buff_uchar, const char *buff, size_t nbytes)
913 : : {
914 : : int32_t len_uchar;
915 : :
916 : 12 : init_icu_converter();
917 : :
918 : 12 : len_uchar = uchar_length(icu_converter, buff, nbytes);
919 : :
920 : 12 : *buff_uchar = palloc_array(UChar, len_uchar + 1);
921 : 12 : len_uchar = uchar_convert(icu_converter,
922 : : *buff_uchar, len_uchar + 1, buff, nbytes);
923 : :
924 : 12 : return len_uchar;
925 : : }
926 : :
927 : : /*
928 : : * Convert a string of UChars into the database encoding.
929 : : *
930 : : * The source string at buff_uchar is of length len_uchar
931 : : * (it needn't be nul-terminated)
932 : : *
933 : : * *result receives a pointer to the palloc'd result string, and the
934 : : * function's result is the number of bytes generated (not counting nul).
935 : : *
936 : : * The result string is nul-terminated.
937 : : */
938 : : static size_t
939 : 0 : icu_from_uchar(char *dest, size_t destsize, const UChar *buff_uchar, int32_t len_uchar)
940 : : {
941 : : UErrorCode status;
942 : : int32_t len_result;
943 : :
944 : 0 : init_icu_converter();
945 : :
946 : 0 : status = U_ZERO_ERROR;
947 : 0 : len_result = ucnv_fromUChars(icu_converter, NULL, 0,
948 : : buff_uchar, len_uchar, &status);
949 [ # # # # ]: 0 : if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
950 [ # # ]: 0 : ereport(ERROR,
951 : : (errmsg("%s failed: %s", "ucnv_fromUChars",
952 : : u_errorName(status))));
953 : :
954 [ # # ]: 0 : if (len_result + 1 > destsize)
955 : 0 : return len_result;
956 : :
957 : 0 : status = U_ZERO_ERROR;
958 : 0 : len_result = ucnv_fromUChars(icu_converter, dest, len_result + 1,
959 : : buff_uchar, len_uchar, &status);
960 [ # # ]: 0 : if (U_FAILURE(status) ||
961 [ # # ]: 0 : status == U_STRING_NOT_TERMINATED_WARNING)
962 [ # # ]: 0 : ereport(ERROR,
963 : : (errmsg("%s failed: %s", "ucnv_fromUChars",
964 : : u_errorName(status))));
965 : :
966 : 0 : return len_result;
967 : : }
968 : :
969 : : static int32_t
970 : 0 : convert_case_uchar(ICU_Convert_Func func, pg_locale_t mylocale,
971 : : UChar **buff_dest, UChar *buff_source, int32_t len_source)
972 : : {
973 : : UErrorCode status;
974 : : int32_t len_dest;
975 : :
976 : 0 : len_dest = len_source; /* try first with same length */
977 : 0 : *buff_dest = palloc_array(UChar, len_dest);
978 : 0 : status = U_ZERO_ERROR;
979 : 0 : len_dest = func(*buff_dest, len_dest, buff_source, len_source,
980 : : mylocale->icu.locale, &status);
981 [ # # ]: 0 : if (status == U_BUFFER_OVERFLOW_ERROR)
982 : : {
983 : : /* try again with adjusted length */
984 : 0 : pfree(*buff_dest);
985 : 0 : *buff_dest = palloc_array(UChar, len_dest);
986 : 0 : status = U_ZERO_ERROR;
987 : 0 : len_dest = func(*buff_dest, len_dest, buff_source, len_source,
988 : : mylocale->icu.locale, &status);
989 : : }
990 [ # # ]: 0 : if (U_FAILURE(status))
991 [ # # ]: 0 : ereport(ERROR,
992 : : (errmsg("case conversion failed: %s", u_errorName(status))));
993 : 0 : return len_dest;
994 : : }
995 : :
996 : : static int32_t
997 : 0 : icu_convert_case(ICU_Convert_Func func, char *dest, size_t destsize,
998 : : const char *src, size_t srclen, pg_locale_t locale)
999 : : {
1000 : : int32_t len_uchar;
1001 : : int32_t len_conv;
1002 : : UChar *buff_uchar;
1003 : : UChar *buff_conv;
1004 : : size_t result_len;
1005 : :
1006 : 0 : len_uchar = icu_to_uchar(&buff_uchar, src, srclen);
1007 : 0 : len_conv = convert_case_uchar(func, locale, &buff_conv,
1008 : : buff_uchar, len_uchar);
1009 : 0 : result_len = icu_from_uchar(dest, destsize, buff_conv, len_conv);
1010 : 0 : pfree(buff_uchar);
1011 : 0 : pfree(buff_conv);
1012 : :
1013 : 0 : return result_len;
1014 : : }
1015 : :
1016 : : static int32_t
1017 : 0 : u_strToTitle_default_BI(UChar *dest, int32_t destCapacity,
1018 : : const UChar *src, int32_t srcLength,
1019 : : const char *locale,
1020 : : UErrorCode *pErrorCode)
1021 : : {
1022 : 0 : return u_strToTitle(dest, destCapacity, src, srcLength,
1023 : : NULL, locale, pErrorCode);
1024 : : }
1025 : :
1026 : : static int32_t
1027 : 0 : u_strFoldCase_default(UChar *dest, int32_t destCapacity,
1028 : : const UChar *src, int32_t srcLength,
1029 : : const char *locale,
1030 : : UErrorCode *pErrorCode)
1031 : : {
1032 : 0 : return u_strFoldCase(dest, destCapacity, src, srcLength,
1033 : 0 : foldcase_options(locale), pErrorCode);
1034 : : }
1035 : :
1036 : : /*
1037 : : * Return the correct u_strFoldCase() options for the given locale.
1038 : : *
1039 : : * Unlike the ICU APIs for lowercasing, titlecasing, and uppercasing, case
1040 : : * folding does not accept a locale. Instead it just supports a single option
1041 : : * relevant to Turkic languages 'az' and 'tr'; check for those languages.
1042 : : */
1043 : : static int32_t
1044 : 131 : foldcase_options(const char *locale)
1045 : : {
1046 : 131 : uint32 options = U_FOLD_CASE_DEFAULT;
1047 : : char lang[ULOC_LANG_CAPACITY];
1048 : 131 : UErrorCode status = U_ZERO_ERROR;
1049 : :
1050 : 131 : uloc_getLanguage(locale, lang, ULOC_LANG_CAPACITY, &status);
1051 [ + - + - ]: 131 : if (U_SUCCESS(status) && status != U_STRING_NOT_TERMINATED_WARNING)
1052 : : {
1053 : : /*
1054 : : * The option name is confusing, but it causes u_strFoldCase to use
1055 : : * the 'T' mappings, which are ignored for U_FOLD_CASE_DEFAULT.
1056 : : */
1057 [ + + - + ]: 131 : if (strcmp(lang, "tr") == 0 || strcmp(lang, "az") == 0)
1058 : 4 : options = U_FOLD_CASE_EXCLUDE_SPECIAL_I;
1059 : : }
1060 : :
1061 : 131 : return options;
1062 : : }
1063 : :
1064 : : /*
1065 : : * strncoll_icu
1066 : : *
1067 : : * Convert the arguments from the database encoding to UChar strings, then
1068 : : * call ucol_strcoll().
1069 : : *
1070 : : * When the database encoding is UTF-8, and ICU supports ucol_strcollUTF8(),
1071 : : * caller should call that instead.
1072 : : */
1073 : : static int
1074 : 0 : strncoll_icu_internal(const char *arg1, ssize_t len1,
1075 : : const char *arg2, ssize_t len2,
1076 : : pg_locale_t locale)
1077 : : {
1078 : : UChar sbuf[TEXTBUFLEN / sizeof(UChar)];
1079 : 0 : UChar *buf = sbuf;
1080 : : int32_t ulen1;
1081 : : int32_t ulen2;
1082 : : size_t bufsize;
1083 : : UChar *uchar1,
1084 : : *uchar2;
1085 : : int result;
1086 : :
1087 : : /* if encoding is UTF8, use more efficient strncoll_icu_utf8 */
1088 : : #ifdef HAVE_UCOL_STRCOLLUTF8
1089 : : Assert(GetDatabaseEncoding() != PG_UTF8);
1090 : : #endif
1091 : :
1092 : 0 : init_icu_converter();
1093 : :
1094 : 0 : ulen1 = uchar_length(icu_converter, arg1, len1);
1095 : 0 : ulen2 = uchar_length(icu_converter, arg2, len2);
1096 : :
1097 : : /* ulen1+1 or ulen2+1 doesn't risk overflow, but summing them might */
1098 : 0 : bufsize = add_size(ulen1 + 1, ulen2 + 1);
1099 [ # # ]: 0 : if (bufsize > lengthof(sbuf))
1100 : 0 : buf = palloc_array(UChar, bufsize);
1101 : :
1102 : 0 : uchar1 = buf;
1103 : 0 : uchar2 = buf + ulen1 + 1;
1104 : :
1105 : 0 : ulen1 = uchar_convert(icu_converter, uchar1, ulen1 + 1, arg1, len1);
1106 : 0 : ulen2 = uchar_convert(icu_converter, uchar2, ulen2 + 1, arg2, len2);
1107 : :
1108 : 0 : result = ucol_strcoll(locale->icu.ucol,
1109 : : uchar1, ulen1,
1110 : : uchar2, ulen2);
1111 : :
1112 [ # # ]: 0 : if (buf != sbuf)
1113 : 0 : pfree(buf);
1114 : :
1115 : 0 : return result;
1116 : : }
1117 : :
1118 : : static int
1119 : 0 : strncoll_icu(const char *arg1, size_t len1, const char *arg2, size_t len2,
1120 : : pg_locale_t locale)
1121 : : {
1122 : 0 : return strncoll_icu_internal(arg1, len1, arg2, len2, locale);
1123 : : }
1124 : :
1125 : : static int
1126 : 0 : strcoll_icu(const char *arg1, const char *arg2, pg_locale_t locale)
1127 : : {
1128 : 0 : return strncoll_icu_internal(arg1, -1, arg2, -1, locale);
1129 : : }
1130 : :
1131 : : static size_t
1132 : 0 : strnxfrm_prefix_icu_internal(char *dest, size_t destsize,
1133 : : const char *src, ssize_t srclen,
1134 : : pg_locale_t locale)
1135 : : {
1136 : : UChar sbuf[TEXTBUFLEN / sizeof(UChar)];
1137 : 0 : UChar *uchar = sbuf;
1138 : : UCharIterator iter;
1139 : : uint32_t state[2];
1140 : : UErrorCode status;
1141 : : int32_t ulen;
1142 : : Size result_bsize;
1143 : :
1144 : : /* if encoding is UTF8, use more efficient strnxfrm_prefix_icu_utf8 */
1145 : : Assert(GetDatabaseEncoding() != PG_UTF8);
1146 : :
1147 : 0 : init_icu_converter();
1148 : :
1149 : 0 : ulen = uchar_length(icu_converter, src, srclen);
1150 : :
1151 [ # # ]: 0 : if (ulen >= lengthof(sbuf))
1152 : 0 : uchar = palloc_array(UChar, ulen + 1);
1153 : :
1154 : 0 : ulen = uchar_convert(icu_converter, uchar, ulen + 1, src, srclen);
1155 : :
1156 : 0 : uiter_setString(&iter, uchar, ulen);
1157 : 0 : state[0] = state[1] = 0; /* won't need that again */
1158 : 0 : status = U_ZERO_ERROR;
1159 : 0 : result_bsize = ucol_nextSortKeyPart(locale->icu.ucol,
1160 : : &iter,
1161 : : state,
1162 : : (uint8_t *) dest,
1163 : : destsize,
1164 : : &status);
1165 [ # # ]: 0 : if (U_FAILURE(status))
1166 [ # # ]: 0 : ereport(ERROR,
1167 : : (errmsg("sort key generation failed: %s",
1168 : : u_errorName(status))));
1169 : :
1170 [ # # ]: 0 : if (uchar != sbuf)
1171 : 0 : pfree(uchar);
1172 : :
1173 : 0 : return result_bsize;
1174 : : }
1175 : :
1176 : : static size_t
1177 : 0 : strnxfrm_prefix_icu(char *dest, size_t destsize, const char *src, size_t srclen,
1178 : : pg_locale_t locale)
1179 : : {
1180 : 0 : return strnxfrm_prefix_icu_internal(dest, destsize, src, srclen, locale);
1181 : : }
1182 : :
1183 : : static size_t
1184 : 0 : strxfrm_prefix_icu(char *dest, size_t destsize, const char *src,
1185 : : pg_locale_t locale)
1186 : : {
1187 : 0 : return strnxfrm_prefix_icu_internal(dest, destsize, src, -1, locale);
1188 : : }
1189 : :
1190 : : static void
1191 : 8340 : init_icu_converter(void)
1192 : : {
1193 : : const char *icu_encoding_name;
1194 : : UErrorCode status;
1195 : : UConverter *conv;
1196 : :
1197 [ + + ]: 8340 : if (icu_converter)
1198 : 8336 : return; /* already done */
1199 : :
1200 : 4 : icu_encoding_name = get_encoding_name_for_icu(GetDatabaseEncoding());
1201 [ - + ]: 4 : if (!icu_encoding_name)
1202 [ # # ]: 0 : ereport(ERROR,
1203 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1204 : : errmsg("encoding \"%s\" not supported by ICU",
1205 : : pg_encoding_to_char(GetDatabaseEncoding()))));
1206 : :
1207 : 4 : status = U_ZERO_ERROR;
1208 : 4 : conv = ucnv_open(icu_encoding_name, &status);
1209 [ - + ]: 4 : if (U_FAILURE(status))
1210 [ # # ]: 0 : ereport(ERROR,
1211 : : (errmsg("could not open ICU converter for encoding \"%s\": %s",
1212 : : icu_encoding_name, u_errorName(status))));
1213 : :
1214 : 4 : icu_converter = conv;
1215 : : }
1216 : :
1217 : : /*
1218 : : * Find length, in UChars, of given string if converted to UChar string.
1219 : : *
1220 : : * A length of -1 indicates that the input string is NUL-terminated.
1221 : : *
1222 : : * Note: given the assumption that the input string fits in MaxAllocSize,
1223 : : * the result cannot overflow int32_t. But callers must be careful about
1224 : : * multiplying the result by sizeof(UChar).
1225 : : */
1226 : : static int32_t
1227 : 8340 : uchar_length(UConverter *converter, const char *str, int32_t len)
1228 : : {
1229 : 8340 : UErrorCode status = U_ZERO_ERROR;
1230 : : int32_t ulen;
1231 : :
1232 : 8340 : ulen = ucnv_toUChars(converter, NULL, 0, str, len, &status);
1233 [ + - - + ]: 8340 : if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
1234 [ # # ]: 0 : ereport(ERROR,
1235 : : (errmsg("%s failed: %s", "ucnv_toUChars", u_errorName(status))));
1236 : 8340 : return ulen;
1237 : : }
1238 : :
1239 : : /*
1240 : : * Convert the given source string into a UChar string, stored in dest, and
1241 : : * return the length (in UChars).
1242 : : *
1243 : : * A srclen of -1 indicates that the input string is NUL-terminated.
1244 : : */
1245 : : static int32_t
1246 : 8340 : uchar_convert(UConverter *converter, UChar *dest, int32_t destlen,
1247 : : const char *src, int32_t srclen)
1248 : : {
1249 : 8340 : UErrorCode status = U_ZERO_ERROR;
1250 : : int32_t ulen;
1251 : :
1252 : 8340 : ulen = ucnv_toUChars(converter, dest, destlen, src, srclen, &status);
1253 [ - + ]: 8340 : if (U_FAILURE(status))
1254 [ # # ]: 0 : ereport(ERROR,
1255 : : (errmsg("%s failed: %s", "ucnv_toUChars", u_errorName(status))));
1256 : 8340 : return ulen;
1257 : : }
1258 : :
1259 : : /*
1260 : : * Parse collation attributes from the given locale string and apply them to
1261 : : * the open collator.
1262 : : *
1263 : : * First, the locale string is canonicalized to an ICU format locale ID such
1264 : : * as "und@colStrength=primary;colCaseLevel=yes". Then, it parses and applies
1265 : : * the key-value arguments.
1266 : : *
1267 : : * Starting with ICU version 54, the attributes are processed automatically by
1268 : : * ucol_open(), so this is only necessary for emulating this behavior on older
1269 : : * versions.
1270 : : */
1271 : : pg_attribute_unused()
1272 : : static void
1273 : 0 : icu_set_collation_attributes(UCollator *collator, const char *loc,
1274 : : UErrorCode *status)
1275 : : {
1276 : : int32_t len;
1277 : : char *icu_locale_id;
1278 : : char *lower_str;
1279 : : char *str;
1280 : : char *token;
1281 : :
1282 : : /*
1283 : : * The input locale may be a BCP 47 language tag, e.g.
1284 : : * "und-u-kc-ks-level1", which expresses the same attributes in a
1285 : : * different form. It will be converted to the equivalent ICU format
1286 : : * locale ID, e.g. "und@colcaselevel=yes;colstrength=primary", by
1287 : : * uloc_canonicalize().
1288 : : */
1289 : 0 : *status = U_ZERO_ERROR;
1290 : 0 : len = uloc_canonicalize(loc, NULL, 0, status);
1291 : 0 : icu_locale_id = palloc(len + 1);
1292 : 0 : *status = U_ZERO_ERROR;
1293 : 0 : len = uloc_canonicalize(loc, icu_locale_id, len + 1, status);
1294 [ # # # # ]: 0 : if (U_FAILURE(*status) || *status == U_STRING_NOT_TERMINATED_WARNING)
1295 : 0 : return;
1296 : :
1297 : 0 : lower_str = asc_tolower(icu_locale_id, strlen(icu_locale_id));
1298 : :
1299 : 0 : pfree(icu_locale_id);
1300 : :
1301 : 0 : str = strchr(lower_str, '@');
1302 [ # # ]: 0 : if (!str)
1303 : 0 : return;
1304 : 0 : str++;
1305 : :
1306 [ # # ]: 0 : while ((token = strsep(&str, ";")))
1307 : : {
1308 : 0 : char *e = strchr(token, '=');
1309 : :
1310 [ # # ]: 0 : if (e)
1311 : : {
1312 : : char *name;
1313 : : char *value;
1314 : : UColAttribute uattr;
1315 : : UColAttributeValue uvalue;
1316 : :
1317 : 0 : *status = U_ZERO_ERROR;
1318 : :
1319 : 0 : *e = '\0';
1320 : 0 : name = token;
1321 : 0 : value = e + 1;
1322 : :
1323 : : /*
1324 : : * See attribute name and value lists in ICU i18n/coll.cpp
1325 : : */
1326 [ # # ]: 0 : if (strcmp(name, "colstrength") == 0)
1327 : 0 : uattr = UCOL_STRENGTH;
1328 [ # # ]: 0 : else if (strcmp(name, "colbackwards") == 0)
1329 : 0 : uattr = UCOL_FRENCH_COLLATION;
1330 [ # # ]: 0 : else if (strcmp(name, "colcaselevel") == 0)
1331 : 0 : uattr = UCOL_CASE_LEVEL;
1332 [ # # ]: 0 : else if (strcmp(name, "colcasefirst") == 0)
1333 : 0 : uattr = UCOL_CASE_FIRST;
1334 [ # # ]: 0 : else if (strcmp(name, "colalternate") == 0)
1335 : 0 : uattr = UCOL_ALTERNATE_HANDLING;
1336 [ # # ]: 0 : else if (strcmp(name, "colnormalization") == 0)
1337 : 0 : uattr = UCOL_NORMALIZATION_MODE;
1338 [ # # ]: 0 : else if (strcmp(name, "colnumeric") == 0)
1339 : 0 : uattr = UCOL_NUMERIC_COLLATION;
1340 : : else
1341 : : /* ignore if unknown */
1342 : 0 : continue;
1343 : :
1344 [ # # ]: 0 : if (strcmp(value, "primary") == 0)
1345 : 0 : uvalue = UCOL_PRIMARY;
1346 [ # # ]: 0 : else if (strcmp(value, "secondary") == 0)
1347 : 0 : uvalue = UCOL_SECONDARY;
1348 [ # # ]: 0 : else if (strcmp(value, "tertiary") == 0)
1349 : 0 : uvalue = UCOL_TERTIARY;
1350 [ # # ]: 0 : else if (strcmp(value, "quaternary") == 0)
1351 : 0 : uvalue = UCOL_QUATERNARY;
1352 [ # # ]: 0 : else if (strcmp(value, "identical") == 0)
1353 : 0 : uvalue = UCOL_IDENTICAL;
1354 [ # # ]: 0 : else if (strcmp(value, "no") == 0)
1355 : 0 : uvalue = UCOL_OFF;
1356 [ # # ]: 0 : else if (strcmp(value, "yes") == 0)
1357 : 0 : uvalue = UCOL_ON;
1358 [ # # ]: 0 : else if (strcmp(value, "shifted") == 0)
1359 : 0 : uvalue = UCOL_SHIFTED;
1360 [ # # ]: 0 : else if (strcmp(value, "non-ignorable") == 0)
1361 : 0 : uvalue = UCOL_NON_IGNORABLE;
1362 [ # # ]: 0 : else if (strcmp(value, "lower") == 0)
1363 : 0 : uvalue = UCOL_LOWER_FIRST;
1364 [ # # ]: 0 : else if (strcmp(value, "upper") == 0)
1365 : 0 : uvalue = UCOL_UPPER_FIRST;
1366 : : else
1367 : : {
1368 : 0 : *status = U_ILLEGAL_ARGUMENT_ERROR;
1369 : 0 : break;
1370 : : }
1371 : :
1372 : 0 : ucol_setAttribute(collator, uattr, uvalue, status);
1373 : : }
1374 : : }
1375 : :
1376 : 0 : pfree(lower_str);
1377 : : }
1378 : :
1379 : : #endif /* USE_ICU */
|
