Do not return NULL from pg_newlocale_from_collation().

Previously, pg_newlocale_from_collation() returned NULL as a special
case for the DEFAULT_COLLATION_OID if the provider was libc. In that
case the behavior would depend on the last call to setlocale().

Now, consistent with the other providers, it will return a pointer to
default_locale, which is not dependent on setlocale().

Note: for the C and POSIX locales, the locale_t structure within the
pg_locale_t will still be zero, because those locales are implemented
with internal logic and do not use libc at all.

lc_collate_is_c() and lc_ctype_is_c() still depend on setlocale() to
determine the current locale, which will be removed in a subsequent
commit.

Discussion: https://postgr.es/m/cfd9eb85-c52a-4ec9-a90e-a5e4de56e57d@eisentraut.org
Reviewed-by: Peter Eisentraut, Andreas Karlsson

diff --git a/src/backend/utils/adt/pg_locale.c b/src/backend/utils/adt/pg_locale.c
index 8c1960db9466fc856bf8c63bbbbca9be4505c6dd..49f333b9b68fdf2b527b0a5e08f274353038807f 100644 (file)
--- a/src/backend/utils/adt/pg_locale.c
+++ b/src/backend/utils/adt/pg_locale.c
@@ -1461,6 +1461,103 @@ lc_ctype_is_c(Oid collation)
    return (lookup_collation_cache(collation, true))->ctype_is_c;
 }
 
+/* simple subroutine for reporting errors from newlocale() */
+static void
+report_newlocale_failure(const char *localename)
+{
+   int         save_errno;
+
+   /*
+    * Windows doesn't provide any useful error indication from
+    * _create_locale(), and BSD-derived platforms don't seem to feel they
+    * need to set errno either (even though POSIX is pretty clear that
+    * newlocale should do so).  So, if errno hasn't been set, assume ENOENT
+    * is what to report.
+    */
+   if (errno == 0)
+       errno = ENOENT;
+
+   /*
+    * ENOENT means "no such locale", not "no such file", so clarify that
+    * errno with an errdetail message.
+    */
+   save_errno = errno;         /* auxiliary funcs might change errno */
+   ereport(ERROR,
+           (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+            errmsg("could not create locale \"%s\": %m",
+                   localename),
+            (save_errno == ENOENT ?
+             errdetail("The operating system could not find any locale data for the locale name \"%s\".",
+                       localename) : 0)));
+}
+
+/*
+ * Initialize the locale_t field.
+ *
+ * The "C" and "POSIX" locales are not actually handled by libc, so set the
+ * locale_t to zero in that case.
+ */
+static void
+make_libc_collator(const char *collate, const char *ctype,
+                  pg_locale_t result)
+{
+   locale_t    loc = 0;
+
+   if (strcmp(collate, ctype) == 0)
+   {
+       if (strcmp(ctype, "C") != 0 && strcmp(ctype, "POSIX") != 0)
+       {
+           /* Normal case where they're the same */
+           errno = 0;
+#ifndef WIN32
+           loc = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collate,
+                           NULL);
+#else
+           loc = _create_locale(LC_ALL, collate);
+#endif
+           if (!loc)
+               report_newlocale_failure(collate);
+       }
+   }
+   else
+   {
+#ifndef WIN32
+       /* We need two newlocale() steps */
+       locale_t    loc1 = 0;
+
+       if (strcmp(collate, "C") != 0 && strcmp(collate, "POSIX") != 0)
+       {
+           errno = 0;
+           loc1 = newlocale(LC_COLLATE_MASK, collate, NULL);
+           if (!loc1)
+               report_newlocale_failure(collate);
+       }
+
+       if (strcmp(ctype, "C") != 0 && strcmp(ctype, "POSIX") != 0)
+       {
+           errno = 0;
+           loc = newlocale(LC_CTYPE_MASK, ctype, loc1);
+           if (!loc)
+               report_newlocale_failure(ctype);
+       }
+       else
+           loc = loc1;
+#else
+
+       /*
+        * XXX The _create_locale() API doesn't appear to support this. Could
+        * perhaps be worked around by changing pg_locale_t to contain two
+        * separate fields.
+        */
+       ereport(ERROR,
+               (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+                errmsg("collations with different collate and ctype values are not supported on this platform")));
+#endif
+   }
+
+   result->info.lt = loc;
+}
+
 void
 make_icu_collator(const char *iculocstr,
                  const char *icurules,
@@ -1514,36 +1611,6 @@ make_icu_collator(const char *iculocstr,
 }
 
 
-/* simple subroutine for reporting errors from newlocale() */
-static void
-report_newlocale_failure(const char *localename)
-{
-   int         save_errno;
-
-   /*
-    * Windows doesn't provide any useful error indication from
-    * _create_locale(), and BSD-derived platforms don't seem to feel they
-    * need to set errno either (even though POSIX is pretty clear that
-    * newlocale should do so).  So, if errno hasn't been set, assume ENOENT
-    * is what to report.
-    */
-   if (errno == 0)
-       errno = ENOENT;
-
-   /*
-    * ENOENT means "no such locale", not "no such file", so clarify that
-    * errno with an errdetail message.
-    */
-   save_errno = errno;         /* auxiliary funcs might change errno */
-   ereport(ERROR,
-           (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-            errmsg("could not create locale \"%s\": %m",
-                   localename),
-            (save_errno == ENOENT ?
-             errdetail("The operating system could not find any locale data for the locale name \"%s\".",
-                       localename) : 0)));
-}
-
 bool
 pg_locale_deterministic(pg_locale_t locale)
 {
@@ -1601,7 +1668,17 @@ init_database_collation(void)
    }
    else
    {
+       const char *datcollate;
+       const char *datctype;
+
        Assert(dbform->datlocprovider == COLLPROVIDER_LIBC);
+
+       datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datcollate);
+       datcollate = TextDatumGetCString(datum);
+       datum = SysCacheGetAttrNotNull(DATABASEOID, tup, Anum_pg_database_datctype);
+       datctype = TextDatumGetCString(datum);
+
+       make_libc_collator(datcollate, datctype, &default_locale);
    }
 
    default_locale.provider = dbform->datlocprovider;
@@ -1620,8 +1697,6 @@ init_database_collation(void)
  * Create a pg_locale_t from a collation OID.  Results are cached for the
  * lifetime of the backend.  Thus, do not free the result with freelocale().
  *
- * As a special optimization, the default/database collation returns 0.
- *
  * For simplicity, we always generate COLLATE + CTYPE even though we
  * might only need one of them.  Since this is called only once per session,
  * it shouldn't cost much.
@@ -1635,12 +1710,7 @@ pg_newlocale_from_collation(Oid collid)
    Assert(OidIsValid(collid));
 
    if (collid == DEFAULT_COLLATION_OID)
-   {
-       if (default_locale.provider == COLLPROVIDER_LIBC)
-           return (pg_locale_t) 0;
-       else
-           return &default_locale;
-   }
+       return &default_locale;
 
    cache_entry = lookup_collation_cache(collid, false);
 
@@ -1679,55 +1749,14 @@ pg_newlocale_from_collation(Oid collid)
        else if (collform->collprovider == COLLPROVIDER_LIBC)
        {
            const char *collcollate;
-           const char *collctype pg_attribute_unused();
-           locale_t    loc;
+           const char *collctype;
 
            datum = SysCacheGetAttrNotNull(COLLOID, tp, Anum_pg_collation_collcollate);
            collcollate = TextDatumGetCString(datum);
            datum = SysCacheGetAttrNotNull(COLLOID, tp, Anum_pg_collation_collctype);
            collctype = TextDatumGetCString(datum);
 
-           if (strcmp(collcollate, collctype) == 0)
-           {
-               /* Normal case where they're the same */
-               errno = 0;
-#ifndef WIN32
-               loc = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collcollate,
-                               NULL);
-#else
-               loc = _create_locale(LC_ALL, collcollate);
-#endif
-               if (!loc)
-                   report_newlocale_failure(collcollate);
-           }
-           else
-           {
-#ifndef WIN32
-               /* We need two newlocale() steps */
-               locale_t    loc1;
-
-               errno = 0;
-               loc1 = newlocale(LC_COLLATE_MASK, collcollate, NULL);
-               if (!loc1)
-                   report_newlocale_failure(collcollate);
-               errno = 0;
-               loc = newlocale(LC_CTYPE_MASK, collctype, loc1);
-               if (!loc)
-                   report_newlocale_failure(collctype);
-#else
-
-               /*
-                * XXX The _create_locale() API doesn't appear to support
-                * this. Could perhaps be worked around by changing
-                * pg_locale_t to contain two separate fields.
-                */
-               ereport(ERROR,
-                       (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-                        errmsg("collations with different collate and ctype values are not supported on this platform")));
-#endif
-           }
-
-           result.info.lt = loc;
+           make_libc_collator(collcollate, collctype, &result);
        }
        else if (collform->collprovider == COLLPROVIDER_ICU)
        {