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

Generated by: LCOV version 1.14