72 #include <unicode/ucnv.h>
73 #include <unicode/ustring.h>
77 #include <gnu/libc-version.h>
88 #define TEXTBUFLEN 1024
90 #define MAX_L10N_DATA 80
134 #if defined(WIN32) && defined(LC_MESSAGES)
135 static char *IsoLocaleName(
const char *);
144 static UConverter *icu_converter = NULL;
146 static UCollator *pg_ucol_open(
const char *loc_str);
147 static void init_icu_converter(
void);
148 static size_t uchar_length(UConverter *converter,
149 const char *
str, int32_t
len);
150 static int32_t uchar_convert(UConverter *converter,
151 UChar *
dest, int32_t destlen,
152 const char *
str, int32_t srclen);
153 static void icu_set_collation_attributes(UCollator *collator,
const char *loc,
188 if (category == LC_MESSAGES)
209 if (category == LC_CTYPE)
214 strlcpy(save_lc_ctype, result,
sizeof(save_lc_ctype));
215 result = save_lc_ctype;
227 envvar =
"LC_COLLATE";
234 envvar =
"LC_MESSAGES";
236 result = IsoLocaleName(
locale);
239 elog(
DEBUG3,
"IsoLocaleName() executed; locale: \"%s\"", result);
244 envvar =
"LC_MONETARY";
247 envvar =
"LC_NUMERIC";
253 elog(
FATAL,
"unrecognized LC category: %d", category);
257 if (
setenv(envvar, result, 1) != 0)
294 if (
res && canonname)
299 elog(
WARNING,
"failed to restore old locale \"%s\"", save);
302 return (
res != NULL);
379 #if defined(LC_MESSAGES) && !defined(WIN32)
406 free(s->decimal_point);
407 free(s->thousands_sep);
409 free(s->int_curr_symbol);
410 free(s->currency_symbol);
411 free(s->mon_decimal_point);
412 free(s->mon_thousands_sep);
413 free(s->mon_grouping);
414 free(s->positive_sign);
415 free(s->negative_sign);
425 if (s->decimal_point == NULL)
427 if (s->thousands_sep == NULL)
429 if (s->grouping == NULL)
431 if (s->int_curr_symbol == NULL)
433 if (s->currency_symbol == NULL)
435 if (s->mon_decimal_point == NULL)
437 if (s->mon_thousands_sep == NULL)
439 if (s->mon_grouping == NULL)
441 if (s->positive_sign == NULL)
443 if (s->negative_sign == NULL)
468 (
errcode(ERRCODE_OUT_OF_MEMORY),
469 errmsg(
"out of memory")));
486 static struct lconv CurrentLocaleConv;
487 static bool CurrentLocaleConvAllocated =
false;
488 struct lconv *extlconv;
489 struct lconv worklconv;
490 char *save_lc_monetary;
491 char *save_lc_numeric;
498 return &CurrentLocaleConv;
501 if (CurrentLocaleConvAllocated)
504 CurrentLocaleConvAllocated =
false;
519 memset(&worklconv, 0,
sizeof(worklconv));
522 save_lc_monetary =
setlocale(LC_MONETARY, NULL);
523 if (!save_lc_monetary)
525 save_lc_monetary =
pstrdup(save_lc_monetary);
527 save_lc_numeric =
setlocale(LC_NUMERIC, NULL);
528 if (!save_lc_numeric)
530 save_lc_numeric =
pstrdup(save_lc_numeric);
549 save_lc_ctype =
setlocale(LC_CTYPE, NULL);
552 save_lc_ctype =
pstrdup(save_lc_ctype);
562 extlconv = localeconv();
565 worklconv.decimal_point = strdup(extlconv->decimal_point);
566 worklconv.thousands_sep = strdup(extlconv->thousands_sep);
567 worklconv.grouping = strdup(extlconv->grouping);
576 extlconv = localeconv();
579 worklconv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
580 worklconv.currency_symbol = strdup(extlconv->currency_symbol);
581 worklconv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
582 worklconv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
583 worklconv.mon_grouping = strdup(extlconv->mon_grouping);
584 worklconv.positive_sign = strdup(extlconv->positive_sign);
585 worklconv.negative_sign = strdup(extlconv->negative_sign);
587 worklconv.int_frac_digits = extlconv->int_frac_digits;
588 worklconv.frac_digits = extlconv->frac_digits;
589 worklconv.p_cs_precedes = extlconv->p_cs_precedes;
590 worklconv.p_sep_by_space = extlconv->p_sep_by_space;
591 worklconv.n_cs_precedes = extlconv->n_cs_precedes;
592 worklconv.n_sep_by_space = extlconv->n_sep_by_space;
593 worklconv.p_sign_posn = extlconv->p_sign_posn;
594 worklconv.n_sign_posn = extlconv->n_sign_posn;
606 elog(
FATAL,
"failed to restore LC_CTYPE to \"%s\"", save_lc_ctype);
608 if (!
setlocale(LC_MONETARY, save_lc_monetary))
609 elog(
FATAL,
"failed to restore LC_MONETARY to \"%s\"", save_lc_monetary);
610 if (!
setlocale(LC_NUMERIC, save_lc_numeric))
611 elog(
FATAL,
"failed to restore LC_NUMERIC to \"%s\"", save_lc_numeric);
623 pfree(save_lc_monetary);
624 pfree(save_lc_numeric);
626 pfree(save_lc_ctype);
632 (
errcode(ERRCODE_OUT_OF_MEMORY),
633 errmsg(
"out of memory")));
672 CurrentLocaleConv = worklconv;
673 CurrentLocaleConvAllocated =
true;
675 return &CurrentLocaleConv;
695 strftime_win32(
char *dst,
size_t dstlen,
706 len = MultiByteToWideChar(CP_UTF8, 0,
format, -1,
709 elog(
ERROR,
"could not convert format string from UTF-8: error code %lu",
722 len = WideCharToMultiByte(CP_UTF8, 0, wbuf,
len, dst, dstlen - 1,
725 elog(
ERROR,
"could not convert string to UTF-8: error code %lu",
734 #define strftime(a,b,c,d) strftime_win32(a,b,c,d)
772 bool strftimefail =
false;
797 save_lc_time =
pstrdup(save_lc_time);
809 save_lc_ctype =
setlocale(LC_CTYPE, NULL);
812 save_lc_ctype =
pstrdup(save_lc_ctype);
821 timenow = time(NULL);
822 timeinfo = localtime(&timenow);
838 for (
i = 0;
i < 7;
i++)
840 timeinfo->tm_wday =
i;
850 for (
i = 0;
i < 12;
i++)
852 timeinfo->tm_mon =
i;
853 timeinfo->tm_mday = 1;
868 elog(
FATAL,
"failed to restore LC_CTYPE to \"%s\"", save_lc_ctype);
871 elog(
FATAL,
"failed to restore LC_TIME to \"%s\"", save_lc_time);
883 pfree(save_lc_ctype);
910 for (
i = 0;
i < 7;
i++)
921 for (
i = 0;
i < 12;
i++)
935 #if defined(WIN32) && defined(LC_MESSAGES)
982 #if defined(_MSC_VER)
997 search_locale_enum(LPWSTR pStr, DWORD dwFlags, LPARAM lparam)
999 wchar_t test_locale[LOCALE_NAME_MAX_LENGTH];
1004 argv = (
wchar_t **) lparam;
1005 *argv[2] = (wchar_t) 0;
1007 memset(test_locale, 0,
sizeof(test_locale));
1010 if (GetLocaleInfoEx(pStr, LOCALE_SENGLISHLANGUAGENAME,
1011 test_locale, LOCALE_NAME_MAX_LENGTH))
1018 if (wcsrchr(pStr,
'-') == NULL || wcsrchr(argv[0],
'_') == NULL)
1020 if (_wcsicmp(argv[0], test_locale) == 0)
1022 wcscpy(argv[1], pStr);
1023 *argv[2] = (wchar_t) 1;
1037 wcscat(test_locale, L
"_");
1038 len = wcslen(test_locale);
1039 if (GetLocaleInfoEx(pStr, LOCALE_SENGLISHCOUNTRYNAME,
1041 LOCALE_NAME_MAX_LENGTH -
len))
1043 if (_wcsicmp(argv[0], test_locale) == 0)
1045 wcscpy(argv[1], pStr);
1046 *argv[2] = (wchar_t) 1;
1063 get_iso_localename(
const char *winlocname)
1065 wchar_t wc_locale_name[LOCALE_NAME_MAX_LENGTH];
1066 wchar_t buffer[LOCALE_NAME_MAX_LENGTH];
1067 static char iso_lc_messages[LOCALE_NAME_MAX_LENGTH];
1079 period = strchr(winlocname,
'.');
1085 memset(wc_locale_name, 0,
sizeof(wc_locale_name));
1086 memset(buffer, 0,
sizeof(buffer));
1087 MultiByteToWideChar(CP_ACP, 0, winlocname,
len, wc_locale_name,
1088 LOCALE_NAME_MAX_LENGTH);
1094 ret_val = GetLocaleInfoEx(wc_locale_name, LOCALE_SNAME, (LPWSTR) &buffer,
1095 LOCALE_NAME_MAX_LENGTH);
1104 argv[0] = wc_locale_name;
1106 argv[2] = (
wchar_t *) &ret_val;
1107 EnumSystemLocalesEx(search_locale_enum, LOCALE_WINDOWS, (LPARAM) argv,
1117 rc =
wchar2char(iso_lc_messages, buffer,
sizeof(iso_lc_messages), NULL);
1118 if (rc == -1 || rc ==
sizeof(iso_lc_messages))
1128 hyphen = strchr(iso_lc_messages,
'-');
1131 return iso_lc_messages;
1138 IsoLocaleName(
const char *winlocname)
1140 static char iso_lc_messages[LOCALE_NAME_MAX_LENGTH];
1145 strcpy(iso_lc_messages,
"C");
1146 return iso_lc_messages;
1149 return get_iso_localename(winlocname);
1155 IsoLocaleName(
const char *winlocname)
1181 const int canary = 0x7F;
1195 (void) strxfrm(
buf,
"ab", 7);
1196 if (
buf[7] != canary)
1210 (void) strxfrm(
buf,
"a", 1);
1211 if (
buf[1] != canary)
1216 (
errcode(ERRCODE_SYSTEM_ERROR),
1217 errmsg_internal(
"strxfrm(), in locale \"%s\", writes past the specified array length",
1219 errhint(
"Apply system library package updates.")));
1254 Assert(collation != DEFAULT_COLLATION_OID);
1286 elog(
ERROR,
"cache lookup failed for collation %u", collation);
1289 if (collform->collprovider == COLLPROVIDER_LIBC)
1292 const char *collcollate;
1293 const char *collctype;
1300 cache_entry->
collate_is_c = ((strcmp(collcollate,
"C") == 0) ||
1301 (strcmp(collcollate,
"POSIX") == 0));
1302 cache_entry->
ctype_is_c = ((strcmp(collctype,
"C") == 0) ||
1303 (strcmp(collctype,
"POSIX") == 0));
1337 if (collation == DEFAULT_COLLATION_OID)
1339 static int result = -1;
1346 return (
bool) result;
1347 localeptr =
setlocale(LC_COLLATE, NULL);
1349 elog(
ERROR,
"invalid LC_COLLATE setting");
1351 if (strcmp(localeptr,
"C") == 0)
1353 else if (strcmp(localeptr,
"POSIX") == 0)
1357 return (
bool) result;
1363 if (collation == C_COLLATION_OID ||
1364 collation == POSIX_COLLATION_OID)
1390 if (collation == DEFAULT_COLLATION_OID)
1392 static int result = -1;
1399 return (
bool) result;
1402 elog(
ERROR,
"invalid LC_CTYPE setting");
1404 if (strcmp(localeptr,
"C") == 0)
1406 else if (strcmp(localeptr,
"POSIX") == 0)
1410 return (
bool) result;
1416 if (collation == C_COLLATION_OID ||
1417 collation == POSIX_COLLATION_OID)
1430 const char *icurules,
1434 UCollator *collator;
1436 collator = pg_ucol_open(iculocstr);
1444 const UChar *default_rules;
1450 default_rules = ucol_getRules(collator, &length);
1451 icu_to_uchar(&my_rules, icurules, strlen(icurules));
1453 agg_rules =
palloc_array(UChar, u_strlen(default_rules) + u_strlen(my_rules) + 1);
1454 u_strcpy(agg_rules, default_rules);
1455 u_strcat(agg_rules, my_rules);
1457 ucol_close(collator);
1459 status = U_ZERO_ERROR;
1460 collator = ucol_openRules(agg_rules, u_strlen(agg_rules),
1461 UCOL_DEFAULT, UCOL_DEFAULT_STRENGTH, NULL, &status);
1462 if (U_FAILURE(status))
1464 (
errmsg(
"could not open collator for locale \"%s\" with rules \"%s\": %s",
1465 iculocstr, icurules, u_errorName(status))));
1470 resultp->
info.icu.ucol = collator;
1474 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1475 errmsg(
"ICU is not supported in this build")));
1481 #ifdef HAVE_LOCALE_T
1483 report_newlocale_failure(
const char *localename)
1503 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1504 errmsg(
"could not create locale \"%s\": %m",
1506 (save_errno == ENOENT ?
1507 errdetail(
"The operating system could not find any locale data for the locale name \"%s\".",
1519 return locale->deterministic;
1544 if (
collid == DEFAULT_COLLATION_OID)
1554 if (cache_entry->
locale == 0)
1570 memset(&result, 0,
sizeof(result));
1571 result.
provider = collform->collprovider;
1574 if (collform->collprovider == COLLPROVIDER_LIBC)
1576 #ifdef HAVE_LOCALE_T
1577 const char *collcollate;
1586 if (strcmp(collcollate, collctype) == 0)
1591 loc = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collcollate,
1594 loc = _create_locale(LC_ALL, collcollate);
1597 report_newlocale_failure(collcollate);
1606 loc1 = newlocale(LC_COLLATE_MASK, collcollate, NULL);
1608 report_newlocale_failure(collcollate);
1610 loc = newlocale(LC_CTYPE_MASK, collctype, loc1);
1612 report_newlocale_failure(collctype);
1621 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1622 errmsg(
"collations with different collate and ctype values are not supported on this platform")));
1626 result.
info.lt = loc;
1630 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1631 errmsg(
"collation provider LIBC is not supported on this platform")));
1634 else if (collform->collprovider == COLLPROVIDER_ICU)
1636 const char *iculocstr;
1637 const char *icurules;
1655 char *actual_versionstr;
1656 char *collversionstr;
1660 datum =
SysCacheGetAttrNotNull(
COLLOID, tp, collform->collprovider == COLLPROVIDER_ICU ? Anum_pg_collation_colliculocale : Anum_pg_collation_collcollate);
1664 if (!actual_versionstr)
1672 (
errmsg(
"collation \"%s\" has no actual version, but a version was recorded",
1673 NameStr(collform->collname))));
1676 if (strcmp(actual_versionstr, collversionstr) != 0)
1678 (
errmsg(
"collation \"%s\" has version mismatch",
1680 errdetail(
"The collation in the database was created using version %s, "
1681 "but the operating system provides version %s.",
1682 collversionstr, actual_versionstr),
1683 errhint(
"Rebuild all objects affected by this collation and run "
1684 "ALTER COLLATION %s REFRESH VERSION, "
1685 "or build PostgreSQL with the right library version.",
1687 NameStr(collform->collname)))));
1696 cache_entry->
locale = resultp;
1699 return cache_entry->
locale;
1709 char *collversion = NULL;
1712 if (collprovider == COLLPROVIDER_ICU)
1714 UCollator *collator;
1715 UVersionInfo versioninfo;
1716 char buf[U_MAX_VERSION_STRING_LENGTH];
1718 collator = pg_ucol_open(collcollate);
1720 ucol_getVersion(collator, versioninfo);
1721 ucol_close(collator);
1723 u_versionToString(versioninfo,
buf);
1728 if (collprovider == COLLPROVIDER_LIBC &&
1733 #if defined(__GLIBC__)
1735 collversion =
pstrdup(gnu_get_libc_version());
1736 #elif defined(LC_VERSION_MASK)
1740 loc = newlocale(LC_COLLATE, collcollate, NULL);
1744 pstrdup(querylocale(LC_COLLATE_MASK | LC_VERSION_MASK, loc));
1749 (
errmsg(
"could not load locale \"%s\"", collcollate)));
1750 #elif defined(WIN32)
1756 NLSVERSIONINFOEX version = {
sizeof(NLSVERSIONINFOEX)};
1757 WCHAR wide_collcollate[LOCALE_NAME_MAX_LENGTH];
1759 MultiByteToWideChar(CP_ACP, 0, collcollate, -1, wide_collcollate,
1760 LOCALE_NAME_MAX_LENGTH);
1761 if (!GetNLSVersionEx(COMPARE_STRING, wide_collcollate, &version))
1770 if (GetLastError() == ERROR_INVALID_PARAMETER)
1774 (
errmsg(
"could not get collation version for locale \"%s\": error code %lu",
1778 collversion =
psprintf(
"%lu.%lu,%lu.%lu",
1779 (version.dwNLSVersion >> 8) & 0xFFFF,
1780 version.dwNLSVersion & 0xFF,
1781 (version.dwDefinedVersion >> 8) & 0xFFFF,
1782 version.dwDefinedVersion & 0xFF);
1797 pg_strncoll_libc_win32_utf8(
const char *arg1,
size_t len1,
const char *arg2,
1804 int a1len = len1 * 2 + 2;
1805 int a2len = len2 * 2 + 2;
1826 r = MultiByteToWideChar(CP_UTF8, 0, arg1, len1,
1827 (LPWSTR) a1p, a1len / 2);
1830 (
errmsg(
"could not convert string to UTF-16: error code %lu",
1833 ((LPWSTR) a1p)[r] = 0;
1839 r = MultiByteToWideChar(CP_UTF8, 0, arg2, len2,
1840 (LPWSTR) a2p, a2len / 2);
1843 (
errmsg(
"could not convert string to UTF-16: error code %lu",
1846 ((LPWSTR) a2p)[r] = 0;
1849 #ifdef HAVE_LOCALE_T
1854 result = wcscoll((LPWSTR) a1p, (LPWSTR) a2p);
1855 if (result == 2147483647)
1858 (
errmsg(
"could not compare Unicode strings: %m")));
1885 size_t len1 = strlen(arg1);
1886 size_t len2 = strlen(arg2);
1887 result = pg_strncoll_libc_win32_utf8(arg1, len1, arg2, len2,
locale);
1893 #ifdef HAVE_LOCALE_T
1901 result = strcoll(arg1, arg2);
1917 size_t bufsize1 = len1 + 1;
1918 size_t bufsize2 = len2 + 1;
1928 return pg_strncoll_libc_win32_utf8(arg1, len1, arg2, len2,
locale);
1935 arg2n =
buf + bufsize1;
1938 memcpy(arg1n, arg1, len1);
1940 memcpy(arg2n, arg2, len2);
1964 pg_strncoll_icu_no_utf8(
const char *arg1, int32_t len1,
1978 #ifdef HAVE_UCOL_STRCOLLUTF8
1982 init_icu_converter();
1984 ulen1 = uchar_length(icu_converter, arg1, len1);
1985 ulen2 = uchar_length(icu_converter, arg2, len2);
1987 bufsize1 = (ulen1 + 1) *
sizeof(UChar);
1988 bufsize2 = (ulen2 + 1) *
sizeof(UChar);
1993 uchar1 = (UChar *)
buf;
1994 uchar2 = (UChar *) (
buf + bufsize1);
1996 ulen1 = uchar_convert(icu_converter, uchar1, ulen1 + 1, arg1, len1);
1997 ulen2 = uchar_convert(icu_converter, uchar2, ulen2 + 1, arg2, len2);
1999 result = ucol_strcoll(
locale->info.icu.ucol,
2019 pg_strncoll_icu(
const char *arg1, int32_t len1,
const char *arg2, int32_t len2,
2026 #ifdef HAVE_UCOL_STRCOLLUTF8
2031 status = U_ZERO_ERROR;
2032 result = ucol_strcollUTF8(
locale->info.icu.ucol,
2036 if (U_FAILURE(status))
2038 (
errmsg(
"collation failed: %s", u_errorName(status))));
2043 result = pg_strncoll_icu_no_utf8(arg1, len1, arg2, len2,
locale);
2072 else if (
locale->provider == COLLPROVIDER_ICU)
2073 result = pg_strncoll_icu(arg1, -1, arg2, -1,
locale);
2100 pg_strncoll(
const char *arg1,
size_t len1,
const char *arg2,
size_t len2,
2108 else if (
locale->provider == COLLPROVIDER_ICU)
2109 result = pg_strncoll_icu(arg1, len1, arg2, len2,
locale);
2125 #ifdef TRUST_STRXFRM
2126 #ifdef HAVE_LOCALE_T
2131 return strxfrm(
dest, src, destsize);
2154 memcpy(
buf, src, srclen);
2163 Assert(result >= destsize ||
dest[result] ==
'\0');
2172 pg_strnxfrm_icu(
char *
dest,
const char *src, int32_t srclen, int32_t destsize,
2184 init_icu_converter();
2186 ulen = uchar_length(icu_converter, src, srclen);
2188 uchar_bsize = (ulen + 1) *
sizeof(UChar);
2193 uchar = (UChar *)
buf;
2195 ulen = uchar_convert(icu_converter, uchar, ulen + 1, src, srclen);
2197 result_bsize = ucol_getSortKey(
locale->info.icu.ucol,
2199 (uint8_t *)
dest, destsize);
2205 Assert(result_bsize > 0);
2212 Assert(result_bsize >= destsize ||
dest[result_bsize] ==
'\0');
2214 return result_bsize;
2219 pg_strnxfrm_prefix_icu_no_utf8(
char *
dest,
const char *src, int32_t srclen,
2228 UChar *uchar = NULL;
2235 init_icu_converter();
2237 ulen = uchar_length(icu_converter, src, srclen);
2239 uchar_bsize = (ulen + 1) *
sizeof(UChar);
2244 uchar = (UChar *)
buf;
2246 ulen = uchar_convert(icu_converter, uchar, ulen + 1, src, srclen);
2248 uiter_setString(&iter, uchar, ulen);
2250 status = U_ZERO_ERROR;
2251 result_bsize = ucol_nextSortKeyPart(
locale->info.icu.ucol,
2257 if (U_FAILURE(status))
2259 (
errmsg(
"sort key generation failed: %s",
2260 u_errorName(status))));
2262 return result_bsize;
2267 pg_strnxfrm_prefix_icu(
char *
dest,
const char *src, int32_t srclen,
2280 uiter_setUTF8(&iter, src, srclen);
2282 status = U_ZERO_ERROR;
2283 result = ucol_nextSortKeyPart(
locale->info.icu.ucol,
2289 if (U_FAILURE(status))
2291 (
errmsg(
"sort key generation failed: %s",
2292 u_errorName(status))));
2295 result = pg_strnxfrm_prefix_icu_no_utf8(
dest, src, srclen, destsize,
2321 #ifdef TRUST_STRXFRM
2326 else if (
locale->provider == COLLPROVIDER_ICU)
2357 else if (
locale->provider == COLLPROVIDER_ICU)
2358 result = pg_strnxfrm_icu(
dest, src, -1, destsize,
locale);
2394 else if (
locale->provider == COLLPROVIDER_ICU)
2395 result = pg_strnxfrm_icu(
dest, src, srclen, destsize,
locale);
2413 else if (
locale->provider == COLLPROVIDER_ICU)
2442 elog(
ERROR,
"collprovider '%c' does not support pg_strxfrm_prefix()",
2445 else if (
locale->provider == COLLPROVIDER_ICU)
2446 result = pg_strnxfrm_prefix_icu(
dest, src, -1, destsize,
locale);
2479 elog(
ERROR,
"collprovider '%c' does not support pg_strnxfrm_prefix()",
2482 else if (
locale->provider == COLLPROVIDER_ICU)
2483 result = pg_strnxfrm_prefix_icu(
dest, src, -1, destsize,
locale);
2499 pg_ucol_open(
const char *loc_str)
2501 UCollator *collator;
2503 const char *orig_str = loc_str;
2504 char *fixed_str = NULL;
2515 if (loc_str == NULL)
2516 elog(
ERROR,
"opening default collator is not supported");
2523 if (U_ICU_VERSION_MAJOR_NUM < 55)
2525 char lang[ULOC_LANG_CAPACITY];
2527 status = U_ZERO_ERROR;
2528 uloc_getLanguage(loc_str, lang, ULOC_LANG_CAPACITY, &status);
2529 if (U_FAILURE(status))
2532 (
errmsg(
"could not get language from locale \"%s\": %s",
2533 loc_str, u_errorName(status))));
2536 if (strcmp(lang,
"und") == 0)
2538 const char *remainder = loc_str + strlen(
"und");
2540 fixed_str =
palloc(strlen(
"root") + strlen(remainder) + 1);
2541 strcpy(fixed_str,
"root");
2542 strcat(fixed_str, remainder);
2544 loc_str = fixed_str;
2548 status = U_ZERO_ERROR;
2549 collator = ucol_open(loc_str, &status);
2550 if (U_FAILURE(status))
2553 (
errmsg(
"could not open collator for locale \"%s\": %s",
2554 orig_str, u_errorName(status))));
2556 if (U_ICU_VERSION_MAJOR_NUM < 54)
2558 status = U_ZERO_ERROR;
2559 icu_set_collation_attributes(collator, loc_str, &status);
2565 if (U_FAILURE(status))
2567 ucol_close(collator);
2569 (
errmsg(
"could not open collator for locale \"%s\": %s",
2570 orig_str, u_errorName(status))));
2574 if (fixed_str != NULL)
2581 init_icu_converter(
void)
2583 const char *icu_encoding_name;
2591 if (!icu_encoding_name)
2593 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2594 errmsg(
"encoding \"%s\" not supported by ICU",
2597 status = U_ZERO_ERROR;
2598 conv = ucnv_open(icu_encoding_name, &status);
2599 if (U_FAILURE(status))
2601 (
errmsg(
"could not open ICU converter for encoding \"%s\": %s",
2602 icu_encoding_name, u_errorName(status))));
2604 icu_converter = conv;
2611 uchar_length(UConverter *converter,
const char *
str, int32_t
len)
2613 UErrorCode status = U_ZERO_ERROR;
2615 ulen = ucnv_toUChars(converter, NULL, 0,
str,
len, &status);
2616 if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
2618 (
errmsg(
"%s failed: %s",
"ucnv_toUChars", u_errorName(status))));
2627 uchar_convert(UConverter *converter, UChar *
dest, int32_t destlen,
2628 const char *src, int32_t srclen)
2630 UErrorCode status = U_ZERO_ERROR;
2632 status = U_ZERO_ERROR;
2633 ulen = ucnv_toUChars(converter,
dest, destlen, src, srclen, &status);
2634 if (U_FAILURE(status))
2636 (
errmsg(
"%s failed: %s",
"ucnv_toUChars", u_errorName(status))));
2653 icu_to_uchar(UChar **buff_uchar,
const char *buff,
size_t nbytes)
2657 init_icu_converter();
2659 len_uchar = uchar_length(icu_converter, buff, nbytes);
2661 *buff_uchar =
palloc((len_uchar + 1) *
sizeof(**buff_uchar));
2662 len_uchar = uchar_convert(icu_converter,
2663 *buff_uchar, len_uchar + 1, buff, nbytes);
2680 icu_from_uchar(
char **result,
const UChar *buff_uchar, int32_t len_uchar)
2685 init_icu_converter();
2687 status = U_ZERO_ERROR;
2688 len_result = ucnv_fromUChars(icu_converter, NULL, 0,
2689 buff_uchar, len_uchar, &status);
2690 if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
2692 (
errmsg(
"%s failed: %s",
"ucnv_fromUChars",
2693 u_errorName(status))));
2695 *result =
palloc(len_result + 1);
2697 status = U_ZERO_ERROR;
2698 len_result = ucnv_fromUChars(icu_converter, *result, len_result + 1,
2699 buff_uchar, len_uchar, &status);
2700 if (U_FAILURE(status))
2702 (
errmsg(
"%s failed: %s",
"ucnv_fromUChars",
2703 u_errorName(status))));
2722 icu_set_collation_attributes(UCollator *collator, const
char *loc,
2726 char *icu_locale_id;
2737 *status = U_ZERO_ERROR;
2738 len = uloc_canonicalize(loc, NULL, 0, status);
2740 *status = U_ZERO_ERROR;
2741 len = uloc_canonicalize(loc, icu_locale_id,
len + 1, status);
2742 if (U_FAILURE(*status))
2745 lower_str =
asc_tolower(icu_locale_id, strlen(icu_locale_id));
2747 pfree(icu_locale_id);
2749 str = strchr(lower_str,
'@');
2756 char *
e = strchr(
token,
'=');
2762 UColAttribute uattr;
2763 UColAttributeValue uvalue;
2765 *status = U_ZERO_ERROR;
2774 if (strcmp(
name,
"colstrength") == 0)
2775 uattr = UCOL_STRENGTH;
2776 else if (strcmp(
name,
"colbackwards") == 0)
2777 uattr = UCOL_FRENCH_COLLATION;
2778 else if (strcmp(
name,
"colcaselevel") == 0)
2779 uattr = UCOL_CASE_LEVEL;
2780 else if (strcmp(
name,
"colcasefirst") == 0)
2781 uattr = UCOL_CASE_FIRST;
2782 else if (strcmp(
name,
"colalternate") == 0)
2783 uattr = UCOL_ALTERNATE_HANDLING;
2784 else if (strcmp(
name,
"colnormalization") == 0)
2785 uattr = UCOL_NORMALIZATION_MODE;
2786 else if (strcmp(
name,
"colnumeric") == 0)
2787 uattr = UCOL_NUMERIC_COLLATION;
2792 if (strcmp(
value,
"primary") == 0)
2793 uvalue = UCOL_PRIMARY;
2794 else if (strcmp(
value,
"secondary") == 0)
2795 uvalue = UCOL_SECONDARY;
2796 else if (strcmp(
value,
"tertiary") == 0)
2797 uvalue = UCOL_TERTIARY;
2798 else if (strcmp(
value,
"quaternary") == 0)
2799 uvalue = UCOL_QUATERNARY;
2800 else if (strcmp(
value,
"identical") == 0)
2801 uvalue = UCOL_IDENTICAL;
2802 else if (strcmp(
value,
"no") == 0)
2804 else if (strcmp(
value,
"yes") == 0)
2806 else if (strcmp(
value,
"shifted") == 0)
2807 uvalue = UCOL_SHIFTED;
2808 else if (strcmp(
value,
"non-ignorable") == 0)
2809 uvalue = UCOL_NON_IGNORABLE;
2810 else if (strcmp(
value,
"lower") == 0)
2811 uvalue = UCOL_LOWER_FIRST;
2812 else if (strcmp(
value,
"upper") == 0)
2813 uvalue = UCOL_UPPER_FIRST;
2816 *status = U_ILLEGAL_ARGUMENT_ERROR;
2820 ucol_setAttribute(collator, uattr, uvalue, status);
2836 UCollator *collator;
2838 char lang[ULOC_LANG_CAPACITY];
2851 status = U_ZERO_ERROR;
2852 uloc_getLanguage(loc_str, lang, ULOC_LANG_CAPACITY, &status);
2853 if (U_FAILURE(status))
2856 (
errmsg(
"could not get language from ICU locale \"%s\": %s",
2857 loc_str, u_errorName(status)),
2858 errhint(
"To disable ICU locale validation, set parameter icu_validation_level to DISABLED.")));
2863 if (strcmp(lang,
"") == 0 ||
2864 strcmp(lang,
"root") == 0 || strcmp(lang,
"und") == 0 ||
2865 strcmp(lang,
"c") == 0 || strcmp(lang,
"posix") == 0)
2869 for (int32_t
i = 0; !found &&
i < uloc_countAvailable();
i++)
2871 const char *otherloc = uloc_getAvailable(
i);
2872 char otherlang[ULOC_LANG_CAPACITY];
2874 status = U_ZERO_ERROR;
2875 uloc_getLanguage(otherloc, otherlang, ULOC_LANG_CAPACITY, &status);
2876 if (U_FAILURE(status))
2879 if (strcmp(lang, otherlang) == 0)
2885 (
errmsg(
"ICU locale \"%s\" has unknown language \"%s\"",
2887 errhint(
"To disable ICU locale validation, set parameter icu_validation_level to DISABLED.")));
2890 collator = pg_ucol_open(loc_str);
2891 ucol_close(collator);
2895 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2896 errmsg(
"ICU is not supported in this build")));
2931 result = WideCharToMultiByte(CP_UTF8, 0, from, -1, to, tolen,
2948 result = wcstombs(to, from, tolen);
2952 #ifdef HAVE_LOCALE_T
2953 #ifdef HAVE_WCSTOMBS_L
2960 result = wcstombs(to, from, tolen);
2962 uselocale(save_locale);
2966 elog(
ERROR,
"wcstombs_l is not available");
2984 char2wchar(
wchar_t *to,
size_t tolen,
const char *from,
size_t fromlen,
3003 result = MultiByteToWideChar(CP_UTF8, 0, from, fromlen, to, tolen - 1);
3025 result = mbstowcs(to,
str, tolen);
3029 #ifdef HAVE_LOCALE_T
3030 #ifdef HAVE_MBSTOWCS_L
3037 result = mbstowcs(to,
str, tolen);
3039 uselocale(save_locale);
3043 elog(
ERROR,
"mbstowcs_l is not available");
3064 (
errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
3065 errmsg(
"invalid multibyte character for locale"),
3066 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
elog(ERROR, "%s: %s", p2, msg)
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 errmsg_internal(const char *fmt,...)
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)
const char * pg_encoding_to_char(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 * 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)
void check_strxfrm_bug(void)
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)
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)
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
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)
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)
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 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
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)
union pg_locale_struct::@142 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)