LCOV - code coverage report
Current view: top level - src/backend/commands - collationcmds.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 271 327 82.9 %
Date: 2024-04-13 08:11:04 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * collationcmds.c
       4             :  *    collation-related commands support code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/commands/collationcmds.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/htup_details.h"
      18             : #include "access/table.h"
      19             : #include "access/xact.h"
      20             : #include "catalog/indexing.h"
      21             : #include "catalog/namespace.h"
      22             : #include "catalog/objectaccess.h"
      23             : #include "catalog/pg_collation.h"
      24             : #include "catalog/pg_database.h"
      25             : #include "catalog/pg_namespace.h"
      26             : #include "commands/collationcmds.h"
      27             : #include "commands/comment.h"
      28             : #include "commands/dbcommands.h"
      29             : #include "commands/defrem.h"
      30             : #include "common/string.h"
      31             : #include "mb/pg_wchar.h"
      32             : #include "miscadmin.h"
      33             : #include "utils/acl.h"
      34             : #include "utils/builtins.h"
      35             : #include "utils/lsyscache.h"
      36             : #include "utils/pg_locale.h"
      37             : #include "utils/rel.h"
      38             : #include "utils/syscache.h"
      39             : 
      40             : 
      41             : typedef struct
      42             : {
      43             :     char       *localename;     /* name of locale, as per "locale -a" */
      44             :     char       *alias;          /* shortened alias for same */
      45             :     int         enc;            /* encoding */
      46             : } CollAliasData;
      47             : 
      48             : 
      49             : /*
      50             :  * CREATE COLLATION
      51             :  */
      52             : ObjectAddress
      53         342 : DefineCollation(ParseState *pstate, List *names, List *parameters, bool if_not_exists)
      54             : {
      55             :     char       *collName;
      56             :     Oid         collNamespace;
      57             :     AclResult   aclresult;
      58             :     ListCell   *pl;
      59         342 :     DefElem    *fromEl = NULL;
      60         342 :     DefElem    *localeEl = NULL;
      61         342 :     DefElem    *lccollateEl = NULL;
      62         342 :     DefElem    *lcctypeEl = NULL;
      63         342 :     DefElem    *providerEl = NULL;
      64         342 :     DefElem    *deterministicEl = NULL;
      65         342 :     DefElem    *rulesEl = NULL;
      66         342 :     DefElem    *versionEl = NULL;
      67             :     char       *collcollate;
      68             :     char       *collctype;
      69             :     const char *colllocale;
      70             :     char       *collicurules;
      71             :     bool        collisdeterministic;
      72             :     int         collencoding;
      73             :     char        collprovider;
      74         342 :     char       *collversion = NULL;
      75             :     Oid         newoid;
      76             :     ObjectAddress address;
      77             : 
      78         342 :     collNamespace = QualifiedNameGetCreationNamespace(names, &collName);
      79             : 
      80         342 :     aclresult = object_aclcheck(NamespaceRelationId, collNamespace, GetUserId(), ACL_CREATE);
      81         342 :     if (aclresult != ACLCHECK_OK)
      82           0 :         aclcheck_error(aclresult, OBJECT_SCHEMA,
      83           0 :                        get_namespace_name(collNamespace));
      84             : 
      85         978 :     foreach(pl, parameters)
      86             :     {
      87         678 :         DefElem    *defel = lfirst_node(DefElem, pl);
      88             :         DefElem   **defelp;
      89             : 
      90         678 :         if (strcmp(defel->defname, "from") == 0)
      91          58 :             defelp = &fromEl;
      92         620 :         else if (strcmp(defel->defname, "locale") == 0)
      93         210 :             defelp = &localeEl;
      94         410 :         else if (strcmp(defel->defname, "lc_collate") == 0)
      95          62 :             defelp = &lccollateEl;
      96         348 :         else if (strcmp(defel->defname, "lc_ctype") == 0)
      97          56 :             defelp = &lcctypeEl;
      98         292 :         else if (strcmp(defel->defname, "provider") == 0)
      99         208 :             defelp = &providerEl;
     100          84 :         else if (strcmp(defel->defname, "deterministic") == 0)
     101          44 :             defelp = &deterministicEl;
     102          40 :         else if (strcmp(defel->defname, "rules") == 0)
     103          12 :             defelp = &rulesEl;
     104          28 :         else if (strcmp(defel->defname, "version") == 0)
     105          22 :             defelp = &versionEl;
     106             :         else
     107             :         {
     108           6 :             ereport(ERROR,
     109             :                     (errcode(ERRCODE_SYNTAX_ERROR),
     110             :                      errmsg("collation attribute \"%s\" not recognized",
     111             :                             defel->defname),
     112             :                      parser_errposition(pstate, defel->location)));
     113             :             break;
     114             :         }
     115         672 :         if (*defelp != NULL)
     116          36 :             errorConflictingDefElem(defel, pstate);
     117         636 :         *defelp = defel;
     118             :     }
     119             : 
     120         300 :     if (localeEl && (lccollateEl || lcctypeEl))
     121          18 :         ereport(ERROR,
     122             :                 errcode(ERRCODE_SYNTAX_ERROR),
     123             :                 errmsg("conflicting or redundant options"),
     124             :                 errdetail("LOCALE cannot be specified together with LC_COLLATE or LC_CTYPE."));
     125             : 
     126         282 :     if (fromEl && list_length(parameters) != 1)
     127           6 :         ereport(ERROR,
     128             :                 errcode(ERRCODE_SYNTAX_ERROR),
     129             :                 errmsg("conflicting or redundant options"),
     130             :                 errdetail("FROM cannot be specified together with any other options."));
     131             : 
     132         276 :     if (fromEl)
     133             :     {
     134             :         Oid         collid;
     135             :         HeapTuple   tp;
     136             :         Datum       datum;
     137             :         bool        isnull;
     138             : 
     139          52 :         collid = get_collation_oid(defGetQualifiedName(fromEl), false);
     140          46 :         tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
     141          46 :         if (!HeapTupleIsValid(tp))
     142           0 :             elog(ERROR, "cache lookup failed for collation %u", collid);
     143             : 
     144          46 :         collprovider = ((Form_pg_collation) GETSTRUCT(tp))->collprovider;
     145          46 :         collisdeterministic = ((Form_pg_collation) GETSTRUCT(tp))->collisdeterministic;
     146          46 :         collencoding = ((Form_pg_collation) GETSTRUCT(tp))->collencoding;
     147             : 
     148          46 :         datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collcollate, &isnull);
     149          46 :         if (!isnull)
     150          28 :             collcollate = TextDatumGetCString(datum);
     151             :         else
     152          18 :             collcollate = NULL;
     153             : 
     154          46 :         datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collctype, &isnull);
     155          46 :         if (!isnull)
     156          28 :             collctype = TextDatumGetCString(datum);
     157             :         else
     158          18 :             collctype = NULL;
     159             : 
     160          46 :         datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_colllocale, &isnull);
     161          46 :         if (!isnull)
     162          12 :             colllocale = TextDatumGetCString(datum);
     163             :         else
     164          34 :             colllocale = NULL;
     165             : 
     166             :         /*
     167             :          * When the ICU locale comes from an existing collation, do not
     168             :          * canonicalize to a language tag.
     169             :          */
     170             : 
     171          46 :         datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collicurules, &isnull);
     172          46 :         if (!isnull)
     173           0 :             collicurules = TextDatumGetCString(datum);
     174             :         else
     175          46 :             collicurules = NULL;
     176             : 
     177          46 :         ReleaseSysCache(tp);
     178             : 
     179             :         /*
     180             :          * Copying the "default" collation is not allowed because most code
     181             :          * checks for DEFAULT_COLLATION_OID instead of COLLPROVIDER_DEFAULT,
     182             :          * and so having a second collation with COLLPROVIDER_DEFAULT would
     183             :          * not work and potentially confuse or crash some code.  This could be
     184             :          * fixed with some legwork.
     185             :          */
     186          46 :         if (collprovider == COLLPROVIDER_DEFAULT)
     187           6 :             ereport(ERROR,
     188             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     189             :                      errmsg("collation \"default\" cannot be copied")));
     190             :     }
     191             :     else
     192             :     {
     193         224 :         char       *collproviderstr = NULL;
     194             : 
     195         224 :         collcollate = NULL;
     196         224 :         collctype = NULL;
     197         224 :         colllocale = NULL;
     198         224 :         collicurules = NULL;
     199             : 
     200         224 :         if (providerEl)
     201         196 :             collproviderstr = defGetString(providerEl);
     202             : 
     203         224 :         if (deterministicEl)
     204          32 :             collisdeterministic = defGetBoolean(deterministicEl);
     205             :         else
     206         192 :             collisdeterministic = true;
     207             : 
     208         224 :         if (rulesEl)
     209          12 :             collicurules = defGetString(rulesEl);
     210             : 
     211         224 :         if (versionEl)
     212           4 :             collversion = defGetString(versionEl);
     213             : 
     214         224 :         if (collproviderstr)
     215             :         {
     216         196 :             if (pg_strcasecmp(collproviderstr, "builtin") == 0)
     217          44 :                 collprovider = COLLPROVIDER_BUILTIN;
     218         152 :             else if (pg_strcasecmp(collproviderstr, "icu") == 0)
     219         152 :                 collprovider = COLLPROVIDER_ICU;
     220           0 :             else if (pg_strcasecmp(collproviderstr, "libc") == 0)
     221           0 :                 collprovider = COLLPROVIDER_LIBC;
     222             :             else
     223           0 :                 ereport(ERROR,
     224             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     225             :                          errmsg("unrecognized collation provider: %s",
     226             :                                 collproviderstr)));
     227             :         }
     228             :         else
     229          28 :             collprovider = COLLPROVIDER_LIBC;
     230             : 
     231         224 :         if (localeEl)
     232             :         {
     233         180 :             if (collprovider == COLLPROVIDER_LIBC)
     234             :             {
     235           2 :                 collcollate = defGetString(localeEl);
     236           2 :                 collctype = defGetString(localeEl);
     237             :             }
     238             :             else
     239         178 :                 colllocale = defGetString(localeEl);
     240             :         }
     241             : 
     242         224 :         if (lccollateEl)
     243          38 :             collcollate = defGetString(lccollateEl);
     244             : 
     245         224 :         if (lcctypeEl)
     246          32 :             collctype = defGetString(lcctypeEl);
     247             : 
     248         224 :         if (collprovider == COLLPROVIDER_BUILTIN)
     249             :         {
     250          44 :             if (!colllocale)
     251          12 :                 ereport(ERROR,
     252             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     253             :                          errmsg("parameter \"%s\" must be specified",
     254             :                                 "locale")));
     255             : 
     256          32 :             colllocale = builtin_validate_locale(GetDatabaseEncoding(),
     257             :                                                  colllocale);
     258             :         }
     259         180 :         else if (collprovider == COLLPROVIDER_LIBC)
     260             :         {
     261          28 :             if (!collcollate)
     262           0 :                 ereport(ERROR,
     263             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     264             :                          errmsg("parameter \"%s\" must be specified",
     265             :                                 "lc_collate")));
     266             : 
     267          28 :             if (!collctype)
     268           0 :                 ereport(ERROR,
     269             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     270             :                          errmsg("parameter \"%s\" must be specified",
     271             :                                 "lc_ctype")));
     272             :         }
     273         152 :         else if (collprovider == COLLPROVIDER_ICU)
     274             :         {
     275         152 :             if (!colllocale)
     276           6 :                 ereport(ERROR,
     277             :                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     278             :                          errmsg("parameter \"%s\" must be specified",
     279             :                                 "locale")));
     280             : 
     281             :             /*
     282             :              * During binary upgrade, preserve the locale string. Otherwise,
     283             :              * canonicalize to a language tag.
     284             :              */
     285         146 :             if (!IsBinaryUpgrade)
     286             :             {
     287         144 :                 char       *langtag = icu_language_tag(colllocale,
     288             :                                                        icu_validation_level);
     289             : 
     290         138 :                 if (langtag && strcmp(colllocale, langtag) != 0)
     291             :                 {
     292         100 :                     ereport(NOTICE,
     293             :                             (errmsg("using standard form \"%s\" for ICU locale \"%s\"",
     294             :                                     langtag, colllocale)));
     295             : 
     296         100 :                     colllocale = langtag;
     297             :                 }
     298             :             }
     299             : 
     300         140 :             icu_validate_locale(colllocale);
     301             :         }
     302             : 
     303             :         /*
     304             :          * Nondeterministic collations are currently only supported with ICU
     305             :          * because that's the only case where it can actually make a
     306             :          * difference. So we can save writing the code for the other
     307             :          * providers.
     308             :          */
     309         176 :         if (!collisdeterministic && collprovider != COLLPROVIDER_ICU)
     310           0 :             ereport(ERROR,
     311             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     312             :                      errmsg("nondeterministic collations not supported with this provider")));
     313             : 
     314         176 :         if (collicurules && collprovider != COLLPROVIDER_ICU)
     315           0 :             ereport(ERROR,
     316             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     317             :                      errmsg("ICU rules cannot be specified unless locale provider is ICU")));
     318             : 
     319         176 :         if (collprovider == COLLPROVIDER_BUILTIN)
     320             :         {
     321          20 :             collencoding = builtin_locale_encoding(colllocale);
     322             :         }
     323         156 :         else if (collprovider == COLLPROVIDER_ICU)
     324             :         {
     325             : #ifdef USE_ICU
     326             :             /*
     327             :              * We could create ICU collations with collencoding == database
     328             :              * encoding, but it seems better to use -1 so that it matches the
     329             :              * way initdb would create ICU collations.  However, only allow
     330             :              * one to be created when the current database's encoding is
     331             :              * supported.  Otherwise the collation is useless, plus we get
     332             :              * surprising behaviors like not being able to drop the collation.
     333             :              *
     334             :              * Skip this test when !USE_ICU, because the error we want to
     335             :              * throw for that isn't thrown till later.
     336             :              */
     337         128 :             if (!is_encoding_supported_by_icu(GetDatabaseEncoding()))
     338           0 :                 ereport(ERROR,
     339             :                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     340             :                          errmsg("current database's encoding is not supported with this provider")));
     341             : #endif
     342         128 :             collencoding = -1;
     343             :         }
     344             :         else
     345             :         {
     346          28 :             collencoding = GetDatabaseEncoding();
     347          28 :             check_encoding_locale_matches(collencoding, collcollate, collctype);
     348             :         }
     349             :     }
     350             : 
     351         216 :     if (!collversion)
     352             :     {
     353             :         const char *locale;
     354             : 
     355         212 :         if (collprovider == COLLPROVIDER_LIBC)
     356          56 :             locale = collcollate;
     357             :         else
     358         156 :             locale = colllocale;
     359             : 
     360         212 :         collversion = get_collation_actual_version(collprovider, locale);
     361             :     }
     362             : 
     363         216 :     newoid = CollationCreate(collName,
     364             :                              collNamespace,
     365             :                              GetUserId(),
     366             :                              collprovider,
     367             :                              collisdeterministic,
     368             :                              collencoding,
     369             :                              collcollate,
     370             :                              collctype,
     371             :                              colllocale,
     372             :                              collicurules,
     373             :                              collversion,
     374             :                              if_not_exists,
     375             :                              false);    /* not quiet */
     376             : 
     377         208 :     if (!OidIsValid(newoid))
     378           2 :         return InvalidObjectAddress;
     379             : 
     380             :     /*
     381             :      * Check that the locales can be loaded.  NB: pg_newlocale_from_collation
     382             :      * is only supposed to be called on non-C-equivalent locales.
     383             :      */
     384         206 :     CommandCounterIncrement();
     385         206 :     if (!lc_collate_is_c(newoid) || !lc_ctype_is_c(newoid))
     386         154 :         (void) pg_newlocale_from_collation(newoid);
     387             : 
     388         200 :     ObjectAddressSet(address, CollationRelationId, newoid);
     389             : 
     390         200 :     return address;
     391             : }
     392             : 
     393             : /*
     394             :  * Subroutine for ALTER COLLATION SET SCHEMA and RENAME
     395             :  *
     396             :  * Is there a collation with the same name of the given collation already in
     397             :  * the given namespace?  If so, raise an appropriate error message.
     398             :  */
     399             : void
     400          18 : IsThereCollationInNamespace(const char *collname, Oid nspOid)
     401             : {
     402             :     /* make sure the name doesn't already exist in new schema */
     403          18 :     if (SearchSysCacheExists3(COLLNAMEENCNSP,
     404             :                               CStringGetDatum(collname),
     405             :                               Int32GetDatum(GetDatabaseEncoding()),
     406             :                               ObjectIdGetDatum(nspOid)))
     407           0 :         ereport(ERROR,
     408             :                 (errcode(ERRCODE_DUPLICATE_OBJECT),
     409             :                  errmsg("collation \"%s\" for encoding \"%s\" already exists in schema \"%s\"",
     410             :                         collname, GetDatabaseEncodingName(),
     411             :                         get_namespace_name(nspOid))));
     412             : 
     413             :     /* mustn't match an any-encoding entry, either */
     414          18 :     if (SearchSysCacheExists3(COLLNAMEENCNSP,
     415             :                               CStringGetDatum(collname),
     416             :                               Int32GetDatum(-1),
     417             :                               ObjectIdGetDatum(nspOid)))
     418           6 :         ereport(ERROR,
     419             :                 (errcode(ERRCODE_DUPLICATE_OBJECT),
     420             :                  errmsg("collation \"%s\" already exists in schema \"%s\"",
     421             :                         collname, get_namespace_name(nspOid))));
     422          12 : }
     423             : 
     424             : /*
     425             :  * ALTER COLLATION
     426             :  */
     427             : ObjectAddress
     428           6 : AlterCollation(AlterCollationStmt *stmt)
     429             : {
     430             :     Relation    rel;
     431             :     Oid         collOid;
     432             :     HeapTuple   tup;
     433             :     Form_pg_collation collForm;
     434             :     Datum       datum;
     435             :     bool        isnull;
     436             :     char       *oldversion;
     437             :     char       *newversion;
     438             :     ObjectAddress address;
     439             : 
     440           6 :     rel = table_open(CollationRelationId, RowExclusiveLock);
     441           6 :     collOid = get_collation_oid(stmt->collname, false);
     442             : 
     443           6 :     if (collOid == DEFAULT_COLLATION_OID)
     444           0 :         ereport(ERROR,
     445             :                 (errmsg("cannot refresh version of default collation"),
     446             :         /* translator: %s is an SQL command */
     447             :                  errhint("Use %s instead.",
     448             :                          "ALTER DATABASE ... REFRESH COLLATION VERSION")));
     449             : 
     450           6 :     if (!object_ownercheck(CollationRelationId, collOid, GetUserId()))
     451           0 :         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_COLLATION,
     452           0 :                        NameListToString(stmt->collname));
     453             : 
     454           6 :     tup = SearchSysCacheCopy1(COLLOID, ObjectIdGetDatum(collOid));
     455           6 :     if (!HeapTupleIsValid(tup))
     456           0 :         elog(ERROR, "cache lookup failed for collation %u", collOid);
     457             : 
     458           6 :     collForm = (Form_pg_collation) GETSTRUCT(tup);
     459           6 :     datum = SysCacheGetAttr(COLLOID, tup, Anum_pg_collation_collversion, &isnull);
     460           6 :     oldversion = isnull ? NULL : TextDatumGetCString(datum);
     461             : 
     462           6 :     if (collForm->collprovider == COLLPROVIDER_LIBC)
     463           0 :         datum = SysCacheGetAttrNotNull(COLLOID, tup, Anum_pg_collation_collcollate);
     464             :     else
     465           6 :         datum = SysCacheGetAttrNotNull(COLLOID, tup, Anum_pg_collation_colllocale);
     466             : 
     467           6 :     newversion = get_collation_actual_version(collForm->collprovider,
     468           6 :                                               TextDatumGetCString(datum));
     469             : 
     470             :     /* cannot change from NULL to non-NULL or vice versa */
     471           6 :     if ((!oldversion && newversion) || (oldversion && !newversion))
     472           0 :         elog(ERROR, "invalid collation version change");
     473           6 :     else if (oldversion && newversion && strcmp(newversion, oldversion) != 0)
     474           0 :     {
     475             :         bool        nulls[Natts_pg_collation];
     476             :         bool        replaces[Natts_pg_collation];
     477             :         Datum       values[Natts_pg_collation];
     478             : 
     479           0 :         ereport(NOTICE,
     480             :                 (errmsg("changing version from %s to %s",
     481             :                         oldversion, newversion)));
     482             : 
     483           0 :         memset(values, 0, sizeof(values));
     484           0 :         memset(nulls, false, sizeof(nulls));
     485           0 :         memset(replaces, false, sizeof(replaces));
     486             : 
     487           0 :         values[Anum_pg_collation_collversion - 1] = CStringGetTextDatum(newversion);
     488           0 :         replaces[Anum_pg_collation_collversion - 1] = true;
     489             : 
     490           0 :         tup = heap_modify_tuple(tup, RelationGetDescr(rel),
     491             :                                 values, nulls, replaces);
     492             :     }
     493             :     else
     494           6 :         ereport(NOTICE,
     495             :                 (errmsg("version has not changed")));
     496             : 
     497           6 :     CatalogTupleUpdate(rel, &tup->t_self, tup);
     498             : 
     499           6 :     InvokeObjectPostAlterHook(CollationRelationId, collOid, 0);
     500             : 
     501           6 :     ObjectAddressSet(address, CollationRelationId, collOid);
     502             : 
     503           6 :     heap_freetuple(tup);
     504           6 :     table_close(rel, NoLock);
     505             : 
     506           6 :     return address;
     507             : }
     508             : 
     509             : 
     510             : Datum
     511          76 : pg_collation_actual_version(PG_FUNCTION_ARGS)
     512             : {
     513          76 :     Oid         collid = PG_GETARG_OID(0);
     514             :     char        provider;
     515             :     char       *locale;
     516             :     char       *version;
     517             :     Datum       datum;
     518             : 
     519          76 :     if (collid == DEFAULT_COLLATION_OID)
     520             :     {
     521             :         /* retrieve from pg_database */
     522             : 
     523           0 :         HeapTuple   dbtup = SearchSysCache1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));
     524             : 
     525           0 :         if (!HeapTupleIsValid(dbtup))
     526           0 :             ereport(ERROR,
     527             :                     (errcode(ERRCODE_UNDEFINED_OBJECT),
     528             :                      errmsg("database with OID %u does not exist", MyDatabaseId)));
     529             : 
     530           0 :         provider = ((Form_pg_database) GETSTRUCT(dbtup))->datlocprovider;
     531             : 
     532           0 :         if (provider == COLLPROVIDER_LIBC)
     533             :         {
     534           0 :             datum = SysCacheGetAttrNotNull(DATABASEOID, dbtup, Anum_pg_database_datcollate);
     535           0 :             locale = TextDatumGetCString(datum);
     536             :         }
     537             :         else
     538             :         {
     539           0 :             datum = SysCacheGetAttrNotNull(DATABASEOID, dbtup, Anum_pg_database_datlocale);
     540           0 :             locale = TextDatumGetCString(datum);
     541             :         }
     542             : 
     543           0 :         ReleaseSysCache(dbtup);
     544             :     }
     545             :     else
     546             :     {
     547             :         /* retrieve from pg_collation */
     548             : 
     549          76 :         HeapTuple   colltp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
     550             : 
     551          76 :         if (!HeapTupleIsValid(colltp))
     552           0 :             ereport(ERROR,
     553             :                     (errcode(ERRCODE_UNDEFINED_OBJECT),
     554             :                      errmsg("collation with OID %u does not exist", collid)));
     555             : 
     556          76 :         provider = ((Form_pg_collation) GETSTRUCT(colltp))->collprovider;
     557             :         Assert(provider != COLLPROVIDER_DEFAULT);
     558             : 
     559          76 :         if (provider == COLLPROVIDER_LIBC)
     560             :         {
     561           0 :             datum = SysCacheGetAttrNotNull(COLLOID, colltp, Anum_pg_collation_collcollate);
     562           0 :             locale = TextDatumGetCString(datum);
     563             :         }
     564             :         else
     565             :         {
     566          76 :             datum = SysCacheGetAttrNotNull(COLLOID, colltp, Anum_pg_collation_colllocale);
     567          76 :             locale = TextDatumGetCString(datum);
     568             :         }
     569             : 
     570          76 :         ReleaseSysCache(colltp);
     571             :     }
     572             : 
     573          76 :     version = get_collation_actual_version(provider, locale);
     574          76 :     if (version)
     575          76 :         PG_RETURN_TEXT_P(cstring_to_text(version));
     576             :     else
     577           0 :         PG_RETURN_NULL();
     578             : }
     579             : 
     580             : 
     581             : /* will we use "locale -a" in pg_import_system_collations? */
     582             : #if !defined(WIN32)
     583             : #define READ_LOCALE_A_OUTPUT
     584             : #endif
     585             : 
     586             : /* will we use EnumSystemLocalesEx in pg_import_system_collations? */
     587             : #ifdef WIN32
     588             : #define ENUM_SYSTEM_LOCALE
     589             : #endif
     590             : 
     591             : 
     592             : #ifdef READ_LOCALE_A_OUTPUT
     593             : /*
     594             :  * "Normalize" a libc locale name, stripping off encoding tags such as
     595             :  * ".utf8" (e.g., "en_US.utf8" -> "en_US", but "br_FR.iso885915@euro"
     596             :  * -> "br_FR@euro").  Return true if a new, different name was
     597             :  * generated.
     598             :  */
     599             : static bool
     600         152 : normalize_libc_locale_name(char *new, const char *old)
     601             : {
     602         152 :     char       *n = new;
     603         152 :     const char *o = old;
     604         152 :     bool        changed = false;
     605             : 
     606         760 :     while (*o)
     607             :     {
     608         608 :         if (*o == '.')
     609             :         {
     610             :             /* skip over encoding tag such as ".utf8" or ".UTF-8" */
     611         152 :             o++;
     612         836 :             while ((*o >= 'A' && *o <= 'Z')
     613         608 :                    || (*o >= 'a' && *o <= 'z')
     614         380 :                    || (*o >= '0' && *o <= '9')
     615         228 :                    || (*o == '-'))
     616         684 :                 o++;
     617         152 :             changed = true;
     618             :         }
     619             :         else
     620         456 :             *n++ = *o++;
     621             :     }
     622         152 :     *n = '\0';
     623             : 
     624         152 :     return changed;
     625             : }
     626             : 
     627             : /*
     628             :  * qsort comparator for CollAliasData items
     629             :  */
     630             : static int
     631          76 : cmpaliases(const void *a, const void *b)
     632             : {
     633          76 :     const CollAliasData *ca = (const CollAliasData *) a;
     634          76 :     const CollAliasData *cb = (const CollAliasData *) b;
     635             : 
     636             :     /* comparing localename is enough because other fields are derived */
     637          76 :     return strcmp(ca->localename, cb->localename);
     638             : }
     639             : #endif                          /* READ_LOCALE_A_OUTPUT */
     640             : 
     641             : 
     642             : #ifdef USE_ICU
     643             : /*
     644             :  * Get a comment (specifically, the display name) for an ICU locale.
     645             :  * The result is a palloc'd string, or NULL if we can't get a comment
     646             :  * or find that it's not all ASCII.  (We can *not* accept non-ASCII
     647             :  * comments, because the contents of template0 must be encoding-agnostic.)
     648             :  */
     649             : static char *
     650       59508 : get_icu_locale_comment(const char *localename)
     651             : {
     652             :     UErrorCode  status;
     653             :     UChar       displayname[128];
     654             :     int32       len_uchar;
     655             :     int32       i;
     656             :     char       *result;
     657             : 
     658       59508 :     status = U_ZERO_ERROR;
     659       59508 :     len_uchar = uloc_getDisplayName(localename, "en",
     660             :                                     displayname, lengthof(displayname),
     661             :                                     &status);
     662       59508 :     if (U_FAILURE(status))
     663           0 :         return NULL;            /* no good reason to raise an error */
     664             : 
     665             :     /* Check for non-ASCII comment (can't use pg_is_ascii for this) */
     666     1019540 :     for (i = 0; i < len_uchar; i++)
     667             :     {
     668      960868 :         if (displayname[i] > 127)
     669         836 :             return NULL;
     670             :     }
     671             : 
     672             :     /* OK, transcribe */
     673       58672 :     result = palloc(len_uchar + 1);
     674     1009736 :     for (i = 0; i < len_uchar; i++)
     675      951064 :         result[i] = displayname[i];
     676       58672 :     result[len_uchar] = '\0';
     677             : 
     678       58672 :     return result;
     679             : }
     680             : #endif                          /* USE_ICU */
     681             : 
     682             : 
     683             : /*
     684             :  * Create a new collation using the input locale 'locale'. (subroutine for
     685             :  * pg_import_system_collations())
     686             :  *
     687             :  * 'nspid' is the namespace id where the collation will be created.
     688             :  *
     689             :  * 'nvalidp' is incremented if the locale has a valid encoding.
     690             :  *
     691             :  * 'ncreatedp' is incremented if the collation is actually created.  If the
     692             :  * collation already exists it will quietly do nothing.
     693             :  *
     694             :  * The returned value is the encoding of the locale, -1 if the locale is not
     695             :  * valid for creating a collation.
     696             :  *
     697             :  */
     698             : pg_attribute_unused()
     699             : static int
     700         304 : create_collation_from_locale(const char *locale, int nspid,
     701             :                              int *nvalidp, int *ncreatedp)
     702             : {
     703             :     int         enc;
     704             :     Oid         collid;
     705             : 
     706             :     /*
     707             :      * Some systems have locale names that don't consist entirely of ASCII
     708             :      * letters (such as "bokm&aring;l" or "fran&ccedil;ais"). This is pretty
     709             :      * silly, since we need the locale itself to interpret the non-ASCII
     710             :      * characters. We can't do much with those, so we filter them out.
     711             :      */
     712         304 :     if (!pg_is_ascii(locale))
     713             :     {
     714           0 :         elog(DEBUG1, "skipping locale with non-ASCII name: \"%s\"", locale);
     715           0 :         return -1;
     716             :     }
     717             : 
     718         304 :     enc = pg_get_encoding_from_locale(locale, false);
     719         304 :     if (enc < 0)
     720             :     {
     721           0 :         elog(DEBUG1, "skipping locale with unrecognized encoding: \"%s\"", locale);
     722           0 :         return -1;
     723             :     }
     724         304 :     if (!PG_VALID_BE_ENCODING(enc))
     725             :     {
     726           0 :         elog(DEBUG1, "skipping locale with client-only encoding: \"%s\"", locale);
     727           0 :         return -1;
     728             :     }
     729         304 :     if (enc == PG_SQL_ASCII)
     730         152 :         return -1;              /* C/POSIX are already in the catalog */
     731             : 
     732             :     /* count valid locales found in operating system */
     733         152 :     (*nvalidp)++;
     734             : 
     735             :     /*
     736             :      * Create a collation named the same as the locale, but quietly doing
     737             :      * nothing if it already exists.  This is the behavior we need even at
     738             :      * initdb time, because some versions of "locale -a" can report the same
     739             :      * locale name more than once.  And it's convenient for later import runs,
     740             :      * too, since you just about always want to add on new locales without a
     741             :      * lot of chatter about existing ones.
     742             :      */
     743         152 :     collid = CollationCreate(locale, nspid, GetUserId(),
     744             :                              COLLPROVIDER_LIBC, true, enc,
     745             :                              locale, locale, NULL, NULL,
     746         152 :                              get_collation_actual_version(COLLPROVIDER_LIBC, locale),
     747             :                              true, true);
     748         152 :     if (OidIsValid(collid))
     749             :     {
     750         152 :         (*ncreatedp)++;
     751             : 
     752             :         /* Must do CCI between inserts to handle duplicates correctly */
     753         152 :         CommandCounterIncrement();
     754             :     }
     755             : 
     756         152 :     return enc;
     757             : }
     758             : 
     759             : 
     760             : #ifdef ENUM_SYSTEM_LOCALE
     761             : /* parameter to be passed to the callback function win32_read_locale() */
     762             : typedef struct
     763             : {
     764             :     Oid         nspid;
     765             :     int        *ncreatedp;
     766             :     int        *nvalidp;
     767             : } CollParam;
     768             : 
     769             : /*
     770             :  * Callback function for EnumSystemLocalesEx() in
     771             :  * pg_import_system_collations().  Creates a collation for every valid locale
     772             :  * and a POSIX alias collation.
     773             :  *
     774             :  * The callback contract is to return TRUE to continue enumerating and FALSE
     775             :  * to stop enumerating.  We always want to continue.
     776             :  */
     777             : static BOOL CALLBACK
     778             : win32_read_locale(LPWSTR pStr, DWORD dwFlags, LPARAM lparam)
     779             : {
     780             :     CollParam  *param = (CollParam *) lparam;
     781             :     char        localebuf[NAMEDATALEN];
     782             :     int         result;
     783             :     int         enc;
     784             : 
     785             :     (void) dwFlags;
     786             : 
     787             :     result = WideCharToMultiByte(CP_ACP, 0, pStr, -1, localebuf, NAMEDATALEN,
     788             :                                  NULL, NULL);
     789             : 
     790             :     if (result == 0)
     791             :     {
     792             :         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
     793             :             elog(DEBUG1, "skipping locale with too-long name: \"%s\"", localebuf);
     794             :         return TRUE;
     795             :     }
     796             :     if (localebuf[0] == '\0')
     797             :         return TRUE;
     798             : 
     799             :     enc = create_collation_from_locale(localebuf, param->nspid,
     800             :                                        param->nvalidp, param->ncreatedp);
     801             :     if (enc < 0)
     802             :         return TRUE;
     803             : 
     804             :     /*
     805             :      * Windows will use hyphens between language and territory, where POSIX
     806             :      * uses an underscore. Simply create a POSIX alias.
     807             :      */
     808             :     if (strchr(localebuf, '-'))
     809             :     {
     810             :         char        alias[NAMEDATALEN];
     811             :         Oid         collid;
     812             : 
     813             :         strcpy(alias, localebuf);
     814             :         for (char *p = alias; *p; p++)
     815             :             if (*p == '-')
     816             :                 *p = '_';
     817             : 
     818             :         collid = CollationCreate(alias, param->nspid, GetUserId(),
     819             :                                  COLLPROVIDER_LIBC, true, enc,
     820             :                                  localebuf, localebuf, NULL, NULL,
     821             :                                  get_collation_actual_version(COLLPROVIDER_LIBC, localebuf),
     822             :                                  true, true);
     823             :         if (OidIsValid(collid))
     824             :         {
     825             :             (*param->ncreatedp)++;
     826             : 
     827             :             CommandCounterIncrement();
     828             :         }
     829             :     }
     830             : 
     831             :     return TRUE;
     832             : }
     833             : #endif                          /* ENUM_SYSTEM_LOCALE */
     834             : 
     835             : 
     836             : /*
     837             :  * pg_import_system_collations: add known system collations to pg_collation
     838             :  */
     839             : Datum
     840          76 : pg_import_system_collations(PG_FUNCTION_ARGS)
     841             : {
     842          76 :     Oid         nspid = PG_GETARG_OID(0);
     843          76 :     int         ncreated = 0;
     844             : 
     845          76 :     if (!superuser())
     846           0 :         ereport(ERROR,
     847             :                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     848             :                  errmsg("must be superuser to import system collations")));
     849             : 
     850          76 :     if (!SearchSysCacheExists1(NAMESPACEOID, ObjectIdGetDatum(nspid)))
     851           0 :         ereport(ERROR,
     852             :                 (errcode(ERRCODE_UNDEFINED_SCHEMA),
     853             :                  errmsg("schema with OID %u does not exist", nspid)));
     854             : 
     855             :     /* Load collations known to libc, using "locale -a" to enumerate them */
     856             : #ifdef READ_LOCALE_A_OUTPUT
     857             :     {
     858             :         FILE       *locale_a_handle;
     859             :         char        localebuf[LOCALE_NAME_BUFLEN];
     860          76 :         int         nvalid = 0;
     861             :         Oid         collid;
     862             :         CollAliasData *aliases;
     863             :         int         naliases,
     864             :                     maxaliases,
     865             :                     i;
     866             : 
     867             :         /* expansible array of aliases */
     868          76 :         maxaliases = 100;
     869          76 :         aliases = (CollAliasData *) palloc(maxaliases * sizeof(CollAliasData));
     870          76 :         naliases = 0;
     871             : 
     872          76 :         locale_a_handle = OpenPipeStream("locale -a", "r");
     873          76 :         if (locale_a_handle == NULL)
     874           0 :             ereport(ERROR,
     875             :                     (errcode_for_file_access(),
     876             :                      errmsg("could not execute command \"%s\": %m",
     877             :                             "locale -a")));
     878             : 
     879         380 :         while (fgets(localebuf, sizeof(localebuf), locale_a_handle))
     880             :         {
     881             :             size_t      len;
     882             :             int         enc;
     883             :             char        alias[LOCALE_NAME_BUFLEN];
     884             : 
     885         304 :             len = strlen(localebuf);
     886             : 
     887         304 :             if (len == 0 || localebuf[len - 1] != '\n')
     888             :             {
     889           0 :                 elog(DEBUG1, "skipping locale with too-long name: \"%s\"", localebuf);
     890         152 :                 continue;
     891             :             }
     892         304 :             localebuf[len - 1] = '\0';
     893             : 
     894         304 :             enc = create_collation_from_locale(localebuf, nspid, &nvalid, &ncreated);
     895         304 :             if (enc < 0)
     896         152 :                 continue;
     897             : 
     898             :             /*
     899             :              * Generate aliases such as "en_US" in addition to "en_US.utf8"
     900             :              * for ease of use.  Note that collation names are unique per
     901             :              * encoding only, so this doesn't clash with "en_US" for LATIN1,
     902             :              * say.
     903             :              *
     904             :              * However, it might conflict with a name we'll see later in the
     905             :              * "locale -a" output.  So save up the aliases and try to add them
     906             :              * after we've read all the output.
     907             :              */
     908         152 :             if (normalize_libc_locale_name(alias, localebuf))
     909             :             {
     910         152 :                 if (naliases >= maxaliases)
     911             :                 {
     912           0 :                     maxaliases *= 2;
     913             :                     aliases = (CollAliasData *)
     914           0 :                         repalloc(aliases, maxaliases * sizeof(CollAliasData));
     915             :                 }
     916         152 :                 aliases[naliases].localename = pstrdup(localebuf);
     917         152 :                 aliases[naliases].alias = pstrdup(alias);
     918         152 :                 aliases[naliases].enc = enc;
     919         152 :                 naliases++;
     920             :             }
     921             :         }
     922             : 
     923             :         /*
     924             :          * We don't check the return value of this, because we want to support
     925             :          * the case where there "locale" command does not exist.  (This is
     926             :          * unusual but can happen on minimalized Linux distributions, for
     927             :          * example.)  We will warn below if no locales could be found.
     928             :          */
     929          76 :         ClosePipeStream(locale_a_handle);
     930             : 
     931             :         /*
     932             :          * Before processing the aliases, sort them by locale name.  The point
     933             :          * here is that if "locale -a" gives us multiple locale names with the
     934             :          * same encoding and base name, say "en_US.utf8" and "en_US.utf-8", we
     935             :          * want to pick a deterministic one of them.  First in ASCII sort
     936             :          * order is a good enough rule.  (Before PG 10, the code corresponding
     937             :          * to this logic in initdb.c had an additional ordering rule, to
     938             :          * prefer the locale name exactly matching the alias, if any.  We
     939             :          * don't need to consider that here, because we would have already
     940             :          * created such a pg_collation entry above, and that one will win.)
     941             :          */
     942          76 :         if (naliases > 1)
     943          76 :             qsort(aliases, naliases, sizeof(CollAliasData), cmpaliases);
     944             : 
     945             :         /* Now add aliases, ignoring any that match pre-existing entries */
     946         228 :         for (i = 0; i < naliases; i++)
     947             :         {
     948         152 :             char       *locale = aliases[i].localename;
     949         152 :             char       *alias = aliases[i].alias;
     950         152 :             int         enc = aliases[i].enc;
     951             : 
     952         152 :             collid = CollationCreate(alias, nspid, GetUserId(),
     953             :                                      COLLPROVIDER_LIBC, true, enc,
     954             :                                      locale, locale, NULL, NULL,
     955         152 :                                      get_collation_actual_version(COLLPROVIDER_LIBC, locale),
     956             :                                      true, true);
     957         152 :             if (OidIsValid(collid))
     958             :             {
     959          76 :                 ncreated++;
     960             : 
     961          76 :                 CommandCounterIncrement();
     962             :             }
     963             :         }
     964             : 
     965             :         /* Give a warning if "locale -a" seems to be malfunctioning */
     966          76 :         if (nvalid == 0)
     967           0 :             ereport(WARNING,
     968             :                     (errmsg("no usable system locales were found")));
     969             :     }
     970             : #endif                          /* READ_LOCALE_A_OUTPUT */
     971             : 
     972             :     /*
     973             :      * Load collations known to ICU
     974             :      *
     975             :      * We use uloc_countAvailable()/uloc_getAvailable() rather than
     976             :      * ucol_countAvailable()/ucol_getAvailable().  The former returns a full
     977             :      * set of language+region combinations, whereas the latter only returns
     978             :      * language+region combinations if they are distinct from the language's
     979             :      * base collation.  So there might not be a de-DE or en-GB, which would be
     980             :      * confusing.
     981             :      */
     982             : #ifdef USE_ICU
     983             :     {
     984             :         int         i;
     985             : 
     986             :         /*
     987             :          * Start the loop at -1 to sneak in the root locale without too much
     988             :          * code duplication.
     989             :          */
     990       59584 :         for (i = -1; i < uloc_countAvailable(); i++)
     991             :         {
     992             :             const char *name;
     993             :             char       *langtag;
     994             :             char       *icucomment;
     995             :             Oid         collid;
     996             : 
     997       59508 :             if (i == -1)
     998          76 :                 name = "";        /* ICU root locale */
     999             :             else
    1000       59432 :                 name = uloc_getAvailable(i);
    1001             : 
    1002       59508 :             langtag = icu_language_tag(name, ERROR);
    1003             : 
    1004             :             /*
    1005             :              * Be paranoid about not allowing any non-ASCII strings into
    1006             :              * pg_collation
    1007             :              */
    1008       59508 :             if (!pg_is_ascii(langtag))
    1009           0 :                 continue;
    1010             : 
    1011       59508 :             collid = CollationCreate(psprintf("%s-x-icu", langtag),
    1012             :                                      nspid, GetUserId(),
    1013             :                                      COLLPROVIDER_ICU, true, -1,
    1014             :                                      NULL, NULL, langtag, NULL,
    1015       59508 :                                      get_collation_actual_version(COLLPROVIDER_ICU, langtag),
    1016             :                                      true, true);
    1017       59508 :             if (OidIsValid(collid))
    1018             :             {
    1019       59508 :                 ncreated++;
    1020             : 
    1021       59508 :                 CommandCounterIncrement();
    1022             : 
    1023       59508 :                 icucomment = get_icu_locale_comment(name);
    1024       59508 :                 if (icucomment)
    1025       58672 :                     CreateComments(collid, CollationRelationId, 0,
    1026             :                                    icucomment);
    1027             :             }
    1028             :         }
    1029             :     }
    1030             : #endif                          /* USE_ICU */
    1031             : 
    1032             :     /* Load collations known to WIN32 */
    1033             : #ifdef ENUM_SYSTEM_LOCALE
    1034             :     {
    1035             :         int         nvalid = 0;
    1036             :         CollParam   param;
    1037             : 
    1038             :         param.nspid = nspid;
    1039             :         param.ncreatedp = &ncreated;
    1040             :         param.nvalidp = &nvalid;
    1041             : 
    1042             :         /*
    1043             :          * Enumerate the locales that are either installed on or supported by
    1044             :          * the OS.
    1045             :          */
    1046             :         if (!EnumSystemLocalesEx(win32_read_locale, LOCALE_ALL,
    1047             :                                  (LPARAM) &param, NULL))
    1048             :             _dosmaperr(GetLastError());
    1049             : 
    1050             :         /* Give a warning if EnumSystemLocalesEx seems to be malfunctioning */
    1051             :         if (nvalid == 0)
    1052             :             ereport(WARNING,
    1053             :                     (errmsg("no usable system locales were found")));
    1054             :     }
    1055             : #endif                          /* ENUM_SYSTEM_LOCALE */
    1056             : 
    1057          76 :     PG_RETURN_INT32(ncreated);
    1058             : }

Generated by: LCOV version 1.14