71 #include <unicode/ucnv.h>
72 #include <unicode/ustring.h>
76 #include <gnu/libc-version.h>
84 #define PGLOCALE_SUPPORT_ERROR(provider) \
85 elog(ERROR, "unsupported collprovider for %s: %c", __func__, provider)
91 #define TEXTBUFLEN 1024
93 #define MAX_L10N_DATA 80
137 #if defined(WIN32) && defined(LC_MESSAGES)
138 static char *IsoLocaleName(
const char *);
147 static UConverter *icu_converter = NULL;
149 static UCollator *pg_ucol_open(
const char *loc_str);
150 static void init_icu_converter(
void);
151 static size_t uchar_length(UConverter *converter,
152 const char *
str, int32_t
len);
153 static int32_t uchar_convert(UConverter *converter,
154 UChar *
dest, int32_t destlen,
155 const char *src, int32_t srclen);
156 static void icu_set_collation_attributes(UCollator *collator,
const char *loc,
164 #ifndef HAVE_MBSTOWCS_L
169 return _mbstowcs_l(
dest, src, n, loc);
172 locale_t save_locale = uselocale(loc);
174 result = mbstowcs(
dest, src, n);
175 uselocale(save_locale);
180 #ifndef HAVE_WCSTOMBS_L
185 return _wcstombs_l(
dest, src, n, loc);
188 locale_t save_locale = uselocale(loc);
190 result = wcstombs(
dest, src, n);
191 uselocale(save_locale);
228 if (category == LC_MESSAGES)
249 if (category == LC_CTYPE)
254 strlcpy(save_lc_ctype, result,
sizeof(save_lc_ctype));
255 result = save_lc_ctype;
267 envvar =
"LC_COLLATE";
274 envvar =
"LC_MESSAGES";
276 result = IsoLocaleName(
locale);
279 elog(
DEBUG3,
"IsoLocaleName() executed; locale: \"%s\"", result);
284 envvar =
"LC_MONETARY";
287 envvar =
"LC_NUMERIC";
293 elog(
FATAL,
"unrecognized LC category: %d", category);
297 if (
setenv(envvar, result, 1) != 0)
334 if (
res && canonname)
339 elog(
WARNING,
"failed to restore old locale \"%s\"", save);
342 return (
res != NULL);
419 #if defined(LC_MESSAGES) && !defined(WIN32)
446 free(s->decimal_point);
447 free(s->thousands_sep);
449 free(s->int_curr_symbol);
450 free(s->currency_symbol);
451 free(s->mon_decimal_point);
452 free(s->mon_thousands_sep);
453 free(s->mon_grouping);
454 free(s->positive_sign);
455 free(s->negative_sign);
465 if (s->decimal_point == NULL)
467 if (s->thousands_sep == NULL)
469 if (s->grouping == NULL)
471 if (s->int_curr_symbol == NULL)
473 if (s->currency_symbol == NULL)
475 if (s->mon_decimal_point == NULL)
477 if (s->mon_thousands_sep == NULL)
479 if (s->mon_grouping == NULL)
481 if (s->positive_sign == NULL)
483 if (s->negative_sign == NULL)
508 (
errcode(ERRCODE_OUT_OF_MEMORY),
509 errmsg(
"out of memory")));
526 static struct lconv CurrentLocaleConv;
527 static bool CurrentLocaleConvAllocated =
false;
528 struct lconv *extlconv;
529 struct lconv worklconv;
530 char *save_lc_monetary;
531 char *save_lc_numeric;
538 return &CurrentLocaleConv;
541 if (CurrentLocaleConvAllocated)
544 CurrentLocaleConvAllocated =
false;
559 memset(&worklconv, 0,
sizeof(worklconv));
562 save_lc_monetary =
setlocale(LC_MONETARY, NULL);
563 if (!save_lc_monetary)
565 save_lc_monetary =
pstrdup(save_lc_monetary);
567 save_lc_numeric =
setlocale(LC_NUMERIC, NULL);
568 if (!save_lc_numeric)
570 save_lc_numeric =
pstrdup(save_lc_numeric);
589 save_lc_ctype =
setlocale(LC_CTYPE, NULL);
592 save_lc_ctype =
pstrdup(save_lc_ctype);
602 extlconv = localeconv();
605 worklconv.decimal_point = strdup(extlconv->decimal_point);
606 worklconv.thousands_sep = strdup(extlconv->thousands_sep);
607 worklconv.grouping = strdup(extlconv->grouping);
616 extlconv = localeconv();
619 worklconv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
620 worklconv.currency_symbol = strdup(extlconv->currency_symbol);
621 worklconv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
622 worklconv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
623 worklconv.mon_grouping = strdup(extlconv->mon_grouping);
624 worklconv.positive_sign = strdup(extlconv->positive_sign);
625 worklconv.negative_sign = strdup(extlconv->negative_sign);
627 worklconv.int_frac_digits = extlconv->int_frac_digits;
628 worklconv.frac_digits = extlconv->frac_digits;
629 worklconv.p_cs_precedes = extlconv->p_cs_precedes;
630 worklconv.p_sep_by_space = extlconv->p_sep_by_space;
631 worklconv.n_cs_precedes = extlconv->n_cs_precedes;
632 worklconv.n_sep_by_space = extlconv->n_sep_by_space;
633 worklconv.p_sign_posn = extlconv->p_sign_posn;
634 worklconv.n_sign_posn = extlconv->n_sign_posn;
646 elog(
FATAL,
"failed to restore LC_CTYPE to \"%s\"", save_lc_ctype);
648 if (!
setlocale(LC_MONETARY, save_lc_monetary))
649 elog(
FATAL,
"failed to restore LC_MONETARY to \"%s\"", save_lc_monetary);
650 if (!
setlocale(LC_NUMERIC, save_lc_numeric))
651 elog(
FATAL,
"failed to restore LC_NUMERIC to \"%s\"", save_lc_numeric);
663 pfree(save_lc_monetary);
664 pfree(save_lc_numeric);
666 pfree(save_lc_ctype);
672 (
errcode(ERRCODE_OUT_OF_MEMORY),
673 errmsg(
"out of memory")));
712 CurrentLocaleConv = worklconv;
713 CurrentLocaleConvAllocated =
true;
715 return &CurrentLocaleConv;
735 strftime_win32(
char *dst,
size_t dstlen,
746 len = MultiByteToWideChar(CP_UTF8, 0,
format, -1,
749 elog(
ERROR,
"could not convert format string from UTF-8: error code %lu",
762 len = WideCharToMultiByte(CP_UTF8, 0, wbuf,
len, dst, dstlen - 1,
765 elog(
ERROR,
"could not convert string to UTF-8: error code %lu",
774 #define strftime(a,b,c,d) strftime_win32(a,b,c,d)
812 bool strftimefail =
false;
837 save_lc_time =
pstrdup(save_lc_time);
849 save_lc_ctype =
setlocale(LC_CTYPE, NULL);
852 save_lc_ctype =
pstrdup(save_lc_ctype);
861 timenow = time(NULL);
862 timeinfo = localtime(&timenow);
878 for (
i = 0;
i < 7;
i++)
880 timeinfo->tm_wday =
i;
890 for (
i = 0;
i < 12;
i++)
892 timeinfo->tm_mon =
i;
893 timeinfo->tm_mday = 1;
908 elog(
FATAL,
"failed to restore LC_CTYPE to \"%s\"", save_lc_ctype);
911 elog(
FATAL,
"failed to restore LC_TIME to \"%s\"", save_lc_time);
923 pfree(save_lc_ctype);
950 for (
i = 0;
i < 7;
i++)
961 for (
i = 0;
i < 12;
i++)
975 #if defined(WIN32) && defined(LC_MESSAGES)
1022 #if defined(_MSC_VER)
1036 static BOOL CALLBACK
1037 search_locale_enum(LPWSTR pStr, DWORD dwFlags, LPARAM lparam)
1039 wchar_t test_locale[LOCALE_NAME_MAX_LENGTH];
1044 argv = (
wchar_t **) lparam;
1045 *argv[2] = (wchar_t) 0;
1047 memset(test_locale, 0,
sizeof(test_locale));
1050 if (GetLocaleInfoEx(pStr, LOCALE_SENGLISHLANGUAGENAME,
1051 test_locale, LOCALE_NAME_MAX_LENGTH))
1058 if (wcsrchr(pStr,
'-') == NULL || wcsrchr(argv[0],
'_') == NULL)
1060 if (_wcsicmp(argv[0], test_locale) == 0)
1062 wcscpy(argv[1], pStr);
1063 *argv[2] = (wchar_t) 1;
1077 wcscat(test_locale, L
"_");
1078 len = wcslen(test_locale);
1079 if (GetLocaleInfoEx(pStr, LOCALE_SENGLISHCOUNTRYNAME,
1081 LOCALE_NAME_MAX_LENGTH -
len))
1083 if (_wcsicmp(argv[0], test_locale) == 0)
1085 wcscpy(argv[1], pStr);
1086 *argv[2] = (wchar_t) 1;
1103 get_iso_localename(
const char *winlocname)
1105 wchar_t wc_locale_name[LOCALE_NAME_MAX_LENGTH];
1106 wchar_t buffer[LOCALE_NAME_MAX_LENGTH];
1107 static char iso_lc_messages[LOCALE_NAME_MAX_LENGTH];
1119 period = strchr(winlocname,
'.');
1125 memset(wc_locale_name, 0,
sizeof(wc_locale_name));
1126 memset(buffer, 0,
sizeof(buffer));
1127 MultiByteToWideChar(CP_ACP, 0, winlocname,
len, wc_locale_name,
1128 LOCALE_NAME_MAX_LENGTH);
1134 ret_val = GetLocaleInfoEx(wc_locale_name, LOCALE_SNAME, (LPWSTR) &buffer,
1135 LOCALE_NAME_MAX_LENGTH);
1144 argv[0] = wc_locale_name;
1146 argv[2] = (
wchar_t *) &ret_val;
1147 EnumSystemLocalesEx(search_locale_enum, LOCALE_WINDOWS, (LPARAM) argv,
1157 rc =
wchar2char(iso_lc_messages, buffer,
sizeof(iso_lc_messages), NULL);
1158 if (rc == -1 || rc ==
sizeof(iso_lc_messages))
1168 hyphen = strchr(iso_lc_messages,
'-');
1171 return iso_lc_messages;
1178 IsoLocaleName(
const char *winlocname)
1180 static char iso_lc_messages[LOCALE_NAME_MAX_LENGTH];
1185 strcpy(iso_lc_messages,
"C");
1186 return iso_lc_messages;
1189 return get_iso_localename(winlocname);
1195 IsoLocaleName(
const char *winlocname)
1236 Assert(collation != DEFAULT_COLLATION_OID);
1268 elog(
ERROR,
"cache lookup failed for collation %u", collation);
1271 if (collform->collprovider == COLLPROVIDER_BUILTIN)
1276 else if (collform->collprovider == COLLPROVIDER_LIBC)
1279 const char *collcollate;
1280 const char *collctype;
1287 cache_entry->
collate_is_c = ((strcmp(collcollate,
"C") == 0) ||
1288 (strcmp(collcollate,
"POSIX") == 0));
1289 cache_entry->
ctype_is_c = ((strcmp(collctype,
"C") == 0) ||
1290 (strcmp(collctype,
"POSIX") == 0));
1324 if (collation == DEFAULT_COLLATION_OID)
1326 static int result = -1;
1327 const char *localeptr;
1330 return (
bool) result;
1335 return (
bool) result;
1340 return (
bool) result;
1346 elog(
ERROR,
"invalid LC_CTYPE setting");
1349 elog(
ERROR,
"unexpected collation provider '%c'",
1352 if (strcmp(localeptr,
"C") == 0)
1354 else if (strcmp(localeptr,
"POSIX") == 0)
1358 return (
bool) result;
1364 if (collation == C_COLLATION_OID ||
1365 collation == POSIX_COLLATION_OID)
1391 if (collation == DEFAULT_COLLATION_OID)
1393 static int result = -1;
1394 const char *localeptr;
1397 return (
bool) result;
1406 return (
bool) result;
1412 elog(
ERROR,
"invalid LC_CTYPE setting");
1415 elog(
ERROR,
"unexpected collation provider '%c'",
1418 if (strcmp(localeptr,
"C") == 0)
1420 else if (strcmp(localeptr,
"POSIX") == 0)
1424 return (
bool) result;
1430 if (collation == C_COLLATION_OID ||
1431 collation == POSIX_COLLATION_OID)
1444 const char *icurules,
1448 UCollator *collator;
1450 collator = pg_ucol_open(iculocstr);
1458 const UChar *default_rules;
1464 default_rules = ucol_getRules(collator, &length);
1465 icu_to_uchar(&my_rules, icurules, strlen(icurules));
1467 agg_rules =
palloc_array(UChar, u_strlen(default_rules) + u_strlen(my_rules) + 1);
1468 u_strcpy(agg_rules, default_rules);
1469 u_strcat(agg_rules, my_rules);
1471 ucol_close(collator);
1473 status = U_ZERO_ERROR;
1474 collator = ucol_openRules(agg_rules, u_strlen(agg_rules),
1475 UCOL_DEFAULT, UCOL_DEFAULT_STRENGTH, NULL, &status);
1476 if (U_FAILURE(status))
1478 (
errmsg(
"could not open collator for locale \"%s\" with rules \"%s\": %s",
1479 iculocstr, icurules, u_errorName(status))));
1484 resultp->
info.icu.ucol = collator;
1488 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1489 errmsg(
"ICU is not supported in this build")));
1516 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1517 errmsg(
"could not create locale \"%s\": %m",
1519 (save_errno == ENOENT ?
1520 errdetail(
"The operating system could not find any locale data for the locale name \"%s\".",
1531 return locale->deterministic;
1552 if (
collid == DEFAULT_COLLATION_OID)
1562 if (cache_entry->
locale == 0)
1578 memset(&result, 0,
sizeof(result));
1579 result.
provider = collform->collprovider;
1582 if (collform->collprovider == COLLPROVIDER_BUILTIN)
1594 else if (collform->collprovider == COLLPROVIDER_LIBC)
1596 const char *collcollate;
1605 if (strcmp(collcollate, collctype) == 0)
1610 loc = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collcollate,
1613 loc = _create_locale(LC_ALL, collcollate);
1625 loc1 = newlocale(LC_COLLATE_MASK, collcollate, NULL);
1629 loc = newlocale(LC_CTYPE_MASK, collctype, loc1);
1640 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1641 errmsg(
"collations with different collate and ctype values are not supported on this platform")));
1647 else if (collform->collprovider == COLLPROVIDER_ICU)
1649 const char *iculocstr;
1650 const char *icurules;
1655 datum =
SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collicurules, &isnull);
1668 char *actual_versionstr;
1669 char *collversionstr;
1673 Assert(collform->collprovider != COLLPROVIDER_BUILTIN);
1674 if (collform->collprovider == COLLPROVIDER_LIBC)
1681 if (!actual_versionstr)
1689 (
errmsg(
"collation \"%s\" has no actual version, but a version was recorded",
1690 NameStr(collform->collname))));
1693 if (strcmp(actual_versionstr, collversionstr) != 0)
1695 (
errmsg(
"collation \"%s\" has version mismatch",
1697 errdetail(
"The collation in the database was created using version %s, "
1698 "but the operating system provides version %s.",
1699 collversionstr, actual_versionstr),
1700 errhint(
"Rebuild all objects affected by this collation and run "
1701 "ALTER COLLATION %s REFRESH VERSION, "
1702 "or build PostgreSQL with the right library version.",
1704 NameStr(collform->collname)))));
1713 cache_entry->
locale = resultp;
1716 return cache_entry->
locale;
1726 char *collversion = NULL;
1729 if (collprovider == COLLPROVIDER_BUILTIN)
1733 if (collprovider == COLLPROVIDER_ICU)
1735 UCollator *collator;
1736 UVersionInfo versioninfo;
1737 char buf[U_MAX_VERSION_STRING_LENGTH];
1739 collator = pg_ucol_open(collcollate);
1741 ucol_getVersion(collator, versioninfo);
1742 ucol_close(collator);
1744 u_versionToString(versioninfo,
buf);
1749 if (collprovider == COLLPROVIDER_LIBC &&
1754 #if defined(__GLIBC__)
1756 collversion =
pstrdup(gnu_get_libc_version());
1757 #elif defined(LC_VERSION_MASK)
1761 loc = newlocale(LC_COLLATE, collcollate, NULL);
1765 pstrdup(querylocale(LC_COLLATE_MASK | LC_VERSION_MASK, loc));
1770 (
errmsg(
"could not load locale \"%s\"", collcollate)));
1771 #elif defined(WIN32)
1777 NLSVERSIONINFOEX version = {
sizeof(NLSVERSIONINFOEX)};
1778 WCHAR wide_collcollate[LOCALE_NAME_MAX_LENGTH];
1780 MultiByteToWideChar(CP_ACP, 0, collcollate, -1, wide_collcollate,
1781 LOCALE_NAME_MAX_LENGTH);
1782 if (!GetNLSVersionEx(COMPARE_STRING, wide_collcollate, &version))
1791 if (GetLastError() == ERROR_INVALID_PARAMETER)
1795 (
errmsg(
"could not get collation version for locale \"%s\": error code %lu",
1799 collversion =
psprintf(
"%lu.%lu,%lu.%lu",
1800 (version.dwNLSVersion >> 8) & 0xFFFF,
1801 version.dwNLSVersion & 0xFF,
1802 (version.dwDefinedVersion >> 8) & 0xFFFF,
1803 version.dwDefinedVersion & 0xFF);
1818 pg_strncoll_libc_win32_utf8(
const char *arg1,
size_t len1,
const char *arg2,
1825 int a1len = len1 * 2 + 2;
1826 int a2len = len2 * 2 + 2;
1847 r = MultiByteToWideChar(CP_UTF8, 0, arg1, len1,
1848 (LPWSTR) a1p, a1len / 2);
1851 (
errmsg(
"could not convert string to UTF-16: error code %lu",
1854 ((LPWSTR) a1p)[r] = 0;
1860 r = MultiByteToWideChar(CP_UTF8, 0, arg2, len2,
1861 (LPWSTR) a2p, a2len / 2);
1864 (
errmsg(
"could not convert string to UTF-16: error code %lu",
1867 ((LPWSTR) a2p)[r] = 0;
1873 result = wcscoll((LPWSTR) a1p, (LPWSTR) a2p);
1874 if (result == 2147483647)
1876 (
errmsg(
"could not compare Unicode strings: %m")));
1903 size_t len1 = strlen(arg1);
1904 size_t len2 = strlen(arg2);
1906 result = pg_strncoll_libc_win32_utf8(arg1, len1, arg2, len2,
locale);
1913 result = strcoll(arg1, arg2);
1929 size_t bufsize1 = len1 + 1;
1930 size_t bufsize2 = len2 + 1;
1940 return pg_strncoll_libc_win32_utf8(arg1, len1, arg2, len2,
locale);
1947 arg2n =
buf + bufsize1;
1950 memcpy(arg1n, arg1, len1);
1952 memcpy(arg2n, arg2, len2);
1976 pg_strncoll_icu_no_utf8(
const char *arg1, int32_t len1,
1990 #ifdef HAVE_UCOL_STRCOLLUTF8
1994 init_icu_converter();
1996 ulen1 = uchar_length(icu_converter, arg1, len1);
1997 ulen2 = uchar_length(icu_converter, arg2, len2);
1999 bufsize1 = (ulen1 + 1) *
sizeof(UChar);
2000 bufsize2 = (ulen2 + 1) *
sizeof(UChar);
2005 uchar1 = (UChar *)
buf;
2006 uchar2 = (UChar *) (
buf + bufsize1);
2008 ulen1 = uchar_convert(icu_converter, uchar1, ulen1 + 1, arg1, len1);
2009 ulen2 = uchar_convert(icu_converter, uchar2, ulen2 + 1, arg2, len2);
2011 result = ucol_strcoll(
locale->info.icu.ucol,
2031 pg_strncoll_icu(
const char *arg1, int32_t len1,
const char *arg2, int32_t len2,
2038 #ifdef HAVE_UCOL_STRCOLLUTF8
2043 status = U_ZERO_ERROR;
2044 result = ucol_strcollUTF8(
locale->info.icu.ucol,
2048 if (U_FAILURE(status))
2050 (
errmsg(
"collation failed: %s", u_errorName(status))));
2055 result = pg_strncoll_icu_no_utf8(arg1, len1, arg2, len2,
locale);
2084 else if (
locale->provider == COLLPROVIDER_ICU)
2085 result = pg_strncoll_icu(arg1, -1, arg2, -1,
locale);
2112 pg_strncoll(
const char *arg1,
size_t len1,
const char *arg2,
size_t len2,
2120 else if (
locale->provider == COLLPROVIDER_ICU)
2121 result = pg_strncoll_icu(arg1, len1, arg2, len2,
locale);
2137 #ifdef TRUST_STRXFRM
2141 return strxfrm(
dest, src, destsize);
2164 memcpy(
buf, src, srclen);
2173 Assert(result >= destsize ||
dest[result] ==
'\0');
2182 pg_strnxfrm_icu(
char *
dest,
const char *src, int32_t srclen, int32_t destsize,
2194 init_icu_converter();
2196 ulen = uchar_length(icu_converter, src, srclen);
2198 uchar_bsize = (ulen + 1) *
sizeof(UChar);
2203 uchar = (UChar *)
buf;
2205 ulen = uchar_convert(icu_converter, uchar, ulen + 1, src, srclen);
2207 result_bsize = ucol_getSortKey(
locale->info.icu.ucol,
2209 (uint8_t *)
dest, destsize);
2215 Assert(result_bsize > 0);
2222 Assert(result_bsize >= destsize ||
dest[result_bsize] ==
'\0');
2224 return result_bsize;
2229 pg_strnxfrm_prefix_icu_no_utf8(
char *
dest,
const char *src, int32_t srclen,
2238 UChar *uchar = NULL;
2245 init_icu_converter();
2247 ulen = uchar_length(icu_converter, src, srclen);
2249 uchar_bsize = (ulen + 1) *
sizeof(UChar);
2254 uchar = (UChar *)
buf;
2256 ulen = uchar_convert(icu_converter, uchar, ulen + 1, src, srclen);
2258 uiter_setString(&iter, uchar, ulen);
2260 status = U_ZERO_ERROR;
2261 result_bsize = ucol_nextSortKeyPart(
locale->info.icu.ucol,
2267 if (U_FAILURE(status))
2269 (
errmsg(
"sort key generation failed: %s",
2270 u_errorName(status))));
2272 return result_bsize;
2277 pg_strnxfrm_prefix_icu(
char *
dest,
const char *src, int32_t srclen,
2290 uiter_setUTF8(&iter, src, srclen);
2292 status = U_ZERO_ERROR;
2293 result = ucol_nextSortKeyPart(
locale->info.icu.ucol,
2299 if (U_FAILURE(status))
2301 (
errmsg(
"sort key generation failed: %s",
2302 u_errorName(status))));
2305 result = pg_strnxfrm_prefix_icu_no_utf8(
dest, src, srclen, destsize,
2331 #ifdef TRUST_STRXFRM
2336 else if (
locale->provider == COLLPROVIDER_ICU)
2367 else if (
locale->provider == COLLPROVIDER_ICU)
2368 result = pg_strnxfrm_icu(
dest, src, -1, destsize,
locale);
2404 else if (
locale->provider == COLLPROVIDER_ICU)
2405 result = pg_strnxfrm_icu(
dest, src, srclen, destsize,
locale);
2423 else if (
locale->provider == COLLPROVIDER_ICU)
2454 else if (
locale->provider == COLLPROVIDER_ICU)
2455 result = pg_strnxfrm_prefix_icu(
dest, src, -1, destsize,
locale);
2489 else if (
locale->provider == COLLPROVIDER_ICU)
2490 result = pg_strnxfrm_prefix_icu(
dest, src, -1, destsize,
locale);
2508 if (strcmp(
locale,
"C") != 0)
2510 (
errcode(ERRCODE_WRONG_OBJECT_TYPE),
2511 errmsg(
"invalid locale name \"%s\" for builtin provider",
2528 if (strcmp(
locale,
"C") != 0)
2530 (
errcode(ERRCODE_WRONG_OBJECT_TYPE),
2531 errmsg(
"invalid locale name \"%s\" for builtin provider",
2545 pg_ucol_open(
const char *loc_str)
2547 UCollator *collator;
2549 const char *orig_str = loc_str;
2550 char *fixed_str = NULL;
2561 if (loc_str == NULL)
2562 elog(
ERROR,
"opening default collator is not supported");
2569 if (U_ICU_VERSION_MAJOR_NUM < 55)
2571 char lang[ULOC_LANG_CAPACITY];
2573 status = U_ZERO_ERROR;
2574 uloc_getLanguage(loc_str, lang, ULOC_LANG_CAPACITY, &status);
2575 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
2578 (
errmsg(
"could not get language from locale \"%s\": %s",
2579 loc_str, u_errorName(status))));
2582 if (strcmp(lang,
"und") == 0)
2584 const char *remainder = loc_str + strlen(
"und");
2586 fixed_str =
palloc(strlen(
"root") + strlen(remainder) + 1);
2587 strcpy(fixed_str,
"root");
2588 strcat(fixed_str, remainder);
2590 loc_str = fixed_str;
2594 status = U_ZERO_ERROR;
2595 collator = ucol_open(loc_str, &status);
2596 if (U_FAILURE(status))
2599 (
errmsg(
"could not open collator for locale \"%s\": %s",
2600 orig_str, u_errorName(status))));
2602 if (U_ICU_VERSION_MAJOR_NUM < 54)
2604 status = U_ZERO_ERROR;
2605 icu_set_collation_attributes(collator, loc_str, &status);
2611 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
2613 ucol_close(collator);
2615 (
errmsg(
"could not open collator for locale \"%s\": %s",
2616 orig_str, u_errorName(status))));
2620 if (fixed_str != NULL)
2627 init_icu_converter(
void)
2629 const char *icu_encoding_name;
2637 if (!icu_encoding_name)
2639 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2640 errmsg(
"encoding \"%s\" not supported by ICU",
2643 status = U_ZERO_ERROR;
2644 conv = ucnv_open(icu_encoding_name, &status);
2645 if (U_FAILURE(status))
2647 (
errmsg(
"could not open ICU converter for encoding \"%s\": %s",
2648 icu_encoding_name, u_errorName(status))));
2650 icu_converter = conv;
2657 uchar_length(UConverter *converter,
const char *
str, int32_t
len)
2659 UErrorCode status = U_ZERO_ERROR;
2662 ulen = ucnv_toUChars(converter, NULL, 0,
str,
len, &status);
2663 if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
2665 (
errmsg(
"%s failed: %s",
"ucnv_toUChars", u_errorName(status))));
2674 uchar_convert(UConverter *converter, UChar *
dest, int32_t destlen,
2675 const char *src, int32_t srclen)
2677 UErrorCode status = U_ZERO_ERROR;
2680 status = U_ZERO_ERROR;
2681 ulen = ucnv_toUChars(converter,
dest, destlen, src, srclen, &status);
2682 if (U_FAILURE(status))
2684 (
errmsg(
"%s failed: %s",
"ucnv_toUChars", u_errorName(status))));
2701 icu_to_uchar(UChar **buff_uchar,
const char *buff,
size_t nbytes)
2705 init_icu_converter();
2707 len_uchar = uchar_length(icu_converter, buff, nbytes);
2709 *buff_uchar =
palloc((len_uchar + 1) *
sizeof(**buff_uchar));
2710 len_uchar = uchar_convert(icu_converter,
2711 *buff_uchar, len_uchar + 1, buff, nbytes);
2728 icu_from_uchar(
char **result,
const UChar *buff_uchar, int32_t len_uchar)
2733 init_icu_converter();
2735 status = U_ZERO_ERROR;
2736 len_result = ucnv_fromUChars(icu_converter, NULL, 0,
2737 buff_uchar, len_uchar, &status);
2738 if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
2740 (
errmsg(
"%s failed: %s",
"ucnv_fromUChars",
2741 u_errorName(status))));
2743 *result =
palloc(len_result + 1);
2745 status = U_ZERO_ERROR;
2746 len_result = ucnv_fromUChars(icu_converter, *result, len_result + 1,
2747 buff_uchar, len_uchar, &status);
2748 if (U_FAILURE(status) ||
2749 status == U_STRING_NOT_TERMINATED_WARNING)
2751 (
errmsg(
"%s failed: %s",
"ucnv_fromUChars",
2752 u_errorName(status))));
2771 icu_set_collation_attributes(UCollator *collator, const
char *loc,
2775 char *icu_locale_id;
2786 *status = U_ZERO_ERROR;
2787 len = uloc_canonicalize(loc, NULL, 0, status);
2789 *status = U_ZERO_ERROR;
2790 len = uloc_canonicalize(loc, icu_locale_id,
len + 1, status);
2791 if (U_FAILURE(*status) || *status == U_STRING_NOT_TERMINATED_WARNING)
2794 lower_str =
asc_tolower(icu_locale_id, strlen(icu_locale_id));
2796 pfree(icu_locale_id);
2798 str = strchr(lower_str,
'@');
2805 char *
e = strchr(
token,
'=');
2811 UColAttribute uattr;
2812 UColAttributeValue uvalue;
2814 *status = U_ZERO_ERROR;
2823 if (strcmp(
name,
"colstrength") == 0)
2824 uattr = UCOL_STRENGTH;
2825 else if (strcmp(
name,
"colbackwards") == 0)
2826 uattr = UCOL_FRENCH_COLLATION;
2827 else if (strcmp(
name,
"colcaselevel") == 0)
2828 uattr = UCOL_CASE_LEVEL;
2829 else if (strcmp(
name,
"colcasefirst") == 0)
2830 uattr = UCOL_CASE_FIRST;
2831 else if (strcmp(
name,
"colalternate") == 0)
2832 uattr = UCOL_ALTERNATE_HANDLING;
2833 else if (strcmp(
name,
"colnormalization") == 0)
2834 uattr = UCOL_NORMALIZATION_MODE;
2835 else if (strcmp(
name,
"colnumeric") == 0)
2836 uattr = UCOL_NUMERIC_COLLATION;
2841 if (strcmp(
value,
"primary") == 0)
2842 uvalue = UCOL_PRIMARY;
2843 else if (strcmp(
value,
"secondary") == 0)
2844 uvalue = UCOL_SECONDARY;
2845 else if (strcmp(
value,
"tertiary") == 0)
2846 uvalue = UCOL_TERTIARY;
2847 else if (strcmp(
value,
"quaternary") == 0)
2848 uvalue = UCOL_QUATERNARY;
2849 else if (strcmp(
value,
"identical") == 0)
2850 uvalue = UCOL_IDENTICAL;
2851 else if (strcmp(
value,
"no") == 0)
2853 else if (strcmp(
value,
"yes") == 0)
2855 else if (strcmp(
value,
"shifted") == 0)
2856 uvalue = UCOL_SHIFTED;
2857 else if (strcmp(
value,
"non-ignorable") == 0)
2858 uvalue = UCOL_NON_IGNORABLE;
2859 else if (strcmp(
value,
"lower") == 0)
2860 uvalue = UCOL_LOWER_FIRST;
2861 else if (strcmp(
value,
"upper") == 0)
2862 uvalue = UCOL_UPPER_FIRST;
2865 *status = U_ILLEGAL_ARGUMENT_ERROR;
2869 ucol_setAttribute(collator, uattr, uvalue, status);
2893 const bool strict =
true;
2901 langtag =
palloc(buflen);
2904 status = U_ZERO_ERROR;
2905 uloc_toLanguageTag(loc_str, langtag, buflen, strict, &status);
2908 if ((status == U_BUFFER_OVERFLOW_ERROR ||
2909 status == U_STRING_NOT_TERMINATED_WARNING) &&
2913 langtag =
repalloc(langtag, buflen);
2920 if (U_FAILURE(status))
2926 (
errmsg(
"could not convert locale name \"%s\" to language tag: %s",
2927 loc_str, u_errorName(status))));
2934 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2935 errmsg(
"ICU is not supported in this build")));
2947 UCollator *collator;
2949 char lang[ULOC_LANG_CAPACITY];
2962 status = U_ZERO_ERROR;
2963 uloc_getLanguage(loc_str, lang, ULOC_LANG_CAPACITY, &status);
2964 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
2967 (
errmsg(
"could not get language from ICU locale \"%s\": %s",
2968 loc_str, u_errorName(status)),
2969 errhint(
"To disable ICU locale validation, set the parameter %s to \"%s\".",
2970 "icu_validation_level",
"disabled")));
2975 if (strcmp(lang,
"") == 0 ||
2976 strcmp(lang,
"root") == 0 || strcmp(lang,
"und") == 0)
2980 for (int32_t
i = 0; !found &&
i < uloc_countAvailable();
i++)
2982 const char *otherloc = uloc_getAvailable(
i);
2983 char otherlang[ULOC_LANG_CAPACITY];
2985 status = U_ZERO_ERROR;
2986 uloc_getLanguage(otherloc, otherlang, ULOC_LANG_CAPACITY, &status);
2987 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
2990 if (strcmp(lang, otherlang) == 0)
2996 (
errmsg(
"ICU locale \"%s\" has unknown language \"%s\"",
2998 errhint(
"To disable ICU locale validation, set the parameter %s to \"%s\".",
2999 "icu_validation_level",
"disabled")));
3002 collator = pg_ucol_open(loc_str);
3003 ucol_close(collator);
3007 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3008 errmsg(
"ICU is not supported in this build")));
3043 result = WideCharToMultiByte(CP_UTF8, 0, from, -1, to, tolen,
3060 result = wcstombs(to, from, tolen);
3081 char2wchar(
wchar_t *to,
size_t tolen,
const char *from,
size_t fromlen,
3100 result = MultiByteToWideChar(CP_UTF8, 0, from, fromlen, to, tolen - 1);
3122 result = mbstowcs(to,
str, tolen);
3146 (
errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
3147 errmsg(
"invalid multibyte character for locale"),
3148 errhint(
"The server's LC_CTYPE locale is probably incompatible with the database encoding.")));
#define TextDatumGetCString(d)
#define pg_attribute_unused()
#define OidIsValid(objectId)
static void PGresult * res
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
const char * get_encoding_name_for_icu(int encoding)
#define palloc_array(type, count)
#define HeapTupleIsValid(tuple)
Assert(fmt[strlen(fmt) - 1] !='\n')
char * get_namespace_name(Oid nspid)
char * pg_any_to_server(const char *s, int len, int encoding)
int GetDatabaseEncoding(void)
int pg_mbstrlen(const char *mbstr)
bool pg_verifymbstr(const char *mbstr, int len, bool noError)
void SetMessageEncoding(int encoding)
char * pnstrdup(const char *in, Size len)
char * pstrdup(const char *in)
void pfree(void *pointer)
MemoryContext TopMemoryContext
void * repalloc(void *pointer, Size size)
void * MemoryContextAlloc(MemoryContext context, Size size)
char * MemoryContextStrdup(MemoryContext context, const char *string)
FormData_pg_collation * Form_pg_collation
size_t pg_strnxfrm(char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static size_t pg_strxfrm_libc(char *dest, const char *src, size_t destsize, pg_locale_t locale)
void cache_locale_time(void)
bool pg_strxfrm_enabled(pg_locale_t locale)
char * localized_full_months[12+1]
size_t wchar2char(char *to, const wchar_t *from, size_t tolen, pg_locale_t locale)
struct lconv * PGLC_localeconv(void)
int pg_strncoll(const char *arg1, size_t len1, const char *arg2, size_t len2, pg_locale_t locale)
void make_icu_collator(const char *iculocstr, const char *icurules, struct pg_locale_struct *resultp)
bool lc_collate_is_c(Oid collation)
struct pg_locale_struct default_locale
void icu_validate_locale(const char *loc_str)
static bool CurrentLCTimeValid
void assign_locale_time(const char *newval, void *extra)
bool check_locale_time(char **newval, void **extra, GucSource source)
pg_locale_t pg_newlocale_from_collation(Oid collid)
int builtin_locale_encoding(const char *locale)
#define PGLOCALE_SUPPORT_ERROR(provider)
static void cache_single_string(char **dst, const char *src, int encoding)
bool lc_ctype_is_c(Oid collation)
bool check_locale_numeric(char **newval, void **extra, GucSource source)
bool pg_locale_deterministic(pg_locale_t locale)
static void db_encoding_convert(int encoding, char **str)
static size_t wcstombs_l(char *dest, const wchar_t *src, size_t n, locale_t loc)
void assign_locale_numeric(const char *newval, void *extra)
bool check_locale_messages(char **newval, void **extra, GucSource source)
char * get_collation_actual_version(char collprovider, const char *collcollate)
static void free_struct_lconv(struct lconv *s)
char * pg_perm_setlocale(int category, const char *locale)
void assign_locale_messages(const char *newval, void *extra)
static bool CurrentLocaleConvValid
char * icu_language_tag(const char *loc_str, int elevel)
int pg_strcoll(const char *arg1, const char *arg2, pg_locale_t locale)
static int pg_strcoll_libc(const char *arg1, const char *arg2, pg_locale_t locale)
static HTAB * collation_cache
bool pg_strxfrm_prefix_enabled(pg_locale_t locale)
static void report_newlocale_failure(const char *localename)
char * localized_abbrev_months[12+1]
static int pg_strncoll_libc(const char *arg1, size_t len1, const char *arg2, size_t len2, pg_locale_t locale)
size_t pg_strnxfrm_prefix(char *dest, size_t destsize, const char *src, size_t srclen, pg_locale_t locale)
static bool struct_lconv_is_valid(struct lconv *s)
char * localized_full_days[7+1]
size_t pg_strxfrm(char *dest, const char *src, size_t destsize, pg_locale_t locale)
const char * builtin_validate_locale(int encoding, const char *locale)
static collation_cache_entry * lookup_collation_cache(Oid collation, bool set_flags)
void assign_locale_monetary(const char *newval, void *extra)
bool check_locale(int category, const char *locale, char **canonname)
char * localized_abbrev_days[7+1]
size_t pg_strxfrm_prefix(char *dest, const char *src, size_t destsize, pg_locale_t locale)
size_t char2wchar(wchar_t *to, size_t tolen, const char *from, size_t fromlen, pg_locale_t locale)
bool check_locale_monetary(char **newval, void **extra, GucSource source)
static size_t mbstowcs_l(wchar_t *dest, const char *src, size_t n, locale_t loc)
static size_t pg_strnxfrm_libc(char *dest, const char *src, size_t srclen, size_t destsize, pg_locale_t locale)
#define LOCALE_NAME_BUFLEN
static rewind_source * source
#define pg_encoding_to_char
int pg_strcasecmp(const char *s1, const char *s2)
int pg_get_encoding_from_locale(const char *ctype, bool write_message)
size_t strlcpy(char *dst, const char *src, size_t siz)
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
static Datum ObjectIdGetDatum(Oid X)
char * psprintf(const char *fmt,...)
char * quote_qualified_identifier(const char *qualifier, const char *ident)
struct pg_locale_struct::@146::@147 builtin
union pg_locale_struct::@146 info
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)