LCOV - code coverage report
Current view: top level - src/backend/utils/adt - pg_locale.c (source / functions) Hit Total Coverage
Test: PostgreSQL 15beta1 Lines: 306 430 71.2 %
Date: 2022-05-18 03:10:05 Functions: 24 27 88.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-----------------------------------------------------------------------
       2             :  *
       3             :  * PostgreSQL locale utilities
       4             :  *
       5             :  * Portions Copyright (c) 2002-2022, PostgreSQL Global Development Group
       6             :  *
       7             :  * src/backend/utils/adt/pg_locale.c
       8             :  *
       9             :  *-----------------------------------------------------------------------
      10             :  */
      11             : 
      12             : /*----------
      13             :  * Here is how the locale stuff is handled: LC_COLLATE and LC_CTYPE
      14             :  * are fixed at CREATE DATABASE time, stored in pg_database, and cannot
      15             :  * be changed. Thus, the effects of strcoll(), strxfrm(), isupper(),
      16             :  * toupper(), etc. are always in the same fixed locale.
      17             :  *
      18             :  * LC_MESSAGES is settable at run time and will take effect
      19             :  * immediately.
      20             :  *
      21             :  * The other categories, LC_MONETARY, LC_NUMERIC, and LC_TIME are also
      22             :  * settable at run-time.  However, we don't actually set those locale
      23             :  * categories permanently.  This would have bizarre effects like no
      24             :  * longer accepting standard floating-point literals in some locales.
      25             :  * Instead, we only set these locale categories briefly when needed,
      26             :  * cache the required information obtained from localeconv() or
      27             :  * strftime(), and then set the locale categories back to "C".
      28             :  * The cached information is only used by the formatting functions
      29             :  * (to_char, etc.) and the money type.  For the user, this should all be
      30             :  * transparent.
      31             :  *
      32             :  * !!! NOW HEAR THIS !!!
      33             :  *
      34             :  * We've been bitten repeatedly by this bug, so let's try to keep it in
      35             :  * mind in future: on some platforms, the locale functions return pointers
      36             :  * to static data that will be overwritten by any later locale function.
      37             :  * Thus, for example, the obvious-looking sequence
      38             :  *          save = setlocale(category, NULL);
      39             :  *          if (!setlocale(category, value))
      40             :  *              fail = true;
      41             :  *          setlocale(category, save);
      42             :  * DOES NOT WORK RELIABLY: on some platforms the second setlocale() call
      43             :  * will change the memory save is pointing at.  To do this sort of thing
      44             :  * safely, you *must* pstrdup what setlocale returns the first time.
      45             :  *
      46             :  * The POSIX locale standard is available here:
      47             :  *
      48             :  *  http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap07.html
      49             :  *----------
      50             :  */
      51             : 
      52             : 
      53             : #include "postgres.h"
      54             : 
      55             : #include <time.h>
      56             : 
      57             : #include "access/htup_details.h"
      58             : #include "catalog/pg_collation.h"
      59             : #include "catalog/pg_control.h"
      60             : #include "mb/pg_wchar.h"
      61             : #include "utils/builtins.h"
      62             : #include "utils/formatting.h"
      63             : #include "utils/hsearch.h"
      64             : #include "utils/lsyscache.h"
      65             : #include "utils/memutils.h"
      66             : #include "utils/pg_locale.h"
      67             : #include "utils/syscache.h"
      68             : 
      69             : #ifdef USE_ICU
      70             : #include <unicode/ucnv.h>
      71             : #endif
      72             : 
      73             : #ifdef __GLIBC__
      74             : #include <gnu/libc-version.h>
      75             : #endif
      76             : 
      77             : #ifdef WIN32
      78             : #include <shlwapi.h>
      79             : #endif
      80             : 
      81             : #define     MAX_L10N_DATA       80
      82             : 
      83             : 
      84             : /* GUC settings */
      85             : char       *locale_messages;
      86             : char       *locale_monetary;
      87             : char       *locale_numeric;
      88             : char       *locale_time;
      89             : 
      90             : /*
      91             :  * lc_time localization cache.
      92             :  *
      93             :  * We use only the first 7 or 12 entries of these arrays.  The last array
      94             :  * element is left as NULL for the convenience of outside code that wants
      95             :  * to sequentially scan these arrays.
      96             :  */
      97             : char       *localized_abbrev_days[7 + 1];
      98             : char       *localized_full_days[7 + 1];
      99             : char       *localized_abbrev_months[12 + 1];
     100             : char       *localized_full_months[12 + 1];
     101             : 
     102             : /* indicates whether locale information cache is valid */
     103             : static bool CurrentLocaleConvValid = false;
     104             : static bool CurrentLCTimeValid = false;
     105             : 
     106             : /* Cache for collation-related knowledge */
     107             : 
     108             : typedef struct
     109             : {
     110             :     Oid         collid;         /* hash key: pg_collation OID */
     111             :     bool        collate_is_c;   /* is collation's LC_COLLATE C? */
     112             :     bool        ctype_is_c;     /* is collation's LC_CTYPE C? */
     113             :     bool        flags_valid;    /* true if above flags are valid */
     114             :     pg_locale_t locale;         /* locale_t struct, or 0 if not valid */
     115             : } collation_cache_entry;
     116             : 
     117             : static HTAB *collation_cache = NULL;
     118             : 
     119             : 
     120             : #if defined(WIN32) && defined(LC_MESSAGES)
     121             : static char *IsoLocaleName(const char *);   /* MSVC specific */
     122             : #endif
     123             : 
     124             : #ifdef USE_ICU
     125             : static void icu_set_collation_attributes(UCollator *collator, const char *loc);
     126             : #endif
     127             : 
     128             : /*
     129             :  * pg_perm_setlocale
     130             :  *
     131             :  * This wraps the libc function setlocale(), with two additions.  First, when
     132             :  * changing LC_CTYPE, update gettext's encoding for the current message
     133             :  * domain.  GNU gettext automatically tracks LC_CTYPE on most platforms, but
     134             :  * not on Windows.  Second, if the operation is successful, the corresponding
     135             :  * LC_XXX environment variable is set to match.  By setting the environment
     136             :  * variable, we ensure that any subsequent use of setlocale(..., "") will
     137             :  * preserve the settings made through this routine.  Of course, LC_ALL must
     138             :  * also be unset to fully ensure that, but that has to be done elsewhere after
     139             :  * all the individual LC_XXX variables have been set correctly.  (Thank you
     140             :  * Perl for making this kluge necessary.)
     141             :  */
     142             : char *
     143       80382 : pg_perm_setlocale(int category, const char *locale)
     144             : {
     145             :     char       *result;
     146             :     const char *envvar;
     147             : 
     148             : #ifndef WIN32
     149       80382 :     result = setlocale(category, locale);
     150             : #else
     151             : 
     152             :     /*
     153             :      * On Windows, setlocale(LC_MESSAGES) does not work, so just assume that
     154             :      * the given value is good and set it in the environment variables. We
     155             :      * must ignore attempts to set to "", which means "keep using the old
     156             :      * environment value".
     157             :      */
     158             : #ifdef LC_MESSAGES
     159             :     if (category == LC_MESSAGES)
     160             :     {
     161             :         result = (char *) locale;
     162             :         if (locale == NULL || locale[0] == '\0')
     163             :             return result;
     164             :     }
     165             :     else
     166             : #endif
     167             :         result = setlocale(category, locale);
     168             : #endif                          /* WIN32 */
     169             : 
     170       80382 :     if (result == NULL)
     171           0 :         return result;          /* fall out immediately on failure */
     172             : 
     173             :     /*
     174             :      * Use the right encoding in translated messages.  Under ENABLE_NLS, let
     175             :      * pg_bind_textdomain_codeset() figure it out.  Under !ENABLE_NLS, message
     176             :      * format strings are ASCII, but database-encoding strings may enter the
     177             :      * message via %s.  This makes the overall message encoding equal to the
     178             :      * database encoding.
     179             :      */
     180       80382 :     if (category == LC_CTYPE)
     181             :     {
     182             :         static char save_lc_ctype[LOCALE_NAME_BUFLEN];
     183             : 
     184             :         /* copy setlocale() return value before callee invokes it again */
     185       22582 :         strlcpy(save_lc_ctype, result, sizeof(save_lc_ctype));
     186       22582 :         result = save_lc_ctype;
     187             : 
     188             : #ifdef ENABLE_NLS
     189       22582 :         SetMessageEncoding(pg_bind_textdomain_codeset(textdomain(NULL)));
     190             : #else
     191             :         SetMessageEncoding(GetDatabaseEncoding());
     192             : #endif
     193             :     }
     194             : 
     195       80382 :     switch (category)
     196             :     {
     197       22582 :         case LC_COLLATE:
     198       22582 :             envvar = "LC_COLLATE";
     199       22582 :             break;
     200       22582 :         case LC_CTYPE:
     201       22582 :             envvar = "LC_CTYPE";
     202       22582 :             break;
     203             : #ifdef LC_MESSAGES
     204       21556 :         case LC_MESSAGES:
     205       21556 :             envvar = "LC_MESSAGES";
     206             : #ifdef WIN32
     207             :             result = IsoLocaleName(locale);
     208             :             if (result == NULL)
     209             :                 result = (char *) locale;
     210             :             elog(DEBUG3, "IsoLocaleName() executed; locale: \"%s\"", result);
     211             : #endif                          /* WIN32 */
     212       21556 :             break;
     213             : #endif                          /* LC_MESSAGES */
     214        4554 :         case LC_MONETARY:
     215        4554 :             envvar = "LC_MONETARY";
     216        4554 :             break;
     217        4554 :         case LC_NUMERIC:
     218        4554 :             envvar = "LC_NUMERIC";
     219        4554 :             break;
     220        4554 :         case LC_TIME:
     221        4554 :             envvar = "LC_TIME";
     222        4554 :             break;
     223           0 :         default:
     224           0 :             elog(FATAL, "unrecognized LC category: %d", category);
     225             :             return NULL;        /* keep compiler quiet */
     226             :     }
     227             : 
     228       80382 :     if (setenv(envvar, result, 1) != 0)
     229           0 :         return NULL;
     230             : 
     231       80382 :     return result;
     232             : }
     233             : 
     234             : 
     235             : /*
     236             :  * Is the locale name valid for the locale category?
     237             :  *
     238             :  * If successful, and canonname isn't NULL, a palloc'd copy of the locale's
     239             :  * canonical name is stored there.  This is especially useful for figuring out
     240             :  * what locale name "" means (ie, the server environment value).  (Actually,
     241             :  * it seems that on most implementations that's the only thing it's good for;
     242             :  * we could wish that setlocale gave back a canonically spelled version of
     243             :  * the locale name, but typically it doesn't.)
     244             :  */
     245             : bool
     246       65624 : check_locale(int category, const char *locale, char **canonname)
     247             : {
     248             :     char       *save;
     249             :     char       *res;
     250             : 
     251       65624 :     if (canonname)
     252        2778 :         *canonname = NULL;      /* in case of failure */
     253             : 
     254       65624 :     save = setlocale(category, NULL);
     255       65624 :     if (!save)
     256           0 :         return false;           /* won't happen, we hope */
     257             : 
     258             :     /* save may be pointing at a modifiable scratch variable, see above. */
     259       65624 :     save = pstrdup(save);
     260             : 
     261             :     /* set the locale with setlocale, to see if it accepts it. */
     262       65624 :     res = setlocale(category, locale);
     263             : 
     264             :     /* save canonical name if requested. */
     265       65624 :     if (res && canonname)
     266        2774 :         *canonname = pstrdup(res);
     267             : 
     268             :     /* restore old value. */
     269       65624 :     if (!setlocale(category, save))
     270           0 :         elog(WARNING, "failed to restore old locale \"%s\"", save);
     271       65624 :     pfree(save);
     272             : 
     273       65624 :     return (res != NULL);
     274             : }
     275             : 
     276             : 
     277             : /*
     278             :  * GUC check/assign hooks
     279             :  *
     280             :  * For most locale categories, the assign hook doesn't actually set the locale
     281             :  * permanently, just reset flags so that the next use will cache the
     282             :  * appropriate values.  (See explanation at the top of this file.)
     283             :  *
     284             :  * Note: we accept value = "" as selecting the postmaster's environment
     285             :  * value, whatever it was (so long as the environment setting is legal).
     286             :  * This will have been locked down by an earlier call to pg_perm_setlocale.
     287             :  */
     288             : bool
     289       17148 : check_locale_monetary(char **newval, void **extra, GucSource source)
     290             : {
     291       17148 :     return check_locale(LC_MONETARY, *newval, NULL);
     292             : }
     293             : 
     294             : void
     295       16978 : assign_locale_monetary(const char *newval, void *extra)
     296             : {
     297       16978 :     CurrentLocaleConvValid = false;
     298       16978 : }
     299             : 
     300             : bool
     301       17154 : check_locale_numeric(char **newval, void **extra, GucSource source)
     302             : {
     303       17154 :     return check_locale(LC_NUMERIC, *newval, NULL);
     304             : }
     305             : 
     306             : void
     307       16990 : assign_locale_numeric(const char *newval, void *extra)
     308             : {
     309       16990 :     CurrentLocaleConvValid = false;
     310       16990 : }
     311             : 
     312             : bool
     313       17148 : check_locale_time(char **newval, void **extra, GucSource source)
     314             : {
     315       17148 :     return check_locale(LC_TIME, *newval, NULL);
     316             : }
     317             : 
     318             : void
     319       16978 : assign_locale_time(const char *newval, void *extra)
     320             : {
     321       16978 :     CurrentLCTimeValid = false;
     322       16978 : }
     323             : 
     324             : /*
     325             :  * We allow LC_MESSAGES to actually be set globally.
     326             :  *
     327             :  * Note: we normally disallow value = "" because it wouldn't have consistent
     328             :  * semantics (it'd effectively just use the previous value).  However, this
     329             :  * is the value passed for PGC_S_DEFAULT, so don't complain in that case,
     330             :  * not even if the attempted setting fails due to invalid environment value.
     331             :  * The idea there is just to accept the environment setting *if possible*
     332             :  * during startup, until we can read the proper value from postgresql.conf.
     333             :  */
     334             : bool
     335       17172 : check_locale_messages(char **newval, void **extra, GucSource source)
     336             : {
     337       17172 :     if (**newval == '\0')
     338             :     {
     339        5776 :         if (source == PGC_S_DEFAULT)
     340        5776 :             return true;
     341             :         else
     342           0 :             return false;
     343             :     }
     344             : 
     345             :     /*
     346             :      * LC_MESSAGES category does not exist everywhere, but accept it anyway
     347             :      *
     348             :      * On Windows, we can't even check the value, so accept blindly
     349             :      */
     350             : #if defined(LC_MESSAGES) && !defined(WIN32)
     351       11396 :     return check_locale(LC_MESSAGES, *newval, NULL);
     352             : #else
     353             :     return true;
     354             : #endif
     355             : }
     356             : 
     357             : void
     358       17002 : assign_locale_messages(const char *newval, void *extra)
     359             : {
     360             :     /*
     361             :      * LC_MESSAGES category does not exist everywhere, but accept it anyway.
     362             :      * We ignore failure, as per comment above.
     363             :      */
     364             : #ifdef LC_MESSAGES
     365       17002 :     (void) pg_perm_setlocale(LC_MESSAGES, newval);
     366             : #endif
     367       17002 : }
     368             : 
     369             : 
     370             : /*
     371             :  * Frees the malloced content of a struct lconv.  (But not the struct
     372             :  * itself.)  It's important that this not throw elog(ERROR).
     373             :  */
     374             : static void
     375           6 : free_struct_lconv(struct lconv *s)
     376             : {
     377           6 :     if (s->decimal_point)
     378           6 :         free(s->decimal_point);
     379           6 :     if (s->thousands_sep)
     380           6 :         free(s->thousands_sep);
     381           6 :     if (s->grouping)
     382           6 :         free(s->grouping);
     383           6 :     if (s->int_curr_symbol)
     384           6 :         free(s->int_curr_symbol);
     385           6 :     if (s->currency_symbol)
     386           6 :         free(s->currency_symbol);
     387           6 :     if (s->mon_decimal_point)
     388           6 :         free(s->mon_decimal_point);
     389           6 :     if (s->mon_thousands_sep)
     390           6 :         free(s->mon_thousands_sep);
     391           6 :     if (s->mon_grouping)
     392           6 :         free(s->mon_grouping);
     393           6 :     if (s->positive_sign)
     394           6 :         free(s->positive_sign);
     395           6 :     if (s->negative_sign)
     396           6 :         free(s->negative_sign);
     397           6 : }
     398             : 
     399             : /*
     400             :  * Check that all fields of a struct lconv (or at least, the ones we care
     401             :  * about) are non-NULL.  The field list must match free_struct_lconv().
     402             :  */
     403             : static bool
     404         102 : struct_lconv_is_valid(struct lconv *s)
     405             : {
     406         102 :     if (s->decimal_point == NULL)
     407           0 :         return false;
     408         102 :     if (s->thousands_sep == NULL)
     409           0 :         return false;
     410         102 :     if (s->grouping == NULL)
     411           0 :         return false;
     412         102 :     if (s->int_curr_symbol == NULL)
     413           0 :         return false;
     414         102 :     if (s->currency_symbol == NULL)
     415           0 :         return false;
     416         102 :     if (s->mon_decimal_point == NULL)
     417           0 :         return false;
     418         102 :     if (s->mon_thousands_sep == NULL)
     419           0 :         return false;
     420         102 :     if (s->mon_grouping == NULL)
     421           0 :         return false;
     422         102 :     if (s->positive_sign == NULL)
     423           0 :         return false;
     424         102 :     if (s->negative_sign == NULL)
     425           0 :         return false;
     426         102 :     return true;
     427             : }
     428             : 
     429             : 
     430             : /*
     431             :  * Convert the strdup'd string at *str from the specified encoding to the
     432             :  * database encoding.
     433             :  */
     434             : static void
     435         816 : db_encoding_convert(int encoding, char **str)
     436             : {
     437             :     char       *pstr;
     438             :     char       *mstr;
     439             : 
     440             :     /* convert the string to the database encoding */
     441         816 :     pstr = pg_any_to_server(*str, strlen(*str), encoding);
     442         816 :     if (pstr == *str)
     443         816 :         return;                 /* no conversion happened */
     444             : 
     445             :     /* need it malloc'd not palloc'd */
     446           0 :     mstr = strdup(pstr);
     447           0 :     if (mstr == NULL)
     448           0 :         ereport(ERROR,
     449             :                 (errcode(ERRCODE_OUT_OF_MEMORY),
     450             :                  errmsg("out of memory")));
     451             : 
     452             :     /* replace old string */
     453           0 :     free(*str);
     454           0 :     *str = mstr;
     455             : 
     456           0 :     pfree(pstr);
     457             : }
     458             : 
     459             : 
     460             : /*
     461             :  * Return the POSIX lconv struct (contains number/money formatting
     462             :  * information) with locale information for all categories.
     463             :  */
     464             : struct lconv *
     465       15906 : PGLC_localeconv(void)
     466             : {
     467             :     static struct lconv CurrentLocaleConv;
     468             :     static bool CurrentLocaleConvAllocated = false;
     469             :     struct lconv *extlconv;
     470             :     struct lconv worklconv;
     471             :     char       *save_lc_monetary;
     472             :     char       *save_lc_numeric;
     473             : #ifdef WIN32
     474             :     char       *save_lc_ctype;
     475             : #endif
     476             : 
     477             :     /* Did we do it already? */
     478       15906 :     if (CurrentLocaleConvValid)
     479       15804 :         return &CurrentLocaleConv;
     480             : 
     481             :     /* Free any already-allocated storage */
     482         102 :     if (CurrentLocaleConvAllocated)
     483             :     {
     484           6 :         free_struct_lconv(&CurrentLocaleConv);
     485           6 :         CurrentLocaleConvAllocated = false;
     486             :     }
     487             : 
     488             :     /*
     489             :      * This is tricky because we really don't want to risk throwing error
     490             :      * while the locale is set to other than our usual settings.  Therefore,
     491             :      * the process is: collect the usual settings, set locale to special
     492             :      * setting, copy relevant data into worklconv using strdup(), restore
     493             :      * normal settings, convert data to desired encoding, and finally stash
     494             :      * the collected data in CurrentLocaleConv.  This makes it safe if we
     495             :      * throw an error during encoding conversion or run out of memory anywhere
     496             :      * in the process.  All data pointed to by struct lconv members is
     497             :      * allocated with strdup, to avoid premature elog(ERROR) and to allow
     498             :      * using a single cleanup routine.
     499             :      */
     500         102 :     memset(&worklconv, 0, sizeof(worklconv));
     501             : 
     502             :     /* Save prevailing values of monetary and numeric locales */
     503         102 :     save_lc_monetary = setlocale(LC_MONETARY, NULL);
     504         102 :     if (!save_lc_monetary)
     505           0 :         elog(ERROR, "setlocale(NULL) failed");
     506         102 :     save_lc_monetary = pstrdup(save_lc_monetary);
     507             : 
     508         102 :     save_lc_numeric = setlocale(LC_NUMERIC, NULL);
     509         102 :     if (!save_lc_numeric)
     510           0 :         elog(ERROR, "setlocale(NULL) failed");
     511         102 :     save_lc_numeric = pstrdup(save_lc_numeric);
     512             : 
     513             : #ifdef WIN32
     514             : 
     515             :     /*
     516             :      * The POSIX standard explicitly says that it is undefined what happens if
     517             :      * LC_MONETARY or LC_NUMERIC imply an encoding (codeset) different from
     518             :      * that implied by LC_CTYPE.  In practice, all Unix-ish platforms seem to
     519             :      * believe that localeconv() should return strings that are encoded in the
     520             :      * codeset implied by the LC_MONETARY or LC_NUMERIC locale name.  Hence,
     521             :      * once we have successfully collected the localeconv() results, we will
     522             :      * convert them from that codeset to the desired server encoding.
     523             :      *
     524             :      * Windows, of course, resolutely does things its own way; on that
     525             :      * platform LC_CTYPE has to match LC_MONETARY/LC_NUMERIC to get sane
     526             :      * results.  Hence, we must temporarily set that category as well.
     527             :      */
     528             : 
     529             :     /* Save prevailing value of ctype locale */
     530             :     save_lc_ctype = setlocale(LC_CTYPE, NULL);
     531             :     if (!save_lc_ctype)
     532             :         elog(ERROR, "setlocale(NULL) failed");
     533             :     save_lc_ctype = pstrdup(save_lc_ctype);
     534             : 
     535             :     /* Here begins the critical section where we must not throw error */
     536             : 
     537             :     /* use numeric to set the ctype */
     538             :     setlocale(LC_CTYPE, locale_numeric);
     539             : #endif
     540             : 
     541             :     /* Get formatting information for numeric */
     542         102 :     setlocale(LC_NUMERIC, locale_numeric);
     543         102 :     extlconv = localeconv();
     544             : 
     545             :     /* Must copy data now in case setlocale() overwrites it */
     546         102 :     worklconv.decimal_point = strdup(extlconv->decimal_point);
     547         102 :     worklconv.thousands_sep = strdup(extlconv->thousands_sep);
     548         102 :     worklconv.grouping = strdup(extlconv->grouping);
     549             : 
     550             : #ifdef WIN32
     551             :     /* use monetary to set the ctype */
     552             :     setlocale(LC_CTYPE, locale_monetary);
     553             : #endif
     554             : 
     555             :     /* Get formatting information for monetary */
     556         102 :     setlocale(LC_MONETARY, locale_monetary);
     557         102 :     extlconv = localeconv();
     558             : 
     559             :     /* Must copy data now in case setlocale() overwrites it */
     560         102 :     worklconv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
     561         102 :     worklconv.currency_symbol = strdup(extlconv->currency_symbol);
     562         102 :     worklconv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
     563         102 :     worklconv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
     564         102 :     worklconv.mon_grouping = strdup(extlconv->mon_grouping);
     565         102 :     worklconv.positive_sign = strdup(extlconv->positive_sign);
     566         102 :     worklconv.negative_sign = strdup(extlconv->negative_sign);
     567             :     /* Copy scalar fields as well */
     568         102 :     worklconv.int_frac_digits = extlconv->int_frac_digits;
     569         102 :     worklconv.frac_digits = extlconv->frac_digits;
     570         102 :     worklconv.p_cs_precedes = extlconv->p_cs_precedes;
     571         102 :     worklconv.p_sep_by_space = extlconv->p_sep_by_space;
     572         102 :     worklconv.n_cs_precedes = extlconv->n_cs_precedes;
     573         102 :     worklconv.n_sep_by_space = extlconv->n_sep_by_space;
     574         102 :     worklconv.p_sign_posn = extlconv->p_sign_posn;
     575         102 :     worklconv.n_sign_posn = extlconv->n_sign_posn;
     576             : 
     577             :     /*
     578             :      * Restore the prevailing locale settings; failure to do so is fatal.
     579             :      * Possibly we could limp along with nondefault LC_MONETARY or LC_NUMERIC,
     580             :      * but proceeding with the wrong value of LC_CTYPE would certainly be bad
     581             :      * news; and considering that the prevailing LC_MONETARY and LC_NUMERIC
     582             :      * are almost certainly "C", there's really no reason that restoring those
     583             :      * should fail.
     584             :      */
     585             : #ifdef WIN32
     586             :     if (!setlocale(LC_CTYPE, save_lc_ctype))
     587             :         elog(FATAL, "failed to restore LC_CTYPE to \"%s\"", save_lc_ctype);
     588             : #endif
     589         102 :     if (!setlocale(LC_MONETARY, save_lc_monetary))
     590           0 :         elog(FATAL, "failed to restore LC_MONETARY to \"%s\"", save_lc_monetary);
     591         102 :     if (!setlocale(LC_NUMERIC, save_lc_numeric))
     592           0 :         elog(FATAL, "failed to restore LC_NUMERIC to \"%s\"", save_lc_numeric);
     593             : 
     594             :     /*
     595             :      * At this point we've done our best to clean up, and can call functions
     596             :      * that might possibly throw errors with a clean conscience.  But let's
     597             :      * make sure we don't leak any already-strdup'd fields in worklconv.
     598             :      */
     599         102 :     PG_TRY();
     600             :     {
     601             :         int         encoding;
     602             : 
     603             :         /* Release the pstrdup'd locale names */
     604         102 :         pfree(save_lc_monetary);
     605         102 :         pfree(save_lc_numeric);
     606             : #ifdef WIN32
     607             :         pfree(save_lc_ctype);
     608             : #endif
     609             : 
     610             :         /* If any of the preceding strdup calls failed, complain now. */
     611         102 :         if (!struct_lconv_is_valid(&worklconv))
     612           0 :             ereport(ERROR,
     613             :                     (errcode(ERRCODE_OUT_OF_MEMORY),
     614             :                      errmsg("out of memory")));
     615             : 
     616             :         /*
     617             :          * Now we must perform encoding conversion from whatever's associated
     618             :          * with the locales into the database encoding.  If we can't identify
     619             :          * the encoding implied by LC_NUMERIC or LC_MONETARY (ie we get -1),
     620             :          * use PG_SQL_ASCII, which will result in just validating that the
     621             :          * strings are OK in the database encoding.
     622             :          */
     623         102 :         encoding = pg_get_encoding_from_locale(locale_numeric, true);
     624         102 :         if (encoding < 0)
     625           0 :             encoding = PG_SQL_ASCII;
     626             : 
     627         102 :         db_encoding_convert(encoding, &worklconv.decimal_point);
     628         102 :         db_encoding_convert(encoding, &worklconv.thousands_sep);
     629             :         /* grouping is not text and does not require conversion */
     630             : 
     631         102 :         encoding = pg_get_encoding_from_locale(locale_monetary, true);
     632         102 :         if (encoding < 0)
     633           0 :             encoding = PG_SQL_ASCII;
     634             : 
     635         102 :         db_encoding_convert(encoding, &worklconv.int_curr_symbol);
     636         102 :         db_encoding_convert(encoding, &worklconv.currency_symbol);
     637         102 :         db_encoding_convert(encoding, &worklconv.mon_decimal_point);
     638         102 :         db_encoding_convert(encoding, &worklconv.mon_thousands_sep);
     639             :         /* mon_grouping is not text and does not require conversion */
     640         102 :         db_encoding_convert(encoding, &worklconv.positive_sign);
     641         102 :         db_encoding_convert(encoding, &worklconv.negative_sign);
     642             :     }
     643           0 :     PG_CATCH();
     644             :     {
     645           0 :         free_struct_lconv(&worklconv);
     646           0 :         PG_RE_THROW();
     647             :     }
     648         102 :     PG_END_TRY();
     649             : 
     650             :     /*
     651             :      * Everything is good, so save the results.
     652             :      */
     653         102 :     CurrentLocaleConv = worklconv;
     654         102 :     CurrentLocaleConvAllocated = true;
     655         102 :     CurrentLocaleConvValid = true;
     656         102 :     return &CurrentLocaleConv;
     657             : }
     658             : 
     659             : #ifdef WIN32
     660             : /*
     661             :  * On Windows, strftime() returns its output in encoding CP_ACP (the default
     662             :  * operating system codepage for the computer), which is likely different
     663             :  * from SERVER_ENCODING.  This is especially important in Japanese versions
     664             :  * of Windows which will use SJIS encoding, which we don't support as a
     665             :  * server encoding.
     666             :  *
     667             :  * So, instead of using strftime(), use wcsftime() to return the value in
     668             :  * wide characters (internally UTF16) and then convert to UTF8, which we
     669             :  * know how to handle directly.
     670             :  *
     671             :  * Note that this only affects the calls to strftime() in this file, which are
     672             :  * used to get the locale-aware strings. Other parts of the backend use
     673             :  * pg_strftime(), which isn't locale-aware and does not need to be replaced.
     674             :  */
     675             : static size_t
     676             : strftime_win32(char *dst, size_t dstlen,
     677             :                const char *format, const struct tm *tm)
     678             : {
     679             :     size_t      len;
     680             :     wchar_t     wformat[8];     /* formats used below need 3 chars */
     681             :     wchar_t     wbuf[MAX_L10N_DATA];
     682             : 
     683             :     /*
     684             :      * Get a wchar_t version of the format string.  We only actually use
     685             :      * plain-ASCII formats in this file, so we can say that they're UTF8.
     686             :      */
     687             :     len = MultiByteToWideChar(CP_UTF8, 0, format, -1,
     688             :                               wformat, lengthof(wformat));
     689             :     if (len == 0)
     690             :         elog(ERROR, "could not convert format string from UTF-8: error code %lu",
     691             :              GetLastError());
     692             : 
     693             :     len = wcsftime(wbuf, MAX_L10N_DATA, wformat, tm);
     694             :     if (len == 0)
     695             :     {
     696             :         /*
     697             :          * wcsftime failed, possibly because the result would not fit in
     698             :          * MAX_L10N_DATA.  Return 0 with the contents of dst unspecified.
     699             :          */
     700             :         return 0;
     701             :     }
     702             : 
     703             :     len = WideCharToMultiByte(CP_UTF8, 0, wbuf, len, dst, dstlen - 1,
     704             :                               NULL, NULL);
     705             :     if (len == 0)
     706             :         elog(ERROR, "could not convert string to UTF-8: error code %lu",
     707             :              GetLastError());
     708             : 
     709             :     dst[len] = '\0';
     710             : 
     711             :     return len;
     712             : }
     713             : 
     714             : /* redefine strftime() */
     715             : #define strftime(a,b,c,d) strftime_win32(a,b,c,d)
     716             : #endif                          /* WIN32 */
     717             : 
     718             : /*
     719             :  * Subroutine for cache_locale_time().
     720             :  * Convert the given string from encoding "encoding" to the database
     721             :  * encoding, and store the result at *dst, replacing any previous value.
     722             :  */
     723             : static void
     724        1672 : cache_single_string(char **dst, const char *src, int encoding)
     725             : {
     726             :     char       *ptr;
     727             :     char       *olddst;
     728             : 
     729             :     /* Convert the string to the database encoding, or validate it's OK */
     730        1672 :     ptr = pg_any_to_server(src, strlen(src), encoding);
     731             : 
     732             :     /* Store the string in long-lived storage, replacing any previous value */
     733        1672 :     olddst = *dst;
     734        1672 :     *dst = MemoryContextStrdup(TopMemoryContext, ptr);
     735        1672 :     if (olddst)
     736           0 :         pfree(olddst);
     737             : 
     738             :     /* Might as well clean up any palloc'd conversion result, too */
     739        1672 :     if (ptr != src)
     740           0 :         pfree(ptr);
     741        1672 : }
     742             : 
     743             : /*
     744             :  * Update the lc_time localization cache variables if needed.
     745             :  */
     746             : void
     747       18512 : cache_locale_time(void)
     748             : {
     749             :     char        buf[(2 * 7 + 2 * 12) * MAX_L10N_DATA];
     750             :     char       *bufptr;
     751             :     time_t      timenow;
     752             :     struct tm  *timeinfo;
     753       18512 :     bool        strftimefail = false;
     754             :     int         encoding;
     755             :     int         i;
     756             :     char       *save_lc_time;
     757             : #ifdef WIN32
     758             :     char       *save_lc_ctype;
     759             : #endif
     760             : 
     761             :     /* did we do this already? */
     762       18512 :     if (CurrentLCTimeValid)
     763       18468 :         return;
     764             : 
     765          44 :     elog(DEBUG3, "cache_locale_time() executed; locale: \"%s\"", locale_time);
     766             : 
     767             :     /*
     768             :      * As in PGLC_localeconv(), it's critical that we not throw error while
     769             :      * libc's locale settings have nondefault values.  Hence, we just call
     770             :      * strftime() within the critical section, and then convert and save its
     771             :      * results afterwards.
     772             :      */
     773             : 
     774             :     /* Save prevailing value of time locale */
     775          44 :     save_lc_time = setlocale(LC_TIME, NULL);
     776          44 :     if (!save_lc_time)
     777           0 :         elog(ERROR, "setlocale(NULL) failed");
     778          44 :     save_lc_time = pstrdup(save_lc_time);
     779             : 
     780             : #ifdef WIN32
     781             : 
     782             :     /*
     783             :      * On Windows, it appears that wcsftime() internally uses LC_CTYPE, so we
     784             :      * must set it here.  This code looks the same as what PGLC_localeconv()
     785             :      * does, but the underlying reason is different: this does NOT determine
     786             :      * the encoding we'll get back from strftime_win32().
     787             :      */
     788             : 
     789             :     /* Save prevailing value of ctype locale */
     790             :     save_lc_ctype = setlocale(LC_CTYPE, NULL);
     791             :     if (!save_lc_ctype)
     792             :         elog(ERROR, "setlocale(NULL) failed");
     793             :     save_lc_ctype = pstrdup(save_lc_ctype);
     794             : 
     795             :     /* use lc_time to set the ctype */
     796             :     setlocale(LC_CTYPE, locale_time);
     797             : #endif
     798             : 
     799          44 :     setlocale(LC_TIME, locale_time);
     800             : 
     801             :     /* We use times close to current time as data for strftime(). */
     802          44 :     timenow = time(NULL);
     803          44 :     timeinfo = localtime(&timenow);
     804             : 
     805             :     /* Store the strftime results in MAX_L10N_DATA-sized portions of buf[] */
     806          44 :     bufptr = buf;
     807             : 
     808             :     /*
     809             :      * MAX_L10N_DATA is sufficient buffer space for every known locale, and
     810             :      * POSIX defines no strftime() errors.  (Buffer space exhaustion is not an
     811             :      * error.)  An implementation might report errors (e.g. ENOMEM) by
     812             :      * returning 0 (or, less plausibly, a negative value) and setting errno.
     813             :      * Report errno just in case the implementation did that, but clear it in
     814             :      * advance of the calls so we don't emit a stale, unrelated errno.
     815             :      */
     816          44 :     errno = 0;
     817             : 
     818             :     /* localized days */
     819         352 :     for (i = 0; i < 7; i++)
     820             :     {
     821         308 :         timeinfo->tm_wday = i;
     822         308 :         if (strftime(bufptr, MAX_L10N_DATA, "%a", timeinfo) <= 0)
     823           0 :             strftimefail = true;
     824         308 :         bufptr += MAX_L10N_DATA;
     825         308 :         if (strftime(bufptr, MAX_L10N_DATA, "%A", timeinfo) <= 0)
     826           0 :             strftimefail = true;
     827         308 :         bufptr += MAX_L10N_DATA;
     828             :     }
     829             : 
     830             :     /* localized months */
     831         572 :     for (i = 0; i < 12; i++)
     832             :     {
     833         528 :         timeinfo->tm_mon = i;
     834         528 :         timeinfo->tm_mday = 1;   /* make sure we don't have invalid date */
     835         528 :         if (strftime(bufptr, MAX_L10N_DATA, "%b", timeinfo) <= 0)
     836           0 :             strftimefail = true;
     837         528 :         bufptr += MAX_L10N_DATA;
     838         528 :         if (strftime(bufptr, MAX_L10N_DATA, "%B", timeinfo) <= 0)
     839           0 :             strftimefail = true;
     840         528 :         bufptr += MAX_L10N_DATA;
     841             :     }
     842             : 
     843             :     /*
     844             :      * Restore the prevailing locale settings; as in PGLC_localeconv(),
     845             :      * failure to do so is fatal.
     846             :      */
     847             : #ifdef WIN32
     848             :     if (!setlocale(LC_CTYPE, save_lc_ctype))
     849             :         elog(FATAL, "failed to restore LC_CTYPE to \"%s\"", save_lc_ctype);
     850             : #endif
     851          44 :     if (!setlocale(LC_TIME, save_lc_time))
     852           0 :         elog(FATAL, "failed to restore LC_TIME to \"%s\"", save_lc_time);
     853             : 
     854             :     /*
     855             :      * At this point we've done our best to clean up, and can throw errors, or
     856             :      * call functions that might throw errors, with a clean conscience.
     857             :      */
     858          44 :     if (strftimefail)
     859           0 :         elog(ERROR, "strftime() failed: %m");
     860             : 
     861             :     /* Release the pstrdup'd locale names */
     862          44 :     pfree(save_lc_time);
     863             : #ifdef WIN32
     864             :     pfree(save_lc_ctype);
     865             : #endif
     866             : 
     867             : #ifndef WIN32
     868             : 
     869             :     /*
     870             :      * As in PGLC_localeconv(), we must convert strftime()'s output from the
     871             :      * encoding implied by LC_TIME to the database encoding.  If we can't
     872             :      * identify the LC_TIME encoding, just perform encoding validation.
     873             :      */
     874          44 :     encoding = pg_get_encoding_from_locale(locale_time, true);
     875          44 :     if (encoding < 0)
     876           0 :         encoding = PG_SQL_ASCII;
     877             : 
     878             : #else
     879             : 
     880             :     /*
     881             :      * On Windows, strftime_win32() always returns UTF8 data, so convert from
     882             :      * that if necessary.
     883             :      */
     884             :     encoding = PG_UTF8;
     885             : 
     886             : #endif                          /* WIN32 */
     887             : 
     888          44 :     bufptr = buf;
     889             : 
     890             :     /* localized days */
     891         352 :     for (i = 0; i < 7; i++)
     892             :     {
     893         308 :         cache_single_string(&localized_abbrev_days[i], bufptr, encoding);
     894         308 :         bufptr += MAX_L10N_DATA;
     895         308 :         cache_single_string(&localized_full_days[i], bufptr, encoding);
     896         308 :         bufptr += MAX_L10N_DATA;
     897             :     }
     898          44 :     localized_abbrev_days[7] = NULL;
     899          44 :     localized_full_days[7] = NULL;
     900             : 
     901             :     /* localized months */
     902         572 :     for (i = 0; i < 12; i++)
     903             :     {
     904         528 :         cache_single_string(&localized_abbrev_months[i], bufptr, encoding);
     905         528 :         bufptr += MAX_L10N_DATA;
     906         528 :         cache_single_string(&localized_full_months[i], bufptr, encoding);
     907         528 :         bufptr += MAX_L10N_DATA;
     908             :     }
     909          44 :     localized_abbrev_months[12] = NULL;
     910          44 :     localized_full_months[12] = NULL;
     911             : 
     912          44 :     CurrentLCTimeValid = true;
     913             : }
     914             : 
     915             : 
     916             : #if defined(WIN32) && defined(LC_MESSAGES)
     917             : /*
     918             :  * Convert a Windows setlocale() argument to a Unix-style one.
     919             :  *
     920             :  * Regardless of platform, we install message catalogs under a Unix-style
     921             :  * LL[_CC][.ENCODING][@VARIANT] naming convention.  Only LC_MESSAGES settings
     922             :  * following that style will elicit localized interface strings.
     923             :  *
     924             :  * Before Visual Studio 2012 (msvcr110.dll), Windows setlocale() accepted "C"
     925             :  * (but not "c") and strings of the form <Language>[_<Country>][.<CodePage>],
     926             :  * case-insensitive.  setlocale() returns the fully-qualified form; for
     927             :  * example, setlocale("thaI") returns "Thai_Thailand.874".  Internally,
     928             :  * setlocale() and _create_locale() select a "locale identifier"[1] and store
     929             :  * it in an undocumented _locale_t field.  From that LCID, we can retrieve the
     930             :  * ISO 639 language and the ISO 3166 country.  Character encoding does not
     931             :  * matter, because the server and client encodings govern that.
     932             :  *
     933             :  * Windows Vista introduced the "locale name" concept[2], closely following
     934             :  * RFC 4646.  Locale identifiers are now deprecated.  Starting with Visual
     935             :  * Studio 2012, setlocale() accepts locale names in addition to the strings it
     936             :  * accepted historically.  It does not standardize them; setlocale("Th-tH")
     937             :  * returns "Th-tH".  setlocale(category, "") still returns a traditional
     938             :  * string.  Furthermore, msvcr110.dll changed the undocumented _locale_t
     939             :  * content to carry locale names instead of locale identifiers.
     940             :  *
     941             :  * Visual Studio 2015 should still be able to do the same as Visual Studio
     942             :  * 2012, but the declaration of locale_name is missing in _locale_t, causing
     943             :  * this code compilation to fail, hence this falls back instead on to
     944             :  * enumerating all system locales by using EnumSystemLocalesEx to find the
     945             :  * required locale name.  If the input argument is in Unix-style then we can
     946             :  * get ISO Locale name directly by using GetLocaleInfoEx() with LCType as
     947             :  * LOCALE_SNAME.
     948             :  *
     949             :  * MinGW headers declare _create_locale(), but msvcrt.dll lacks that symbol in
     950             :  * releases before Windows 8. IsoLocaleName() always fails in a MinGW-built
     951             :  * postgres.exe, so only Unix-style values of the lc_messages GUC can elicit
     952             :  * localized messages. In particular, every lc_messages setting that initdb
     953             :  * can select automatically will yield only C-locale messages. XXX This could
     954             :  * be fixed by running the fully-qualified locale name through a lookup table.
     955             :  *
     956             :  * This function returns a pointer to a static buffer bearing the converted
     957             :  * name or NULL if conversion fails.
     958             :  *
     959             :  * [1] https://docs.microsoft.com/en-us/windows/win32/intl/locale-identifiers
     960             :  * [2] https://docs.microsoft.com/en-us/windows/win32/intl/locale-names
     961             :  */
     962             : 
     963             : #if _MSC_VER >= 1900
     964             : /*
     965             :  * Callback function for EnumSystemLocalesEx() in get_iso_localename().
     966             :  *
     967             :  * This function enumerates all system locales, searching for one that matches
     968             :  * an input with the format: <Language>[_<Country>], e.g.
     969             :  * English[_United States]
     970             :  *
     971             :  * The input is a three wchar_t array as an LPARAM. The first element is the
     972             :  * locale_name we want to match, the second element is an allocated buffer
     973             :  * where the Unix-style locale is copied if a match is found, and the third
     974             :  * element is the search status, 1 if a match was found, 0 otherwise.
     975             :  */
     976             : static BOOL CALLBACK
     977             : search_locale_enum(LPWSTR pStr, DWORD dwFlags, LPARAM lparam)
     978             : {
     979             :     wchar_t     test_locale[LOCALE_NAME_MAX_LENGTH];
     980             :     wchar_t   **argv;
     981             : 
     982             :     (void) (dwFlags);
     983             : 
     984             :     argv = (wchar_t **) lparam;
     985             :     *argv[2] = (wchar_t) 0;
     986             : 
     987             :     memset(test_locale, 0, sizeof(test_locale));
     988             : 
     989             :     /* Get the name of the <Language> in English */
     990             :     if (GetLocaleInfoEx(pStr, LOCALE_SENGLISHLANGUAGENAME,
     991             :                         test_locale, LOCALE_NAME_MAX_LENGTH))
     992             :     {
     993             :         /*
     994             :          * If the enumerated locale does not have a hyphen ("en") OR the
     995             :          * lc_message input does not have an underscore ("English"), we only
     996             :          * need to compare the <Language> tags.
     997             :          */
     998             :         if (wcsrchr(pStr, '-') == NULL || wcsrchr(argv[0], '_') == NULL)
     999             :         {
    1000             :             if (_wcsicmp(argv[0], test_locale) == 0)
    1001             :             {
    1002             :                 wcscpy(argv[1], pStr);
    1003             :                 *argv[2] = (wchar_t) 1;
    1004             :                 return FALSE;
    1005             :             }
    1006             :         }
    1007             : 
    1008             :         /*
    1009             :          * We have to compare a full <Language>_<Country> tag, so we append
    1010             :          * the underscore and name of the country/region in English, e.g.
    1011             :          * "English_United States".
    1012             :          */
    1013             :         else
    1014             :         {
    1015             :             size_t      len;
    1016             : 
    1017             :             wcscat(test_locale, L"_");
    1018             :             len = wcslen(test_locale);
    1019             :             if (GetLocaleInfoEx(pStr, LOCALE_SENGLISHCOUNTRYNAME,
    1020             :                                 test_locale + len,
    1021             :                                 LOCALE_NAME_MAX_LENGTH - len))
    1022             :             {
    1023             :                 if (_wcsicmp(argv[0], test_locale) == 0)
    1024             :                 {
    1025             :                     wcscpy(argv[1], pStr);
    1026             :                     *argv[2] = (wchar_t) 1;
    1027             :                     return FALSE;
    1028             :                 }
    1029             :             }
    1030             :         }
    1031             :     }
    1032             : 
    1033             :     return TRUE;
    1034             : }
    1035             : 
    1036             : /*
    1037             :  * This function converts a Windows locale name to an ISO formatted version
    1038             :  * for Visual Studio 2015 or greater.
    1039             :  *
    1040             :  * Returns NULL, if no valid conversion was found.
    1041             :  */
    1042             : static char *
    1043             : get_iso_localename(const char *winlocname)
    1044             : {
    1045             :     wchar_t     wc_locale_name[LOCALE_NAME_MAX_LENGTH];
    1046             :     wchar_t     buffer[LOCALE_NAME_MAX_LENGTH];
    1047             :     static char iso_lc_messages[LOCALE_NAME_MAX_LENGTH];
    1048             :     char       *period;
    1049             :     int         len;
    1050             :     int         ret_val;
    1051             : 
    1052             :     /*
    1053             :      * Valid locales have the following syntax:
    1054             :      * <Language>[_<Country>[.<CodePage>]]
    1055             :      *
    1056             :      * GetLocaleInfoEx can only take locale name without code-page and for the
    1057             :      * purpose of this API the code-page doesn't matter.
    1058             :      */
    1059             :     period = strchr(winlocname, '.');
    1060             :     if (period != NULL)
    1061             :         len = period - winlocname;
    1062             :     else
    1063             :         len = pg_mbstrlen(winlocname);
    1064             : 
    1065             :     memset(wc_locale_name, 0, sizeof(wc_locale_name));
    1066             :     memset(buffer, 0, sizeof(buffer));
    1067             :     MultiByteToWideChar(CP_ACP, 0, winlocname, len, wc_locale_name,
    1068             :                         LOCALE_NAME_MAX_LENGTH);
    1069             : 
    1070             :     /*
    1071             :      * If the lc_messages is already a Unix-style string, we have a direct
    1072             :      * match with LOCALE_SNAME, e.g. en-US, en_US.
    1073             :      */
    1074             :     ret_val = GetLocaleInfoEx(wc_locale_name, LOCALE_SNAME, (LPWSTR) &buffer,
    1075             :                               LOCALE_NAME_MAX_LENGTH);
    1076             :     if (!ret_val)
    1077             :     {
    1078             :         /*
    1079             :          * Search for a locale in the system that matches language and country
    1080             :          * name.
    1081             :          */
    1082             :         wchar_t    *argv[3];
    1083             : 
    1084             :         argv[0] = wc_locale_name;
    1085             :         argv[1] = buffer;
    1086             :         argv[2] = (wchar_t *) &ret_val;
    1087             :         EnumSystemLocalesEx(search_locale_enum, LOCALE_WINDOWS, (LPARAM) argv,
    1088             :                             NULL);
    1089             :     }
    1090             : 
    1091             :     if (ret_val)
    1092             :     {
    1093             :         size_t      rc;
    1094             :         char       *hyphen;
    1095             : 
    1096             :         /* Locale names use only ASCII, any conversion locale suffices. */
    1097             :         rc = wchar2char(iso_lc_messages, buffer, sizeof(iso_lc_messages), NULL);
    1098             :         if (rc == -1 || rc == sizeof(iso_lc_messages))
    1099             :             return NULL;
    1100             : 
    1101             :         /*
    1102             :          * Simply replace the hyphen with an underscore.  See comments in
    1103             :          * IsoLocaleName.
    1104             :          */
    1105             :         hyphen = strchr(iso_lc_messages, '-');
    1106             :         if (hyphen)
    1107             :             *hyphen = '_';
    1108             :         return iso_lc_messages;
    1109             :     }
    1110             : 
    1111             :     return NULL;
    1112             : }
    1113             : #endif                          /* _MSC_VER >= 1900 */
    1114             : 
    1115             : static char *
    1116             : IsoLocaleName(const char *winlocname)
    1117             : {
    1118             : #if defined(_MSC_VER)
    1119             :     static char iso_lc_messages[LOCALE_NAME_MAX_LENGTH];
    1120             : 
    1121             :     if (pg_strcasecmp("c", winlocname) == 0 ||
    1122             :         pg_strcasecmp("posix", winlocname) == 0)
    1123             :     {
    1124             :         strcpy(iso_lc_messages, "C");
    1125             :         return iso_lc_messages;
    1126             :     }
    1127             :     else
    1128             :     {
    1129             : #if (_MSC_VER >= 1900)           /* Visual Studio 2015 or later */
    1130             :         return get_iso_localename(winlocname);
    1131             : #else
    1132             :         _locale_t   loct;
    1133             : 
    1134             :         loct = _create_locale(LC_CTYPE, winlocname);
    1135             :         if (loct != NULL)
    1136             :         {
    1137             :             size_t      rc;
    1138             :             char       *hyphen;
    1139             : 
    1140             :             /* Locale names use only ASCII, any conversion locale suffices. */
    1141             :             rc = wchar2char(iso_lc_messages, loct->locinfo->locale_name[LC_CTYPE],
    1142             :                             sizeof(iso_lc_messages), NULL);
    1143             :             _free_locale(loct);
    1144             :             if (rc == -1 || rc == sizeof(iso_lc_messages))
    1145             :                 return NULL;
    1146             : 
    1147             :             /*
    1148             :              * Since the message catalogs sit on a case-insensitive
    1149             :              * filesystem, we need not standardize letter case here.  So long
    1150             :              * as we do not ship message catalogs for which it would matter,
    1151             :              * we also need not translate the script/variant portion, e.g.
    1152             :              * uz-Cyrl-UZ to uz_UZ@cyrillic.  Simply replace the hyphen with
    1153             :              * an underscore.
    1154             :              *
    1155             :              * Note that the locale name can be less-specific than the value
    1156             :              * we would derive under earlier Visual Studio releases.  For
    1157             :              * example, French_France.1252 yields just "fr".  This does not
    1158             :              * affect any of the country-specific message catalogs available
    1159             :              * as of this writing (pt_BR, zh_CN, zh_TW).
    1160             :              */
    1161             :             hyphen = strchr(iso_lc_messages, '-');
    1162             :             if (hyphen)
    1163             :                 *hyphen = '_';
    1164             :             return iso_lc_messages;
    1165             :         }
    1166             : #endif                          /* Visual Studio 2015 or later */
    1167             :     }
    1168             : #endif                          /* defined(_MSC_VER) */
    1169             :     return NULL;                /* Not supported on this version of msvc/mingw */
    1170             : }
    1171             : #endif                          /* WIN32 && LC_MESSAGES */
    1172             : 
    1173             : 
    1174             : /*
    1175             :  * Detect aging strxfrm() implementations that, in a subset of locales, write
    1176             :  * past the specified buffer length.  Affected users must update OS packages
    1177             :  * before using PostgreSQL 9.5 or later.
    1178             :  *
    1179             :  * Assume that the bug can come and go from one postmaster startup to another
    1180             :  * due to physical replication among diverse machines.  Assume that the bug's
    1181             :  * presence will not change during the life of a particular postmaster.  Given
    1182             :  * those assumptions, call this no less than once per postmaster startup per
    1183             :  * LC_COLLATE setting used.  No known-affected system offers strxfrm_l(), so
    1184             :  * there is no need to consider pg_collation locales.
    1185             :  */
    1186             : void
    1187       22582 : check_strxfrm_bug(void)
    1188             : {
    1189             :     char        buf[32];
    1190       22582 :     const int   canary = 0x7F;
    1191       22582 :     bool        ok = true;
    1192             : 
    1193             :     /*
    1194             :      * Given a two-byte ASCII string and length limit 7, 8 or 9, Solaris 10
    1195             :      * 05/08 returns 18 and modifies 10 bytes.  It respects limits above or
    1196             :      * below that range.
    1197             :      *
    1198             :      * The bug is present in Solaris 8 as well; it is absent in Solaris 10
    1199             :      * 01/13 and Solaris 11.2.  Affected locales include is_IS.ISO8859-1,
    1200             :      * en_US.UTF-8, en_US.ISO8859-1, and ru_RU.KOI8-R.  Unaffected locales
    1201             :      * include de_DE.UTF-8, de_DE.ISO8859-1, zh_TW.UTF-8, and C.
    1202             :      */
    1203       22582 :     buf[7] = canary;
    1204       22582 :     (void) strxfrm(buf, "ab", 7);
    1205       22582 :     if (buf[7] != canary)
    1206           0 :         ok = false;
    1207             : 
    1208             :     /*
    1209             :      * illumos bug #1594 was present in the source tree from 2010-10-11 to
    1210             :      * 2012-02-01.  Given an ASCII string of any length and length limit 1,
    1211             :      * affected systems ignore the length limit and modify a number of bytes
    1212             :      * one less than the return value.  The problem inputs for this bug do not
    1213             :      * overlap those for the Solaris bug, hence a distinct test.
    1214             :      *
    1215             :      * Affected systems include smartos-20110926T021612Z.  Affected locales
    1216             :      * include en_US.ISO8859-1 and en_US.UTF-8.  Unaffected locales include C.
    1217             :      */
    1218       22582 :     buf[1] = canary;
    1219       22582 :     (void) strxfrm(buf, "a", 1);
    1220       22582 :     if (buf[1] != canary)
    1221           0 :         ok = false;
    1222             : 
    1223       22582 :     if (!ok)
    1224           0 :         ereport(ERROR,
    1225             :                 (errcode(ERRCODE_SYSTEM_ERROR),
    1226             :                  errmsg_internal("strxfrm(), in locale \"%s\", writes past the specified array length",
    1227             :                                  setlocale(LC_COLLATE, NULL)),
    1228             :                  errhint("Apply system library package updates.")));
    1229       22582 : }
    1230             : 
    1231             : 
    1232             : /*
    1233             :  * Cache mechanism for collation information.
    1234             :  *
    1235             :  * We cache two flags: whether the collation's LC_COLLATE or LC_CTYPE is C
    1236             :  * (or POSIX), so we can optimize a few code paths in various places.
    1237             :  * For the built-in C and POSIX collations, we can know that without even
    1238             :  * doing a cache lookup, but we want to support aliases for C/POSIX too.
    1239             :  * For the "default" collation, there are separate static cache variables,
    1240             :  * since consulting the pg_collation catalog doesn't tell us what we need.
    1241             :  *
    1242             :  * Also, if a pg_locale_t has been requested for a collation, we cache that
    1243             :  * for the life of a backend.
    1244             :  *
    1245             :  * Note that some code relies on the flags not reporting false negatives
    1246             :  * (that is, saying it's not C when it is).  For example, char2wchar()
    1247             :  * could fail if the locale is C, so str_tolower() shouldn't call it
    1248             :  * in that case.
    1249             :  *
    1250             :  * Note that we currently lack any way to flush the cache.  Since we don't
    1251             :  * support ALTER COLLATION, this is OK.  The worst case is that someone
    1252             :  * drops a collation, and a useless cache entry hangs around in existing
    1253             :  * backends.
    1254             :  */
    1255             : 
    1256             : static collation_cache_entry *
    1257          44 : lookup_collation_cache(Oid collation, bool set_flags)
    1258             : {
    1259             :     collation_cache_entry *cache_entry;
    1260             :     bool        found;
    1261             : 
    1262             :     Assert(OidIsValid(collation));
    1263             :     Assert(collation != DEFAULT_COLLATION_OID);
    1264             : 
    1265          44 :     if (collation_cache == NULL)
    1266             :     {
    1267             :         /* First time through, initialize the hash table */
    1268             :         HASHCTL     ctl;
    1269             : 
    1270          16 :         ctl.keysize = sizeof(Oid);
    1271          16 :         ctl.entrysize = sizeof(collation_cache_entry);
    1272          16 :         collation_cache = hash_create("Collation cache", 100, &ctl,
    1273             :                                       HASH_ELEM | HASH_BLOBS);
    1274             :     }
    1275             : 
    1276          44 :     cache_entry = hash_search(collation_cache, &collation, HASH_ENTER, &found);
    1277          44 :     if (!found)
    1278             :     {
    1279             :         /*
    1280             :          * Make sure cache entry is marked invalid, in case we fail before
    1281             :          * setting things.
    1282             :          */
    1283          22 :         cache_entry->flags_valid = false;
    1284          22 :         cache_entry->locale = 0;
    1285             :     }
    1286             : 
    1287          44 :     if (set_flags && !cache_entry->flags_valid)
    1288             :     {
    1289             :         /* Attempt to set the flags */
    1290             :         HeapTuple   tp;
    1291             :         Form_pg_collation collform;
    1292             : 
    1293          22 :         tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collation));
    1294          22 :         if (!HeapTupleIsValid(tp))
    1295           0 :             elog(ERROR, "cache lookup failed for collation %u", collation);
    1296          22 :         collform = (Form_pg_collation) GETSTRUCT(tp);
    1297             : 
    1298          22 :         if (collform->collprovider == COLLPROVIDER_LIBC)
    1299             :         {
    1300             :             Datum       datum;
    1301             :             bool        isnull;
    1302             :             const char *collcollate;
    1303             :             const char *collctype;
    1304             : 
    1305          22 :             datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collcollate, &isnull);
    1306             :             Assert(!isnull);
    1307          22 :             collcollate = TextDatumGetCString(datum);
    1308          22 :             datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collctype, &isnull);
    1309             :             Assert(!isnull);
    1310          22 :             collctype = TextDatumGetCString(datum);
    1311             : 
    1312          28 :             cache_entry->collate_is_c = ((strcmp(collcollate, "C") == 0) ||
    1313           6 :                                          (strcmp(collcollate, "POSIX") == 0));
    1314          28 :             cache_entry->ctype_is_c = ((strcmp(collctype, "C") == 0) ||
    1315           6 :                                        (strcmp(collctype, "POSIX") == 0));
    1316             :         }
    1317             :         else
    1318             :         {
    1319           0 :             cache_entry->collate_is_c = false;
    1320           0 :             cache_entry->ctype_is_c = false;
    1321             :         }
    1322             : 
    1323          22 :         cache_entry->flags_valid = true;
    1324             : 
    1325          22 :         ReleaseSysCache(tp);
    1326             :     }
    1327             : 
    1328          44 :     return cache_entry;
    1329             : }
    1330             : 
    1331             : 
    1332             : /*
    1333             :  * Detect whether collation's LC_COLLATE property is C
    1334             :  */
    1335             : bool
    1336    17824644 : lc_collate_is_c(Oid collation)
    1337             : {
    1338             :     /*
    1339             :      * If we're asked about "collation 0", return false, so that the code will
    1340             :      * go into the non-C path and report that the collation is bogus.
    1341             :      */
    1342    17824644 :     if (!OidIsValid(collation))
    1343           0 :         return false;
    1344             : 
    1345             :     /*
    1346             :      * If we're asked about the default collation, we have to inquire of the C
    1347             :      * library.  Cache the result so we only have to compute it once.
    1348             :      */
    1349    17824644 :     if (collation == DEFAULT_COLLATION_OID)
    1350             :     {
    1351             :         static int  result = -1;
    1352             :         char       *localeptr;
    1353             : 
    1354    12086504 :         if (default_locale.provider == COLLPROVIDER_ICU)
    1355           0 :             return false;
    1356             : 
    1357    12086504 :         if (result >= 0)
    1358    12082656 :             return (bool) result;
    1359        3848 :         localeptr = setlocale(LC_COLLATE, NULL);
    1360        3848 :         if (!localeptr)
    1361           0 :             elog(ERROR, "invalid LC_COLLATE setting");
    1362             : 
    1363        3848 :         if (strcmp(localeptr, "C") == 0)
    1364          62 :             result = true;
    1365        3786 :         else if (strcmp(localeptr, "POSIX") == 0)
    1366           0 :             result = true;
    1367             :         else
    1368        3786 :             result = false;
    1369        3848 :         return (bool) result;
    1370             :     }
    1371             : 
    1372             :     /*
    1373             :      * If we're asked about the built-in C/POSIX collations, we know that.
    1374             :      */
    1375     5738140 :     if (collation == C_COLLATION_OID ||
    1376             :         collation == POSIX_COLLATION_OID)
    1377     5738118 :         return true;
    1378             : 
    1379             :     /*
    1380             :      * Otherwise, we have to consult pg_collation, but we cache that.
    1381             :      */
    1382          22 :     return (lookup_collation_cache(collation, true))->collate_is_c;
    1383             : }
    1384             : 
    1385             : /*
    1386             :  * Detect whether collation's LC_CTYPE property is C
    1387             :  */
    1388             : bool
    1389     5472714 : lc_ctype_is_c(Oid collation)
    1390             : {
    1391             :     /*
    1392             :      * If we're asked about "collation 0", return false, so that the code will
    1393             :      * go into the non-C path and report that the collation is bogus.
    1394             :      */
    1395     5472714 :     if (!OidIsValid(collation))
    1396           0 :         return false;
    1397             : 
    1398             :     /*
    1399             :      * If we're asked about the default collation, we have to inquire of the C
    1400             :      * library.  Cache the result so we only have to compute it once.
    1401             :      */
    1402     5472714 :     if (collation == DEFAULT_COLLATION_OID)
    1403             :     {
    1404             :         static int  result = -1;
    1405             :         char       *localeptr;
    1406             : 
    1407     3030762 :         if (default_locale.provider == COLLPROVIDER_ICU)
    1408           0 :             return false;
    1409             : 
    1410     3030762 :         if (result >= 0)
    1411     3029596 :             return (bool) result;
    1412        1166 :         localeptr = setlocale(LC_CTYPE, NULL);
    1413        1166 :         if (!localeptr)
    1414           0 :             elog(ERROR, "invalid LC_CTYPE setting");
    1415             : 
    1416        1166 :         if (strcmp(localeptr, "C") == 0)
    1417          24 :             result = true;
    1418        1142 :         else if (strcmp(localeptr, "POSIX") == 0)
    1419           0 :             result = true;
    1420             :         else
    1421        1142 :             result = false;
    1422        1166 :         return (bool) result;
    1423             :     }
    1424             : 
    1425             :     /*
    1426             :      * If we're asked about the built-in C/POSIX collations, we know that.
    1427             :      */
    1428     2441952 :     if (collation == C_COLLATION_OID ||
    1429             :         collation == POSIX_COLLATION_OID)
    1430     2441930 :         return true;
    1431             : 
    1432             :     /*
    1433             :      * Otherwise, we have to consult pg_collation, but we cache that.
    1434             :      */
    1435          22 :     return (lookup_collation_cache(collation, true))->ctype_is_c;
    1436             : }
    1437             : 
    1438             : struct pg_locale_struct default_locale;
    1439             : 
    1440             : void
    1441           0 : make_icu_collator(const char *iculocstr,
    1442             :                   struct pg_locale_struct *resultp)
    1443             : {
    1444             : #ifdef USE_ICU
    1445             :     UCollator  *collator;
    1446             :     UErrorCode  status;
    1447             : 
    1448             :     status = U_ZERO_ERROR;
    1449             :     collator = ucol_open(iculocstr, &status);
    1450             :     if (U_FAILURE(status))
    1451             :         ereport(ERROR,
    1452             :                 (errmsg("could not open collator for locale \"%s\": %s",
    1453             :                         iculocstr, u_errorName(status))));
    1454             : 
    1455             :     if (U_ICU_VERSION_MAJOR_NUM < 54)
    1456             :         icu_set_collation_attributes(collator, iculocstr);
    1457             : 
    1458             :     /* We will leak this string if the caller errors later :-( */
    1459             :     resultp->info.icu.locale = MemoryContextStrdup(TopMemoryContext, iculocstr);
    1460             :     resultp->info.icu.ucol = collator;
    1461             : #else                           /* not USE_ICU */
    1462             :     /* could get here if a collation was created by a build with ICU */
    1463           0 :     ereport(ERROR,
    1464             :             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1465             :              errmsg("ICU is not supported in this build")));
    1466             : #endif                          /* not USE_ICU */
    1467             : }
    1468             : 
    1469             : 
    1470             : /* simple subroutine for reporting errors from newlocale() */
    1471             : #ifdef HAVE_LOCALE_T
    1472             : static void
    1473           0 : report_newlocale_failure(const char *localename)
    1474             : {
    1475             :     int         save_errno;
    1476             : 
    1477             :     /*
    1478             :      * Windows doesn't provide any useful error indication from
    1479             :      * _create_locale(), and BSD-derived platforms don't seem to feel they
    1480             :      * need to set errno either (even though POSIX is pretty clear that
    1481             :      * newlocale should do so).  So, if errno hasn't been set, assume ENOENT
    1482             :      * is what to report.
    1483             :      */
    1484           0 :     if (errno == 0)
    1485           0 :         errno = ENOENT;
    1486             : 
    1487             :     /*
    1488             :      * ENOENT means "no such locale", not "no such file", so clarify that
    1489             :      * errno with an errdetail message.
    1490             :      */
    1491           0 :     save_errno = errno;         /* auxiliary funcs might change errno */
    1492           0 :     ereport(ERROR,
    1493             :             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1494             :              errmsg("could not create locale \"%s\": %m",
    1495             :                     localename),
    1496             :              (save_errno == ENOENT ?
    1497             :               errdetail("The operating system could not find any locale data for the locale name \"%s\".",
    1498             :                         localename) : 0)));
    1499             : }
    1500             : #endif                          /* HAVE_LOCALE_T */
    1501             : 
    1502             : 
    1503             : /*
    1504             :  * Create a locale_t from a collation OID.  Results are cached for the
    1505             :  * lifetime of the backend.  Thus, do not free the result with freelocale().
    1506             :  *
    1507             :  * As a special optimization, the default/database collation returns 0.
    1508             :  * Callers should then revert to the non-locale_t-enabled code path.
    1509             :  * Also, callers should avoid calling this before going down a C/POSIX
    1510             :  * fastpath, because such a fastpath should work even on platforms without
    1511             :  * locale_t support in the C library.
    1512             :  *
    1513             :  * For simplicity, we always generate COLLATE + CTYPE even though we
    1514             :  * might only need one of them.  Since this is called only once per session,
    1515             :  * it shouldn't cost much.
    1516             :  */
    1517             : pg_locale_t
    1518    14787358 : pg_newlocale_from_collation(Oid collid)
    1519             : {
    1520             :     collation_cache_entry *cache_entry;
    1521             : 
    1522             :     /* Callers must pass a valid OID */
    1523             :     Assert(OidIsValid(collid));
    1524             : 
    1525    14787358 :     if (collid == DEFAULT_COLLATION_OID)
    1526             :     {
    1527    14787358 :         if (default_locale.provider == COLLPROVIDER_ICU)
    1528           0 :             return &default_locale;
    1529             :         else
    1530    14787358 :             return (pg_locale_t) 0;
    1531             :     }
    1532             : 
    1533           0 :     cache_entry = lookup_collation_cache(collid, false);
    1534             : 
    1535           0 :     if (cache_entry->locale == 0)
    1536             :     {
    1537             :         /* We haven't computed this yet in this session, so do it */
    1538             :         HeapTuple   tp;
    1539             :         Form_pg_collation collform;
    1540             :         struct pg_locale_struct result;
    1541             :         pg_locale_t resultp;
    1542             :         Datum       datum;
    1543             :         bool        isnull;
    1544             : 
    1545           0 :         tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
    1546           0 :         if (!HeapTupleIsValid(tp))
    1547           0 :             elog(ERROR, "cache lookup failed for collation %u", collid);
    1548           0 :         collform = (Form_pg_collation) GETSTRUCT(tp);
    1549             : 
    1550             :         /* We'll fill in the result struct locally before allocating memory */
    1551           0 :         memset(&result, 0, sizeof(result));
    1552           0 :         result.provider = collform->collprovider;
    1553           0 :         result.deterministic = collform->collisdeterministic;
    1554             : 
    1555           0 :         if (collform->collprovider == COLLPROVIDER_LIBC)
    1556             :         {
    1557             : #ifdef HAVE_LOCALE_T
    1558             :             const char *collcollate;
    1559             :             const char *collctype pg_attribute_unused();
    1560             :             locale_t    loc;
    1561             : 
    1562           0 :             datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collcollate, &isnull);
    1563             :             Assert(!isnull);
    1564           0 :             collcollate = TextDatumGetCString(datum);
    1565           0 :             datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collctype, &isnull);
    1566             :             Assert(!isnull);
    1567           0 :             collctype = TextDatumGetCString(datum);
    1568             : 
    1569           0 :             if (strcmp(collcollate, collctype) == 0)
    1570             :             {
    1571             :                 /* Normal case where they're the same */
    1572           0 :                 errno = 0;
    1573             : #ifndef WIN32
    1574           0 :                 loc = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collcollate,
    1575             :                                 NULL);
    1576             : #else
    1577             :                 loc = _create_locale(LC_ALL, collcollate);
    1578             : #endif
    1579           0 :                 if (!loc)
    1580           0 :                     report_newlocale_failure(collcollate);
    1581             :             }
    1582             :             else
    1583             :             {
    1584             : #ifndef WIN32
    1585             :                 /* We need two newlocale() steps */
    1586             :                 locale_t    loc1;
    1587             : 
    1588           0 :                 errno = 0;
    1589           0 :                 loc1 = newlocale(LC_COLLATE_MASK, collcollate, NULL);
    1590           0 :                 if (!loc1)
    1591           0 :                     report_newlocale_failure(collcollate);
    1592           0 :                 errno = 0;
    1593           0 :                 loc = newlocale(LC_CTYPE_MASK, collctype, loc1);
    1594           0 :                 if (!loc)
    1595           0 :                     report_newlocale_failure(collctype);
    1596             : #else
    1597             : 
    1598             :                 /*
    1599             :                  * XXX The _create_locale() API doesn't appear to support
    1600             :                  * this. Could perhaps be worked around by changing
    1601             :                  * pg_locale_t to contain two separate fields.
    1602             :                  */
    1603             :                 ereport(ERROR,
    1604             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1605             :                          errmsg("collations with different collate and ctype values are not supported on this platform")));
    1606             : #endif
    1607             :             }
    1608             : 
    1609           0 :             result.info.lt = loc;
    1610             : #else                           /* not HAVE_LOCALE_T */
    1611             :             /* platform that doesn't support locale_t */
    1612             :             ereport(ERROR,
    1613             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1614             :                      errmsg("collation provider LIBC is not supported on this platform")));
    1615             : #endif                          /* not HAVE_LOCALE_T */
    1616             :         }
    1617           0 :         else if (collform->collprovider == COLLPROVIDER_ICU)
    1618             :         {
    1619             :             const char *iculocstr;
    1620             : 
    1621           0 :             datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_colliculocale, &isnull);
    1622             :             Assert(!isnull);
    1623           0 :             iculocstr = TextDatumGetCString(datum);
    1624           0 :             make_icu_collator(iculocstr, &result);
    1625             :         }
    1626             : 
    1627           0 :         datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collversion,
    1628             :                                 &isnull);
    1629           0 :         if (!isnull)
    1630             :         {
    1631             :             char       *actual_versionstr;
    1632             :             char       *collversionstr;
    1633             : 
    1634           0 :             collversionstr = TextDatumGetCString(datum);
    1635             : 
    1636           0 :             datum = SysCacheGetAttr(COLLOID, tp, collform->collprovider == COLLPROVIDER_ICU ? Anum_pg_collation_colliculocale : Anum_pg_collation_collcollate, &isnull);
    1637             :             Assert(!isnull);
    1638             : 
    1639           0 :             actual_versionstr = get_collation_actual_version(collform->collprovider,
    1640           0 :                                                              TextDatumGetCString(datum));
    1641           0 :             if (!actual_versionstr)
    1642             :             {
    1643             :                 /*
    1644             :                  * This could happen when specifying a version in CREATE
    1645             :                  * COLLATION but the provider does not support versioning, or
    1646             :                  * manually creating a mess in the catalogs.
    1647             :                  */
    1648           0 :                 ereport(ERROR,
    1649             :                         (errmsg("collation \"%s\" has no actual version, but a version was recorded",
    1650             :                                 NameStr(collform->collname))));
    1651             :             }
    1652             : 
    1653           0 :             if (strcmp(actual_versionstr, collversionstr) != 0)
    1654           0 :                 ereport(WARNING,
    1655             :                         (errmsg("collation \"%s\" has version mismatch",
    1656             :                                 NameStr(collform->collname)),
    1657             :                          errdetail("The collation in the database was created using version %s, "
    1658             :                                    "but the operating system provides version %s.",
    1659             :                                    collversionstr, actual_versionstr),
    1660             :                          errhint("Rebuild all objects affected by this collation and run "
    1661             :                                  "ALTER COLLATION %s REFRESH VERSION, "
    1662             :                                  "or build PostgreSQL with the right library version.",
    1663             :                                  quote_qualified_identifier(get_namespace_name(collform->collnamespace),
    1664             :                                                             NameStr(collform->collname)))));
    1665             :         }
    1666             : 
    1667           0 :         ReleaseSysCache(tp);
    1668             : 
    1669             :         /* We'll keep the pg_locale_t structures in TopMemoryContext */
    1670           0 :         resultp = MemoryContextAlloc(TopMemoryContext, sizeof(*resultp));
    1671           0 :         *resultp = result;
    1672             : 
    1673           0 :         cache_entry->locale = resultp;
    1674             :     }
    1675             : 
    1676           0 :     return cache_entry->locale;
    1677             : }
    1678             : 
    1679             : /*
    1680             :  * Get provider-specific collation version string for the given collation from
    1681             :  * the operating system/library.
    1682             :  */
    1683             : char *
    1684       20748 : get_collation_actual_version(char collprovider, const char *collcollate)
    1685             : {
    1686       20748 :     char       *collversion = NULL;
    1687             : 
    1688             : #ifdef USE_ICU
    1689             :     if (collprovider == COLLPROVIDER_ICU)
    1690             :     {
    1691             :         UCollator  *collator;
    1692             :         UErrorCode  status;
    1693             :         UVersionInfo versioninfo;
    1694             :         char        buf[U_MAX_VERSION_STRING_LENGTH];
    1695             : 
    1696             :         status = U_ZERO_ERROR;
    1697             :         collator = ucol_open(collcollate, &status);
    1698             :         if (U_FAILURE(status))
    1699             :             ereport(ERROR,
    1700             :                     (errmsg("could not open collator for locale \"%s\": %s",
    1701             :                             collcollate, u_errorName(status))));
    1702             :         ucol_getVersion(collator, versioninfo);
    1703             :         ucol_close(collator);
    1704             : 
    1705             :         u_versionToString(versioninfo, buf);
    1706             :         collversion = pstrdup(buf);
    1707             :     }
    1708             :     else
    1709             : #endif
    1710       41496 :         if (collprovider == COLLPROVIDER_LIBC &&
    1711       41360 :             pg_strcasecmp("C", collcollate) != 0 &&
    1712       40160 :             pg_strncasecmp("C.", collcollate, 2) != 0 &&
    1713       19548 :             pg_strcasecmp("POSIX", collcollate) != 0)
    1714             :     {
    1715             : #if defined(__GLIBC__)
    1716             :         /* Use the glibc version because we don't have anything better. */
    1717       19542 :         collversion = pstrdup(gnu_get_libc_version());
    1718             : #elif defined(LC_VERSION_MASK)
    1719             :         locale_t    loc;
    1720             : 
    1721             :         /* Look up FreeBSD collation version. */
    1722             :         loc = newlocale(LC_COLLATE, collcollate, NULL);
    1723             :         if (loc)
    1724             :         {
    1725             :             collversion =
    1726             :                 pstrdup(querylocale(LC_COLLATE_MASK | LC_VERSION_MASK, loc));
    1727             :             freelocale(loc);
    1728             :         }
    1729             :         else
    1730             :             ereport(ERROR,
    1731             :                     (errmsg("could not load locale \"%s\"", collcollate)));
    1732             : #elif defined(WIN32) && _WIN32_WINNT >= 0x0600
    1733             :         /*
    1734             :          * If we are targeting Windows Vista and above, we can ask for a name
    1735             :          * given a collation name (earlier versions required a location code
    1736             :          * that we don't have).
    1737             :          */
    1738             :         NLSVERSIONINFOEX version = {sizeof(NLSVERSIONINFOEX)};
    1739             :         WCHAR       wide_collcollate[LOCALE_NAME_MAX_LENGTH];
    1740             : 
    1741             :         MultiByteToWideChar(CP_ACP, 0, collcollate, -1, wide_collcollate,
    1742             :                             LOCALE_NAME_MAX_LENGTH);
    1743             :         if (!GetNLSVersionEx(COMPARE_STRING, wide_collcollate, &version))
    1744             :         {
    1745             :             /*
    1746             :              * GetNLSVersionEx() wants a language tag such as "en-US", not a
    1747             :              * locale name like "English_United States.1252".  Until those
    1748             :              * values can be prevented from entering the system, or 100%
    1749             :              * reliably converted to the more useful tag format, tolerate the
    1750             :              * resulting error and report that we have no version data.
    1751             :              */
    1752             :             if (GetLastError() == ERROR_INVALID_PARAMETER)
    1753             :                 return NULL;
    1754             : 
    1755             :             ereport(ERROR,
    1756             :                     (errmsg("could not get collation version for locale \"%s\": error code %lu",
    1757             :                             collcollate,
    1758             :                             GetLastError())));
    1759             :         }
    1760             :         collversion = psprintf("%d.%d,%d.%d",
    1761             :                                (version.dwNLSVersion >> 8) & 0xFFFF,
    1762             :                                version.dwNLSVersion & 0xFF,
    1763             :                                (version.dwDefinedVersion >> 8) & 0xFFFF,
    1764             :                                version.dwDefinedVersion & 0xFF);
    1765             : #endif
    1766             :     }
    1767             : 
    1768       20748 :     return collversion;
    1769             : }
    1770             : 
    1771             : 
    1772             : #ifdef USE_ICU
    1773             : /*
    1774             :  * Converter object for converting between ICU's UChar strings and C strings
    1775             :  * in database encoding.  Since the database encoding doesn't change, we only
    1776             :  * need one of these per session.
    1777             :  */
    1778             : static UConverter *icu_converter = NULL;
    1779             : 
    1780             : static void
    1781             : init_icu_converter(void)
    1782             : {
    1783             :     const char *icu_encoding_name;
    1784             :     UErrorCode  status;
    1785             :     UConverter *conv;
    1786             : 
    1787             :     if (icu_converter)
    1788             :         return;                 /* already done */
    1789             : 
    1790             :     icu_encoding_name = get_encoding_name_for_icu(GetDatabaseEncoding());
    1791             :     if (!icu_encoding_name)
    1792             :         ereport(ERROR,
    1793             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1794             :                  errmsg("encoding \"%s\" not supported by ICU",
    1795             :                         pg_encoding_to_char(GetDatabaseEncoding()))));
    1796             : 
    1797             :     status = U_ZERO_ERROR;
    1798             :     conv = ucnv_open(icu_encoding_name, &status);
    1799             :     if (U_FAILURE(status))
    1800             :         ereport(ERROR,
    1801             :                 (errmsg("could not open ICU converter for encoding \"%s\": %s",
    1802             :                         icu_encoding_name, u_errorName(status))));
    1803             : 
    1804             :     icu_converter = conv;
    1805             : }
    1806             : 
    1807             : /*
    1808             :  * Convert a string in the database encoding into a string of UChars.
    1809             :  *
    1810             :  * The source string at buff is of length nbytes
    1811             :  * (it needn't be nul-terminated)
    1812             :  *
    1813             :  * *buff_uchar receives a pointer to the palloc'd result string, and
    1814             :  * the function's result is the number of UChars generated.
    1815             :  *
    1816             :  * The result string is nul-terminated, though most callers rely on the
    1817             :  * result length instead.
    1818             :  */
    1819             : int32_t
    1820             : icu_to_uchar(UChar **buff_uchar, const char *buff, size_t nbytes)
    1821             : {
    1822             :     UErrorCode  status;
    1823             :     int32_t     len_uchar;
    1824             : 
    1825             :     init_icu_converter();
    1826             : 
    1827             :     status = U_ZERO_ERROR;
    1828             :     len_uchar = ucnv_toUChars(icu_converter, NULL, 0,
    1829             :                               buff, nbytes, &status);
    1830             :     if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
    1831             :         ereport(ERROR,
    1832             :                 (errmsg("%s failed: %s", "ucnv_toUChars", u_errorName(status))));
    1833             : 
    1834             :     *buff_uchar = palloc((len_uchar + 1) * sizeof(**buff_uchar));
    1835             : 
    1836             :     status = U_ZERO_ERROR;
    1837             :     len_uchar = ucnv_toUChars(icu_converter, *buff_uchar, len_uchar + 1,
    1838             :                               buff, nbytes, &status);
    1839             :     if (U_FAILURE(status))
    1840             :         ereport(ERROR,
    1841             :                 (errmsg("%s failed: %s", "ucnv_toUChars", u_errorName(status))));
    1842             : 
    1843             :     return len_uchar;
    1844             : }
    1845             : 
    1846             : /*
    1847             :  * Convert a string of UChars into the database encoding.
    1848             :  *
    1849             :  * The source string at buff_uchar is of length len_uchar
    1850             :  * (it needn't be nul-terminated)
    1851             :  *
    1852             :  * *result receives a pointer to the palloc'd result string, and the
    1853             :  * function's result is the number of bytes generated (not counting nul).
    1854             :  *
    1855             :  * The result string is nul-terminated.
    1856             :  */
    1857             : int32_t
    1858             : icu_from_uchar(char **result, const UChar *buff_uchar, int32_t len_uchar)
    1859             : {
    1860             :     UErrorCode  status;
    1861             :     int32_t     len_result;
    1862             : 
    1863             :     init_icu_converter();
    1864             : 
    1865             :     status = U_ZERO_ERROR;
    1866             :     len_result = ucnv_fromUChars(icu_converter, NULL, 0,
    1867             :                                  buff_uchar, len_uchar, &status);
    1868             :     if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
    1869             :         ereport(ERROR,
    1870             :                 (errmsg("%s failed: %s", "ucnv_fromUChars",
    1871             :                         u_errorName(status))));
    1872             : 
    1873             :     *result = palloc(len_result + 1);
    1874             : 
    1875             :     status = U_ZERO_ERROR;
    1876             :     len_result = ucnv_fromUChars(icu_converter, *result, len_result + 1,
    1877             :                                  buff_uchar, len_uchar, &status);
    1878             :     if (U_FAILURE(status))
    1879             :         ereport(ERROR,
    1880             :                 (errmsg("%s failed: %s", "ucnv_fromUChars",
    1881             :                         u_errorName(status))));
    1882             : 
    1883             :     return len_result;
    1884             : }
    1885             : 
    1886             : /*
    1887             :  * Parse collation attributes and apply them to the open collator.  This takes
    1888             :  * a string like "und@colStrength=primary;colCaseLevel=yes" and parses and
    1889             :  * applies the key-value arguments.
    1890             :  *
    1891             :  * Starting with ICU version 54, the attributes are processed automatically by
    1892             :  * ucol_open(), so this is only necessary for emulating this behavior on older
    1893             :  * versions.
    1894             :  */
    1895             : pg_attribute_unused()
    1896             : static void
    1897             : icu_set_collation_attributes(UCollator *collator, const char *loc)
    1898             : {
    1899             :     char       *str = asc_tolower(loc, strlen(loc));
    1900             : 
    1901             :     str = strchr(str, '@');
    1902             :     if (!str)
    1903             :         return;
    1904             :     str++;
    1905             : 
    1906             :     for (char *token = strtok(str, ";"); token; token = strtok(NULL, ";"))
    1907             :     {
    1908             :         char       *e = strchr(token, '=');
    1909             : 
    1910             :         if (e)
    1911             :         {
    1912             :             char       *name;
    1913             :             char       *value;
    1914             :             UColAttribute uattr;
    1915             :             UColAttributeValue uvalue;
    1916             :             UErrorCode  status;
    1917             : 
    1918             :             status = U_ZERO_ERROR;
    1919             : 
    1920             :             *e = '\0';
    1921             :             name = token;
    1922             :             value = e + 1;
    1923             : 
    1924             :             /*
    1925             :              * See attribute name and value lists in ICU i18n/coll.cpp
    1926             :              */
    1927             :             if (strcmp(name, "colstrength") == 0)
    1928             :                 uattr = UCOL_STRENGTH;
    1929             :             else if (strcmp(name, "colbackwards") == 0)
    1930             :                 uattr = UCOL_FRENCH_COLLATION;
    1931             :             else if (strcmp(name, "colcaselevel") == 0)
    1932             :                 uattr = UCOL_CASE_LEVEL;
    1933             :             else if (strcmp(name, "colcasefirst") == 0)
    1934             :                 uattr = UCOL_CASE_FIRST;
    1935             :             else if (strcmp(name, "colalternate") == 0)
    1936             :                 uattr = UCOL_ALTERNATE_HANDLING;
    1937             :             else if (strcmp(name, "colnormalization") == 0)
    1938             :                 uattr = UCOL_NORMALIZATION_MODE;
    1939             :             else if (strcmp(name, "colnumeric") == 0)
    1940             :                 uattr = UCOL_NUMERIC_COLLATION;
    1941             :             else
    1942             :                 /* ignore if unknown */
    1943             :                 continue;
    1944             : 
    1945             :             if (strcmp(value, "primary") == 0)
    1946             :                 uvalue = UCOL_PRIMARY;
    1947             :             else if (strcmp(value, "secondary") == 0)
    1948             :                 uvalue = UCOL_SECONDARY;
    1949             :             else if (strcmp(value, "tertiary") == 0)
    1950             :                 uvalue = UCOL_TERTIARY;
    1951             :             else if (strcmp(value, "quaternary") == 0)
    1952             :                 uvalue = UCOL_QUATERNARY;
    1953             :             else if (strcmp(value, "identical") == 0)
    1954             :                 uvalue = UCOL_IDENTICAL;
    1955             :             else if (strcmp(value, "no") == 0)
    1956             :                 uvalue = UCOL_OFF;
    1957             :             else if (strcmp(value, "yes") == 0)
    1958             :                 uvalue = UCOL_ON;
    1959             :             else if (strcmp(value, "shifted") == 0)
    1960             :                 uvalue = UCOL_SHIFTED;
    1961             :             else if (strcmp(value, "non-ignorable") == 0)
    1962             :                 uvalue = UCOL_NON_IGNORABLE;
    1963             :             else if (strcmp(value, "lower") == 0)
    1964             :                 uvalue = UCOL_LOWER_FIRST;
    1965             :             else if (strcmp(value, "upper") == 0)
    1966             :                 uvalue = UCOL_UPPER_FIRST;
    1967             :             else
    1968             :                 status = U_ILLEGAL_ARGUMENT_ERROR;
    1969             : 
    1970             :             if (status == U_ZERO_ERROR)
    1971             :                 ucol_setAttribute(collator, uattr, uvalue, &status);
    1972             : 
    1973             :             /*
    1974             :              * Pretend the error came from ucol_open(), for consistent error
    1975             :              * message across ICU versions.
    1976             :              */
    1977             :             if (U_FAILURE(status))
    1978             :                 ereport(ERROR,
    1979             :                         (errmsg("could not open collator for locale \"%s\": %s",
    1980             :                                 loc, u_errorName(status))));
    1981             :         }
    1982             :     }
    1983             : }
    1984             : 
    1985             : #endif                          /* USE_ICU */
    1986             : 
    1987             : /*
    1988             :  * Check if the given locale ID is valid, and ereport(ERROR) if it isn't.
    1989             :  */
    1990             : void
    1991           0 : check_icu_locale(const char *icu_locale)
    1992             : {
    1993             : #ifdef USE_ICU
    1994             :     UCollator  *collator;
    1995             :     UErrorCode  status;
    1996             : 
    1997             :     status = U_ZERO_ERROR;
    1998             :     collator = ucol_open(icu_locale, &status);
    1999             :     if (U_FAILURE(status))
    2000             :         ereport(ERROR,
    2001             :                 (errmsg("could not open collator for locale \"%s\": %s",
    2002             :                         icu_locale, u_errorName(status))));
    2003             : 
    2004             :     if (U_ICU_VERSION_MAJOR_NUM < 54)
    2005             :         icu_set_collation_attributes(collator, icu_locale);
    2006             :     ucol_close(collator);
    2007             : #else
    2008           0 :     ereport(ERROR,
    2009             :             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2010             :              errmsg("ICU is not supported in this build")));
    2011             : #endif
    2012             : }
    2013             : 
    2014             : /*
    2015             :  * These functions convert from/to libc's wchar_t, *not* pg_wchar_t.
    2016             :  * Therefore we keep them here rather than with the mbutils code.
    2017             :  */
    2018             : 
    2019             : /*
    2020             :  * wchar2char --- convert wide characters to multibyte format
    2021             :  *
    2022             :  * This has the same API as the standard wcstombs_l() function; in particular,
    2023             :  * tolen is the maximum number of bytes to store at *to, and *from must be
    2024             :  * zero-terminated.  The output will be zero-terminated iff there is room.
    2025             :  */
    2026             : size_t
    2027     1243514 : wchar2char(char *to, const wchar_t *from, size_t tolen, pg_locale_t locale)
    2028             : {
    2029             :     size_t      result;
    2030             : 
    2031             :     Assert(!locale || locale->provider == COLLPROVIDER_LIBC);
    2032             : 
    2033     1243514 :     if (tolen == 0)
    2034           0 :         return 0;
    2035             : 
    2036             : #ifdef WIN32
    2037             : 
    2038             :     /*
    2039             :      * On Windows, the "Unicode" locales assume UTF16 not UTF8 encoding, and
    2040             :      * for some reason mbstowcs and wcstombs won't do this for us, so we use
    2041             :      * MultiByteToWideChar().
    2042             :      */
    2043             :     if (GetDatabaseEncoding() == PG_UTF8)
    2044             :     {
    2045             :         result = WideCharToMultiByte(CP_UTF8, 0, from, -1, to, tolen,
    2046             :                                      NULL, NULL);
    2047             :         /* A zero return is failure */
    2048             :         if (result <= 0)
    2049             :             result = -1;
    2050             :         else
    2051             :         {
    2052             :             Assert(result <= tolen);
    2053             :             /* Microsoft counts the zero terminator in the result */
    2054             :             result--;
    2055             :         }
    2056             :     }
    2057             :     else
    2058             : #endif                          /* WIN32 */
    2059     1243514 :     if (locale == (pg_locale_t) 0)
    2060             :     {
    2061             :         /* Use wcstombs directly for the default locale */
    2062     1243514 :         result = wcstombs(to, from, tolen);
    2063             :     }
    2064             :     else
    2065             :     {
    2066             : #ifdef HAVE_LOCALE_T
    2067             : #ifdef HAVE_WCSTOMBS_L
    2068             :         /* Use wcstombs_l for nondefault locales */
    2069             :         result = wcstombs_l(to, from, tolen, locale->info.lt);
    2070             : #else                           /* !HAVE_WCSTOMBS_L */
    2071             :         /* We have to temporarily set the locale as current ... ugh */
    2072           0 :         locale_t    save_locale = uselocale(locale->info.lt);
    2073             : 
    2074           0 :         result = wcstombs(to, from, tolen);
    2075             : 
    2076           0 :         uselocale(save_locale);
    2077             : #endif                          /* HAVE_WCSTOMBS_L */
    2078             : #else                           /* !HAVE_LOCALE_T */
    2079             :         /* Can't have locale != 0 without HAVE_LOCALE_T */
    2080             :         elog(ERROR, "wcstombs_l is not available");
    2081             :         result = 0;             /* keep compiler quiet */
    2082             : #endif                          /* HAVE_LOCALE_T */
    2083             :     }
    2084             : 
    2085     1243514 :     return result;
    2086             : }
    2087             : 
    2088             : /*
    2089             :  * char2wchar --- convert multibyte characters to wide characters
    2090             :  *
    2091             :  * This has almost the API of mbstowcs_l(), except that *from need not be
    2092             :  * null-terminated; instead, the number of input bytes is specified as
    2093             :  * fromlen.  Also, we ereport() rather than returning -1 for invalid
    2094             :  * input encoding.  tolen is the maximum number of wchar_t's to store at *to.
    2095             :  * The output will be zero-terminated iff there is room.
    2096             :  */
    2097             : size_t
    2098     1248086 : char2wchar(wchar_t *to, size_t tolen, const char *from, size_t fromlen,
    2099             :            pg_locale_t locale)
    2100             : {
    2101             :     size_t      result;
    2102             : 
    2103             :     Assert(!locale || locale->provider == COLLPROVIDER_LIBC);
    2104             : 
    2105     1248086 :     if (tolen == 0)
    2106           0 :         return 0;
    2107             : 
    2108             : #ifdef WIN32
    2109             :     /* See WIN32 "Unicode" comment above */
    2110             :     if (GetDatabaseEncoding() == PG_UTF8)
    2111             :     {
    2112             :         /* Win32 API does not work for zero-length input */
    2113             :         if (fromlen == 0)
    2114             :             result = 0;
    2115             :         else
    2116             :         {
    2117             :             result = MultiByteToWideChar(CP_UTF8, 0, from, fromlen, to, tolen - 1);
    2118             :             /* A zero return is failure */
    2119             :             if (result == 0)
    2120             :                 result = -1;
    2121             :         }
    2122             : 
    2123             :         if (result != -1)
    2124             :         {
    2125             :             Assert(result < tolen);
    2126             :             /* Append trailing null wchar (MultiByteToWideChar() does not) */
    2127             :             to[result] = 0;
    2128             :         }
    2129             :     }
    2130             :     else
    2131             : #endif                          /* WIN32 */
    2132             :     {
    2133             :         /* mbstowcs requires ending '\0' */
    2134     1248086 :         char       *str = pnstrdup(from, fromlen);
    2135             : 
    2136     1248086 :         if (locale == (pg_locale_t) 0)
    2137             :         {
    2138             :             /* Use mbstowcs directly for the default locale */
    2139     1248086 :             result = mbstowcs(to, str, tolen);
    2140             :         }
    2141             :         else
    2142             :         {
    2143             : #ifdef HAVE_LOCALE_T
    2144             : #ifdef HAVE_MBSTOWCS_L
    2145             :             /* Use mbstowcs_l for nondefault locales */
    2146             :             result = mbstowcs_l(to, str, tolen, locale->info.lt);
    2147             : #else                           /* !HAVE_MBSTOWCS_L */
    2148             :             /* We have to temporarily set the locale as current ... ugh */
    2149           0 :             locale_t    save_locale = uselocale(locale->info.lt);
    2150             : 
    2151           0 :             result = mbstowcs(to, str, tolen);
    2152             : 
    2153           0 :             uselocale(save_locale);
    2154             : #endif                          /* HAVE_MBSTOWCS_L */
    2155             : #else                           /* !HAVE_LOCALE_T */
    2156             :             /* Can't have locale != 0 without HAVE_LOCALE_T */
    2157             :             elog(ERROR, "mbstowcs_l is not available");
    2158             :             result = 0;         /* keep compiler quiet */
    2159             : #endif                          /* HAVE_LOCALE_T */
    2160             :         }
    2161             : 
    2162     1248086 :         pfree(str);
    2163             :     }
    2164             : 
    2165     1248086 :     if (result == -1)
    2166             :     {
    2167             :         /*
    2168             :          * Invalid multibyte character encountered.  We try to give a useful
    2169             :          * error message by letting pg_verifymbstr check the string.  But it's
    2170             :          * possible that the string is OK to us, and not OK to mbstowcs ---
    2171             :          * this suggests that the LC_CTYPE locale is different from the
    2172             :          * database encoding.  Give a generic error message if pg_verifymbstr
    2173             :          * can't find anything wrong.
    2174             :          */
    2175           0 :         pg_verifymbstr(from, fromlen, false);   /* might not return */
    2176             :         /* but if it does ... */
    2177           0 :         ereport(ERROR,
    2178             :                 (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
    2179             :                  errmsg("invalid multibyte character for locale"),
    2180             :                  errhint("The server's LC_CTYPE locale is probably incompatible with the database encoding.")));
    2181             :     }
    2182             : 
    2183     1248086 :     return result;
    2184             : }

Generated by: LCOV version 1.14