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);
1243 ctl.keysize =
sizeof(
Oid);
1268 elog(
ERROR,
"cache lookup failed for collation %u", collation);
1271 if (collform->collprovider == COLLPROVIDER_BUILTIN)
1274 const char *colllocale;
1280 cache_entry->
ctype_is_c = (strcmp(colllocale,
"C") == 0);
1282 else if (collform->collprovider == COLLPROVIDER_LIBC)
1285 const char *collcollate;
1286 const char *collctype;
1293 cache_entry->
collate_is_c = ((strcmp(collcollate,
"C") == 0) ||
1294 (strcmp(collcollate,
"POSIX") == 0));
1295 cache_entry->
ctype_is_c = ((strcmp(collctype,
"C") == 0) ||
1296 (strcmp(collctype,
"POSIX") == 0));
1330 if (collation == DEFAULT_COLLATION_OID)
1332 static int result = -1;
1333 const char *localeptr;
1336 return (
bool) result;
1341 return (
bool) result;
1346 return (
bool) result;
1352 elog(
ERROR,
"invalid LC_CTYPE setting");
1355 elog(
ERROR,
"unexpected collation provider '%c'",
1358 if (strcmp(localeptr,
"C") == 0)
1360 else if (strcmp(localeptr,
"POSIX") == 0)
1364 return (
bool) result;
1370 if (collation == C_COLLATION_OID ||
1371 collation == POSIX_COLLATION_OID)
1397 if (collation == DEFAULT_COLLATION_OID)
1399 static int result = -1;
1400 const char *localeptr;
1403 return (
bool) result;
1412 return (
bool) result;
1418 elog(
ERROR,
"invalid LC_CTYPE setting");
1421 elog(
ERROR,
"unexpected collation provider '%c'",
1424 if (strcmp(localeptr,
"C") == 0)
1426 else if (strcmp(localeptr,
"POSIX") == 0)
1430 return (
bool) result;
1436 if (collation == C_COLLATION_OID ||
1437 collation == POSIX_COLLATION_OID)
1450 const char *icurules,
1454 UCollator *collator;
1456 collator = pg_ucol_open(iculocstr);
1464 const UChar *default_rules;
1470 default_rules = ucol_getRules(collator, &length);
1471 icu_to_uchar(&my_rules, icurules, strlen(icurules));
1473 agg_rules =
palloc_array(UChar, u_strlen(default_rules) + u_strlen(my_rules) + 1);
1474 u_strcpy(agg_rules, default_rules);
1475 u_strcat(agg_rules, my_rules);
1477 ucol_close(collator);
1479 status = U_ZERO_ERROR;
1480 collator = ucol_openRules(agg_rules, u_strlen(agg_rules),
1481 UCOL_DEFAULT, UCOL_DEFAULT_STRENGTH, NULL, &status);
1482 if (U_FAILURE(status))
1484 (
errmsg(
"could not open collator for locale \"%s\" with rules \"%s\": %s",
1485 iculocstr, icurules, u_errorName(status))));
1490 resultp->
info.icu.ucol = collator;
1494 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1495 errmsg(
"ICU is not supported in this build")));
1522 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1523 errmsg(
"could not create locale \"%s\": %m",
1525 (save_errno == ENOENT ?
1526 errdetail(
"The operating system could not find any locale data for the locale name \"%s\".",
1537 return locale->deterministic;
1558 if (
collid == DEFAULT_COLLATION_OID)
1568 if (cache_entry->
locale == 0)
1584 memset(&result, 0,
sizeof(result));
1585 result.
provider = collform->collprovider;
1588 if (collform->collprovider == COLLPROVIDER_BUILTIN)
1600 else if (collform->collprovider == COLLPROVIDER_LIBC)
1602 const char *collcollate;
1611 if (strcmp(collcollate, collctype) == 0)
1616 loc = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collcollate,
1619 loc = _create_locale(LC_ALL, collcollate);
1631 loc1 = newlocale(LC_COLLATE_MASK, collcollate, NULL);
1635 loc = newlocale(LC_CTYPE_MASK, collctype, loc1);
1646 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1647 errmsg(
"collations with different collate and ctype values are not supported on this platform")));
1653 else if (collform->collprovider == COLLPROVIDER_ICU)
1655 const char *iculocstr;
1656 const char *icurules;
1661 datum =
SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collicurules, &isnull);
1674 char *actual_versionstr;
1675 char *collversionstr;
1679 if (collform->collprovider == COLLPROVIDER_LIBC)
1686 if (!actual_versionstr)
1694 (
errmsg(
"collation \"%s\" has no actual version, but a version was recorded",
1695 NameStr(collform->collname))));
1698 if (strcmp(actual_versionstr, collversionstr) != 0)
1700 (
errmsg(
"collation \"%s\" has version mismatch",
1702 errdetail(
"The collation in the database was created using version %s, "
1703 "but the operating system provides version %s.",
1704 collversionstr, actual_versionstr),
1705 errhint(
"Rebuild all objects affected by this collation and run "
1706 "ALTER COLLATION %s REFRESH VERSION, "
1707 "or build PostgreSQL with the right library version.",
1709 NameStr(collform->collname)))));
1718 cache_entry->
locale = resultp;
1721 return cache_entry->
locale;
1731 char *collversion = NULL;
1740 if (collprovider == COLLPROVIDER_BUILTIN)
1742 if (strcmp(collcollate,
"C") == 0)
1744 else if (strcmp(collcollate,
"C.UTF-8") == 0)
1748 (
errcode(ERRCODE_WRONG_OBJECT_TYPE),
1749 errmsg(
"invalid locale name \"%s\" for builtin provider",
1754 if (collprovider == COLLPROVIDER_ICU)
1756 UCollator *collator;
1757 UVersionInfo versioninfo;
1758 char buf[U_MAX_VERSION_STRING_LENGTH];
1760 collator = pg_ucol_open(collcollate);
1762 ucol_getVersion(collator, versioninfo);
1763 ucol_close(collator);
1765 u_versionToString(versioninfo,
buf);
1770 if (collprovider == COLLPROVIDER_LIBC &&
1775 #if defined(__GLIBC__)
1777 collversion =
pstrdup(gnu_get_libc_version());
1778 #elif defined(LC_VERSION_MASK)
1782 loc = newlocale(LC_COLLATE, collcollate, NULL);
1786 pstrdup(querylocale(LC_COLLATE_MASK | LC_VERSION_MASK, loc));
1791 (
errmsg(
"could not load locale \"%s\"", collcollate)));
1792 #elif defined(WIN32)
1798 NLSVERSIONINFOEX version = {
sizeof(NLSVERSIONINFOEX)};
1799 WCHAR wide_collcollate[LOCALE_NAME_MAX_LENGTH];
1801 MultiByteToWideChar(CP_ACP, 0, collcollate, -1, wide_collcollate,
1802 LOCALE_NAME_MAX_LENGTH);
1803 if (!GetNLSVersionEx(COMPARE_STRING, wide_collcollate, &version))
1812 if (GetLastError() == ERROR_INVALID_PARAMETER)
1816 (
errmsg(
"could not get collation version for locale \"%s\": error code %lu",
1820 collversion =
psprintf(
"%lu.%lu,%lu.%lu",
1821 (version.dwNLSVersion >> 8) & 0xFFFF,
1822 version.dwNLSVersion & 0xFF,
1823 (version.dwDefinedVersion >> 8) & 0xFFFF,
1824 version.dwDefinedVersion & 0xFF);
1839 pg_strncoll_libc_win32_utf8(
const char *arg1,
size_t len1,
const char *arg2,
1846 int a1len = len1 * 2 + 2;
1847 int a2len = len2 * 2 + 2;
1868 r = MultiByteToWideChar(CP_UTF8, 0, arg1, len1,
1869 (LPWSTR) a1p, a1len / 2);
1872 (
errmsg(
"could not convert string to UTF-16: error code %lu",
1875 ((LPWSTR) a1p)[r] = 0;
1881 r = MultiByteToWideChar(CP_UTF8, 0, arg2, len2,
1882 (LPWSTR) a2p, a2len / 2);
1885 (
errmsg(
"could not convert string to UTF-16: error code %lu",
1888 ((LPWSTR) a2p)[r] = 0;
1894 result = wcscoll((LPWSTR) a1p, (LPWSTR) a2p);
1895 if (result == 2147483647)
1897 (
errmsg(
"could not compare Unicode strings: %m")));
1924 size_t len1 = strlen(arg1);
1925 size_t len2 = strlen(arg2);
1927 result = pg_strncoll_libc_win32_utf8(arg1, len1, arg2, len2,
locale);
1934 result = strcoll(arg1, arg2);
1950 size_t bufsize1 = len1 + 1;
1951 size_t bufsize2 = len2 + 1;
1961 return pg_strncoll_libc_win32_utf8(arg1, len1, arg2, len2,
locale);
1968 arg2n =
buf + bufsize1;
1971 memcpy(arg1n, arg1, len1);
1973 memcpy(arg2n, arg2, len2);
1997 pg_strncoll_icu_no_utf8(
const char *arg1, int32_t len1,
2011 #ifdef HAVE_UCOL_STRCOLLUTF8
2015 init_icu_converter();
2017 ulen1 = uchar_length(icu_converter, arg1, len1);
2018 ulen2 = uchar_length(icu_converter, arg2, len2);
2020 bufsize1 = (ulen1 + 1) *
sizeof(UChar);
2021 bufsize2 = (ulen2 + 1) *
sizeof(UChar);
2026 uchar1 = (UChar *)
buf;
2027 uchar2 = (UChar *) (
buf + bufsize1);
2029 ulen1 = uchar_convert(icu_converter, uchar1, ulen1 + 1, arg1, len1);
2030 ulen2 = uchar_convert(icu_converter, uchar2, ulen2 + 1, arg2, len2);
2032 result = ucol_strcoll(
locale->info.icu.ucol,
2052 pg_strncoll_icu(
const char *arg1, int32_t len1,
const char *arg2, int32_t len2,
2059 #ifdef HAVE_UCOL_STRCOLLUTF8
2064 status = U_ZERO_ERROR;
2065 result = ucol_strcollUTF8(
locale->info.icu.ucol,
2069 if (U_FAILURE(status))
2071 (
errmsg(
"collation failed: %s", u_errorName(status))));
2076 result = pg_strncoll_icu_no_utf8(arg1, len1, arg2, len2,
locale);
2105 else if (
locale->provider == COLLPROVIDER_ICU)
2106 result = pg_strncoll_icu(arg1, -1, arg2, -1,
locale);
2133 pg_strncoll(
const char *arg1,
size_t len1,
const char *arg2,
size_t len2,
2141 else if (
locale->provider == COLLPROVIDER_ICU)
2142 result = pg_strncoll_icu(arg1, len1, arg2, len2,
locale);
2158 #ifdef TRUST_STRXFRM
2162 return strxfrm(
dest, src, destsize);
2185 memcpy(
buf, src, srclen);
2194 Assert(result >= destsize ||
dest[result] ==
'\0');
2203 pg_strnxfrm_icu(
char *
dest,
const char *src, int32_t srclen, int32_t destsize,
2215 init_icu_converter();
2217 ulen = uchar_length(icu_converter, src, srclen);
2219 uchar_bsize = (ulen + 1) *
sizeof(UChar);
2224 uchar = (UChar *)
buf;
2226 ulen = uchar_convert(icu_converter, uchar, ulen + 1, src, srclen);
2228 result_bsize = ucol_getSortKey(
locale->info.icu.ucol,
2230 (uint8_t *)
dest, destsize);
2236 Assert(result_bsize > 0);
2243 Assert(result_bsize >= destsize ||
dest[result_bsize] ==
'\0');
2245 return result_bsize;
2250 pg_strnxfrm_prefix_icu_no_utf8(
char *
dest,
const char *src, int32_t srclen,
2259 UChar *uchar = NULL;
2266 init_icu_converter();
2268 ulen = uchar_length(icu_converter, src, srclen);
2270 uchar_bsize = (ulen + 1) *
sizeof(UChar);
2275 uchar = (UChar *)
buf;
2277 ulen = uchar_convert(icu_converter, uchar, ulen + 1, src, srclen);
2279 uiter_setString(&iter, uchar, ulen);
2281 status = U_ZERO_ERROR;
2282 result_bsize = ucol_nextSortKeyPart(
locale->info.icu.ucol,
2288 if (U_FAILURE(status))
2290 (
errmsg(
"sort key generation failed: %s",
2291 u_errorName(status))));
2293 return result_bsize;
2298 pg_strnxfrm_prefix_icu(
char *
dest,
const char *src, int32_t srclen,
2311 uiter_setUTF8(&iter, src, srclen);
2313 status = U_ZERO_ERROR;
2314 result = ucol_nextSortKeyPart(
locale->info.icu.ucol,
2320 if (U_FAILURE(status))
2322 (
errmsg(
"sort key generation failed: %s",
2323 u_errorName(status))));
2326 result = pg_strnxfrm_prefix_icu_no_utf8(
dest, src, srclen, destsize,
2352 #ifdef TRUST_STRXFRM
2357 else if (
locale->provider == COLLPROVIDER_ICU)
2388 else if (
locale->provider == COLLPROVIDER_ICU)
2389 result = pg_strnxfrm_icu(
dest, src, -1, destsize,
locale);
2425 else if (
locale->provider == COLLPROVIDER_ICU)
2426 result = pg_strnxfrm_icu(
dest, src, srclen, destsize,
locale);
2444 else if (
locale->provider == COLLPROVIDER_ICU)
2475 else if (
locale->provider == COLLPROVIDER_ICU)
2476 result = pg_strnxfrm_prefix_icu(
dest, src, -1, destsize,
locale);
2510 else if (
locale->provider == COLLPROVIDER_ICU)
2511 result = pg_strnxfrm_prefix_icu(
dest, src, -1, destsize,
locale);
2529 if (strcmp(
locale,
"C") == 0)
2531 if (strcmp(
locale,
"C.UTF-8") == 0)
2535 (
errcode(ERRCODE_WRONG_OBJECT_TYPE),
2536 errmsg(
"invalid locale name \"%s\" for builtin provider",
2553 const char *canonical_name = NULL;
2554 int required_encoding;
2556 if (strcmp(
locale,
"C") == 0)
2557 canonical_name =
"C";
2558 else if (strcmp(
locale,
"C.UTF-8") == 0 || strcmp(
locale,
"C.UTF8") == 0)
2559 canonical_name =
"C.UTF-8";
2561 if (!canonical_name)
2563 (
errcode(ERRCODE_WRONG_OBJECT_TYPE),
2564 errmsg(
"invalid locale name \"%s\" for builtin provider",
2568 if (required_encoding >= 0 &&
encoding != required_encoding)
2570 (
errcode(ERRCODE_WRONG_OBJECT_TYPE),
2571 errmsg(
"encoding \"%s\" does not match locale \"%s\"",
2574 return canonical_name;
2585 pg_ucol_open(
const char *loc_str)
2587 UCollator *collator;
2589 const char *orig_str = loc_str;
2590 char *fixed_str = NULL;
2601 if (loc_str == NULL)
2602 elog(
ERROR,
"opening default collator is not supported");
2609 if (U_ICU_VERSION_MAJOR_NUM < 55)
2611 char lang[ULOC_LANG_CAPACITY];
2613 status = U_ZERO_ERROR;
2614 uloc_getLanguage(loc_str, lang, ULOC_LANG_CAPACITY, &status);
2615 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
2618 (
errmsg(
"could not get language from locale \"%s\": %s",
2619 loc_str, u_errorName(status))));
2622 if (strcmp(lang,
"und") == 0)
2624 const char *remainder = loc_str + strlen(
"und");
2626 fixed_str =
palloc(strlen(
"root") + strlen(remainder) + 1);
2627 strcpy(fixed_str,
"root");
2628 strcat(fixed_str, remainder);
2630 loc_str = fixed_str;
2634 status = U_ZERO_ERROR;
2635 collator = ucol_open(loc_str, &status);
2636 if (U_FAILURE(status))
2639 (
errmsg(
"could not open collator for locale \"%s\": %s",
2640 orig_str, u_errorName(status))));
2642 if (U_ICU_VERSION_MAJOR_NUM < 54)
2644 status = U_ZERO_ERROR;
2645 icu_set_collation_attributes(collator, loc_str, &status);
2651 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
2653 ucol_close(collator);
2655 (
errmsg(
"could not open collator for locale \"%s\": %s",
2656 orig_str, u_errorName(status))));
2660 if (fixed_str != NULL)
2667 init_icu_converter(
void)
2669 const char *icu_encoding_name;
2677 if (!icu_encoding_name)
2679 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2680 errmsg(
"encoding \"%s\" not supported by ICU",
2683 status = U_ZERO_ERROR;
2684 conv = ucnv_open(icu_encoding_name, &status);
2685 if (U_FAILURE(status))
2687 (
errmsg(
"could not open ICU converter for encoding \"%s\": %s",
2688 icu_encoding_name, u_errorName(status))));
2690 icu_converter = conv;
2697 uchar_length(UConverter *converter,
const char *
str, int32_t
len)
2699 UErrorCode status = U_ZERO_ERROR;
2702 ulen = ucnv_toUChars(converter, NULL, 0,
str,
len, &status);
2703 if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
2705 (
errmsg(
"%s failed: %s",
"ucnv_toUChars", u_errorName(status))));
2714 uchar_convert(UConverter *converter, UChar *
dest, int32_t destlen,
2715 const char *src, int32_t srclen)
2717 UErrorCode status = U_ZERO_ERROR;
2720 status = U_ZERO_ERROR;
2721 ulen = ucnv_toUChars(converter,
dest, destlen, src, srclen, &status);
2722 if (U_FAILURE(status))
2724 (
errmsg(
"%s failed: %s",
"ucnv_toUChars", u_errorName(status))));
2741 icu_to_uchar(UChar **buff_uchar,
const char *buff,
size_t nbytes)
2745 init_icu_converter();
2747 len_uchar = uchar_length(icu_converter, buff, nbytes);
2749 *buff_uchar =
palloc((len_uchar + 1) *
sizeof(**buff_uchar));
2750 len_uchar = uchar_convert(icu_converter,
2751 *buff_uchar, len_uchar + 1, buff, nbytes);
2768 icu_from_uchar(
char **result,
const UChar *buff_uchar, int32_t len_uchar)
2773 init_icu_converter();
2775 status = U_ZERO_ERROR;
2776 len_result = ucnv_fromUChars(icu_converter, NULL, 0,
2777 buff_uchar, len_uchar, &status);
2778 if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
2780 (
errmsg(
"%s failed: %s",
"ucnv_fromUChars",
2781 u_errorName(status))));
2783 *result =
palloc(len_result + 1);
2785 status = U_ZERO_ERROR;
2786 len_result = ucnv_fromUChars(icu_converter, *result, len_result + 1,
2787 buff_uchar, len_uchar, &status);
2788 if (U_FAILURE(status) ||
2789 status == U_STRING_NOT_TERMINATED_WARNING)
2791 (
errmsg(
"%s failed: %s",
"ucnv_fromUChars",
2792 u_errorName(status))));
2811 icu_set_collation_attributes(UCollator *collator, const
char *loc,
2815 char *icu_locale_id;
2826 *status = U_ZERO_ERROR;
2827 len = uloc_canonicalize(loc, NULL, 0, status);
2829 *status = U_ZERO_ERROR;
2830 len = uloc_canonicalize(loc, icu_locale_id,
len + 1, status);
2831 if (U_FAILURE(*status) || *status == U_STRING_NOT_TERMINATED_WARNING)
2834 lower_str =
asc_tolower(icu_locale_id, strlen(icu_locale_id));
2836 pfree(icu_locale_id);
2838 str = strchr(lower_str,
'@');
2845 char *
e = strchr(
token,
'=');
2851 UColAttribute uattr;
2852 UColAttributeValue uvalue;
2854 *status = U_ZERO_ERROR;
2863 if (strcmp(
name,
"colstrength") == 0)
2864 uattr = UCOL_STRENGTH;
2865 else if (strcmp(
name,
"colbackwards") == 0)
2866 uattr = UCOL_FRENCH_COLLATION;
2867 else if (strcmp(
name,
"colcaselevel") == 0)
2868 uattr = UCOL_CASE_LEVEL;
2869 else if (strcmp(
name,
"colcasefirst") == 0)
2870 uattr = UCOL_CASE_FIRST;
2871 else if (strcmp(
name,
"colalternate") == 0)
2872 uattr = UCOL_ALTERNATE_HANDLING;
2873 else if (strcmp(
name,
"colnormalization") == 0)
2874 uattr = UCOL_NORMALIZATION_MODE;
2875 else if (strcmp(
name,
"colnumeric") == 0)
2876 uattr = UCOL_NUMERIC_COLLATION;
2881 if (strcmp(
value,
"primary") == 0)
2882 uvalue = UCOL_PRIMARY;
2883 else if (strcmp(
value,
"secondary") == 0)
2884 uvalue = UCOL_SECONDARY;
2885 else if (strcmp(
value,
"tertiary") == 0)
2886 uvalue = UCOL_TERTIARY;
2887 else if (strcmp(
value,
"quaternary") == 0)
2888 uvalue = UCOL_QUATERNARY;
2889 else if (strcmp(
value,
"identical") == 0)
2890 uvalue = UCOL_IDENTICAL;
2891 else if (strcmp(
value,
"no") == 0)
2893 else if (strcmp(
value,
"yes") == 0)
2895 else if (strcmp(
value,
"shifted") == 0)
2896 uvalue = UCOL_SHIFTED;
2897 else if (strcmp(
value,
"non-ignorable") == 0)
2898 uvalue = UCOL_NON_IGNORABLE;
2899 else if (strcmp(
value,
"lower") == 0)
2900 uvalue = UCOL_LOWER_FIRST;
2901 else if (strcmp(
value,
"upper") == 0)
2902 uvalue = UCOL_UPPER_FIRST;
2905 *status = U_ILLEGAL_ARGUMENT_ERROR;
2909 ucol_setAttribute(collator, uattr, uvalue, status);
2933 const bool strict =
true;
2941 langtag =
palloc(buflen);
2944 status = U_ZERO_ERROR;
2945 uloc_toLanguageTag(loc_str, langtag, buflen, strict, &status);
2948 if ((status == U_BUFFER_OVERFLOW_ERROR ||
2949 status == U_STRING_NOT_TERMINATED_WARNING) &&
2953 langtag =
repalloc(langtag, buflen);
2960 if (U_FAILURE(status))
2966 (
errmsg(
"could not convert locale name \"%s\" to language tag: %s",
2967 loc_str, u_errorName(status))));
2974 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2975 errmsg(
"ICU is not supported in this build")));
2987 UCollator *collator;
2989 char lang[ULOC_LANG_CAPACITY];
3002 status = U_ZERO_ERROR;
3003 uloc_getLanguage(loc_str, lang, ULOC_LANG_CAPACITY, &status);
3004 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
3007 (
errmsg(
"could not get language from ICU locale \"%s\": %s",
3008 loc_str, u_errorName(status)),
3009 errhint(
"To disable ICU locale validation, set the parameter %s to \"%s\".",
3010 "icu_validation_level",
"disabled")));
3015 if (strcmp(lang,
"") == 0 ||
3016 strcmp(lang,
"root") == 0 || strcmp(lang,
"und") == 0)
3020 for (int32_t
i = 0; !found &&
i < uloc_countAvailable();
i++)
3022 const char *otherloc = uloc_getAvailable(
i);
3023 char otherlang[ULOC_LANG_CAPACITY];
3025 status = U_ZERO_ERROR;
3026 uloc_getLanguage(otherloc, otherlang, ULOC_LANG_CAPACITY, &status);
3027 if (U_FAILURE(status) || status == U_STRING_NOT_TERMINATED_WARNING)
3030 if (strcmp(lang, otherlang) == 0)
3036 (
errmsg(
"ICU locale \"%s\" has unknown language \"%s\"",
3038 errhint(
"To disable ICU locale validation, set the parameter %s to \"%s\".",
3039 "icu_validation_level",
"disabled")));
3042 collator = pg_ucol_open(loc_str);
3043 ucol_close(collator);
3047 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3048 errmsg(
"ICU is not supported in this build")));
3083 result = WideCharToMultiByte(CP_UTF8, 0, from, -1, to, tolen,
3100 result = wcstombs(to, from, tolen);
3121 char2wchar(
wchar_t *to,
size_t tolen,
const char *from,
size_t fromlen,
3140 result = MultiByteToWideChar(CP_UTF8, 0, from, fromlen, to, tolen - 1);
3162 result = mbstowcs(to,
str, tolen);
3186 (
errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
3187 errmsg(
"invalid multibyte character for locale"),
3188 errhint(
"The server's LC_CTYPE locale is probably incompatible with the database encoding.")));
#define TextDatumGetCString(d)
#define pg_attribute_unused()
#define Assert(condition)
#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)
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::@151::@152 builtin
union pg_locale_struct::@151 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)