collationcmds.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_database.h"
#include "catalog/pg_namespace.h"
#include "commands/collationcmds.h"
#include "commands/comment.h"
#include "commands/dbcommands.h"
#include "commands/defrem.h"
#include "common/string.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/pg_locale.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for collationcmds.c:

Go to the source code of this file.

Data Structures
struct	CollAliasData

Macros
#define	READ_LOCALE_A_OUTPUT

Functions
ObjectAddress	DefineCollation (ParseState *pstate, List *names, List *parameters, bool if_not_exists)
void	IsThereCollationInNamespace (const char *collname, Oid nspOid)
ObjectAddress	AlterCollation (AlterCollationStmt *stmt)
Datum	pg_collation_actual_version (PG_FUNCTION_ARGS)
static bool	normalize_libc_locale_name (char *new, const char *old)
static int	cmpaliases (const void *a, const void *b)
	pg_attribute_unused () static int create_collation_from_locale(const char *locale
	if (!pg_is_ascii(locale))
	if (enc< 0)
	if (!PG_VALID_BE_ENCODING(enc))
	if (collid=CollationCreate(enc==PG_SQL_ASCII)
Datum	pg_import_system_collations (PG_FUNCTION_ARGS)

Variables
int	nspid
int int *	nvalidp
int int int *	ncreatedp
Oid	collid
	enc = pg_get_encoding_from_locale(locale, false)

Macro Definition Documentation

READ_LOCALE_A_OUTPUT

#define READ_LOCALE_A_OUTPUT

Definition at line 583 of file collationcmds.c.

Function Documentation

AlterCollation()

ObjectAddress AlterCollation

(

AlterCollationStmt *

stmt

)

Definition at line 428 of file collationcmds.c.

{
    Relation    rel;
    Oid         collOid;
    HeapTuple   tup;
    Form_pg_collation collForm;
    Datum       datum;
    bool        isnull;
    char       *oldversion;
    char       *newversion;
    ObjectAddress address;
 
    rel = table_open(CollationRelationId, RowExclusiveLock);
    collOid = get_collation_oid(stmt->collname, false);
 
    if (collOid == DEFAULT_COLLATION_OID)
        ereport(ERROR,
                (errmsg("cannot refresh version of default collation"),
        /* translator: %s is an SQL command */
                 errhint("Use %s instead.",
                         "ALTER DATABASE ... REFRESH COLLATION VERSION")));
 
    if (!object_ownercheck(CollationRelationId, collOid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_COLLATION,
                       NameListToString(stmt->collname));
 
    tup = SearchSysCacheCopy1(COLLOID, ObjectIdGetDatum(collOid));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for collation %u", collOid);
 
    collForm = (Form_pg_collation) GETSTRUCT(tup);
    datum = SysCacheGetAttr(COLLOID, tup, Anum_pg_collation_collversion, &isnull);
    oldversion = isnull ? NULL : TextDatumGetCString(datum);
 
    if (collForm->collprovider == COLLPROVIDER_LIBC)
        datum = SysCacheGetAttrNotNull(COLLOID, tup, Anum_pg_collation_collcollate);
    else
        datum = SysCacheGetAttrNotNull(COLLOID, tup, Anum_pg_collation_colllocale);
 
    newversion = get_collation_actual_version(collForm->collprovider,
                                              TextDatumGetCString(datum));
 
    /* cannot change from NULL to non-NULL or vice versa */
    if ((!oldversion && newversion) || (oldversion && !newversion))
        elog(ERROR, "invalid collation version change");
    else if (oldversion && newversion && strcmp(newversion, oldversion) != 0)
    {
        bool        nulls[Natts_pg_collation];
        bool        replaces[Natts_pg_collation];
        Datum       values[Natts_pg_collation];
 
        ereport(NOTICE,
                (errmsg("changing version from %s to %s",
                        oldversion, newversion)));
 
        memset(values, 0, sizeof(values));
        memset(nulls, false, sizeof(nulls));
        memset(replaces, false, sizeof(replaces));
 
        values[Anum_pg_collation_collversion - 1] = CStringGetTextDatum(newversion);
        replaces[Anum_pg_collation_collversion - 1] = true;
 
        tup = heap_modify_tuple(tup, RelationGetDescr(rel),
                                values, nulls, replaces);
    }
    else
        ereport(NOTICE,
                (errmsg("version has not changed")));
 
    CatalogTupleUpdate(rel, &tup->t_self, tup);
 
    InvokeObjectPostAlterHook(CollationRelationId, collOid, 0);
 
    ObjectAddressSet(address, CollationRelationId, collOid);
 
    heap_freetuple(tup);
    table_close(rel, NoLock);
 
    return address;
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, CatalogTupleUpdate(), CStringGetTextDatum, elog, ereport, errhint(), errmsg(), ERROR, get_collation_actual_version(), get_collation_oid(), GETSTRUCT(), GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, NameListToString(), NoLock, NOTICE, OBJECT_COLLATION, object_ownercheck(), ObjectAddressSet, ObjectIdGetDatum(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, stmt, SysCacheGetAttr(), SysCacheGetAttrNotNull(), HeapTupleData::t_self, table_close(), table_open(), TextDatumGetCString, and values.

Referenced by ProcessUtilitySlow().

cmpaliases()

static int cmpaliases ( const void *  a, const void *  b  )

static

Definition at line 631 of file collationcmds.c.

{
    const CollAliasData *ca = (const CollAliasData *) a;
    const CollAliasData *cb = (const CollAliasData *) b;
 
    /* comparing localename is enough because other fields are derived */
    return strcmp(ca->localename, cb->localename);
}

References a, b, and CollAliasData::localename.

Referenced by pg_import_system_collations().

DefineCollation()

ObjectAddress DefineCollation	(	ParseState *	pstate,
		List *	names,
		List *	parameters,
		bool	if_not_exists
	)

Definition at line 57 of file collationcmds.c.

{
    char       *collName;
    Oid         collNamespace;
    AclResult   aclresult;
    ListCell   *pl;
    DefElem    *fromEl = NULL;
    DefElem    *localeEl = NULL;
    DefElem    *lccollateEl = NULL;
    DefElem    *lcctypeEl = NULL;
    DefElem    *providerEl = NULL;
    DefElem    *deterministicEl = NULL;
    DefElem    *rulesEl = NULL;
    DefElem    *versionEl = NULL;
    char       *collcollate;
    char       *collctype;
    const char *colllocale;
    char       *collicurules;
    bool        collisdeterministic;
    int         collencoding;
    char        collprovider;
    char       *collversion = NULL;
    Oid         newoid;
    ObjectAddress address;
 
    collNamespace = QualifiedNameGetCreationNamespace(names, &collName);
 
    aclresult = object_aclcheck(NamespaceRelationId, collNamespace, GetUserId(), ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA,
                       get_namespace_name(collNamespace));
 
    foreach(pl, parameters)
    {
        DefElem    *defel = lfirst_node(DefElem, pl);
        DefElem   **defelp;
 
        if (strcmp(defel->defname, "from") == 0)
            defelp = &fromEl;
        else if (strcmp(defel->defname, "locale") == 0)
            defelp = &localeEl;
        else if (strcmp(defel->defname, "lc_collate") == 0)
            defelp = &lccollateEl;
        else if (strcmp(defel->defname, "lc_ctype") == 0)
            defelp = &lcctypeEl;
        else if (strcmp(defel->defname, "provider") == 0)
            defelp = &providerEl;
        else if (strcmp(defel->defname, "deterministic") == 0)
            defelp = &deterministicEl;
        else if (strcmp(defel->defname, "rules") == 0)
            defelp = &rulesEl;
        else if (strcmp(defel->defname, "version") == 0)
            defelp = &versionEl;
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("collation attribute \"%s\" not recognized",
                            defel->defname),
                     parser_errposition(pstate, defel->location)));
            break;
        }
        if (*defelp != NULL)
            errorConflictingDefElem(defel, pstate);
        *defelp = defel;
    }
 
    if (localeEl && (lccollateEl || lcctypeEl))
        ereport(ERROR,
                errcode(ERRCODE_SYNTAX_ERROR),
                errmsg("conflicting or redundant options"),
                errdetail("LOCALE cannot be specified together with LC_COLLATE or LC_CTYPE."));
 
    if (fromEl && list_length(parameters) != 1)
        ereport(ERROR,
                errcode(ERRCODE_SYNTAX_ERROR),
                errmsg("conflicting or redundant options"),
                errdetail("FROM cannot be specified together with any other options."));
 
    if (fromEl)
    {
        Oid         collid;
        HeapTuple   tp;
        Datum       datum;
        bool        isnull;
 
        collid = get_collation_oid(defGetQualifiedName(fromEl), false);
        tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
        if (!HeapTupleIsValid(tp))
            elog(ERROR, "cache lookup failed for collation %u", collid);
 
        collprovider = ((Form_pg_collation) GETSTRUCT(tp))->collprovider;
        collisdeterministic = ((Form_pg_collation) GETSTRUCT(tp))->collisdeterministic;
        collencoding = ((Form_pg_collation) GETSTRUCT(tp))->collencoding;
 
        datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collcollate, &isnull);
        if (!isnull)
            collcollate = TextDatumGetCString(datum);
        else
            collcollate = NULL;
 
        datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collctype, &isnull);
        if (!isnull)
            collctype = TextDatumGetCString(datum);
        else
            collctype = NULL;
 
        datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_colllocale, &isnull);
        if (!isnull)
            colllocale = TextDatumGetCString(datum);
        else
            colllocale = NULL;
 
        /*
         * When the ICU locale comes from an existing collation, do not
         * canonicalize to a language tag.
         */
 
        datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collicurules, &isnull);
        if (!isnull)
            collicurules = TextDatumGetCString(datum);
        else
            collicurules = NULL;
 
        ReleaseSysCache(tp);
 
        /*
         * Copying the "default" collation is not allowed because most code
         * checks for DEFAULT_COLLATION_OID instead of COLLPROVIDER_DEFAULT,
         * and so having a second collation with COLLPROVIDER_DEFAULT would
         * not work and potentially confuse or crash some code.  This could be
         * fixed with some legwork.
         */
        if (collprovider == COLLPROVIDER_DEFAULT)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("collation \"default\" cannot be copied")));
    }
    else
    {
        char       *collproviderstr = NULL;
 
        collcollate = NULL;
        collctype = NULL;
        colllocale = NULL;
        collicurules = NULL;
 
        if (providerEl)
            collproviderstr = defGetString(providerEl);
 
        if (deterministicEl)
            collisdeterministic = defGetBoolean(deterministicEl);
        else
            collisdeterministic = true;
 
        if (rulesEl)
            collicurules = defGetString(rulesEl);
 
        if (versionEl)
            collversion = defGetString(versionEl);
 
        if (collproviderstr)
        {
            if (pg_strcasecmp(collproviderstr, "builtin") == 0)
                collprovider = COLLPROVIDER_BUILTIN;
            else if (pg_strcasecmp(collproviderstr, "icu") == 0)
                collprovider = COLLPROVIDER_ICU;
            else if (pg_strcasecmp(collproviderstr, "libc") == 0)
                collprovider = COLLPROVIDER_LIBC;
            else
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("unrecognized collation provider: %s",
                                collproviderstr)));
        }
        else
            collprovider = COLLPROVIDER_LIBC;
 
        if (localeEl)
        {
            if (collprovider == COLLPROVIDER_LIBC)
            {
                collcollate = defGetString(localeEl);
                collctype = defGetString(localeEl);
            }
            else
                colllocale = defGetString(localeEl);
        }
 
        if (lccollateEl)
            collcollate = defGetString(lccollateEl);
 
        if (lcctypeEl)
            collctype = defGetString(lcctypeEl);
 
        if (collprovider == COLLPROVIDER_BUILTIN)
        {
            if (!colllocale)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("parameter \"%s\" must be specified",
                                "locale")));
 
            colllocale = builtin_validate_locale(GetDatabaseEncoding(),
                                                 colllocale);
        }
        else if (collprovider == COLLPROVIDER_LIBC)
        {
            if (!collcollate)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("parameter \"%s\" must be specified",
                                "lc_collate")));
 
            if (!collctype)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("parameter \"%s\" must be specified",
                                "lc_ctype")));
        }
        else if (collprovider == COLLPROVIDER_ICU)
        {
            if (!colllocale)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("parameter \"%s\" must be specified",
                                "locale")));
 
            /*
             * During binary upgrade, preserve the locale string. Otherwise,
             * canonicalize to a language tag.
             */
            if (!IsBinaryUpgrade)
            {
                char       *langtag = icu_language_tag(colllocale,
                                                       icu_validation_level);
 
                if (langtag && strcmp(colllocale, langtag) != 0)
                {
                    ereport(NOTICE,
                            (errmsg("using standard form \"%s\" for ICU locale \"%s\"",
                                    langtag, colllocale)));
 
                    colllocale = langtag;
                }
            }
 
            icu_validate_locale(colllocale);
        }
 
        /*
         * Nondeterministic collations are currently only supported with ICU
         * because that's the only case where it can actually make a
         * difference. So we can save writing the code for the other
         * providers.
         */
        if (!collisdeterministic && collprovider != COLLPROVIDER_ICU)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("nondeterministic collations not supported with this provider")));
 
        if (collicurules && collprovider != COLLPROVIDER_ICU)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("ICU rules cannot be specified unless locale provider is ICU")));
 
        if (collprovider == COLLPROVIDER_BUILTIN)
        {
            collencoding = builtin_locale_encoding(colllocale);
        }
        else if (collprovider == COLLPROVIDER_ICU)
        {
#ifdef USE_ICU
            /*
             * We could create ICU collations with collencoding == database
             * encoding, but it seems better to use -1 so that it matches the
             * way initdb would create ICU collations.  However, only allow
             * one to be created when the current database's encoding is
             * supported.  Otherwise the collation is useless, plus we get
             * surprising behaviors like not being able to drop the collation.
             *
             * Skip this test when !USE_ICU, because the error we want to
             * throw for that isn't thrown till later.
             */
            if (!is_encoding_supported_by_icu(GetDatabaseEncoding()))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("current database's encoding is not supported with this provider")));
#endif
            collencoding = -1;
        }
        else
        {
            collencoding = GetDatabaseEncoding();
            check_encoding_locale_matches(collencoding, collcollate, collctype);
        }
    }
 
    if (!collversion)
    {
        const char *locale;
 
        if (collprovider == COLLPROVIDER_LIBC)
            locale = collcollate;
        else
            locale = colllocale;
 
        collversion = get_collation_actual_version(collprovider, locale);
    }
 
    newoid = CollationCreate(collName,
                             collNamespace,
                             GetUserId(),
                             collprovider,
                             collisdeterministic,
                             collencoding,
                             collcollate,
                             collctype,
                             colllocale,
                             collicurules,
                             collversion,
                             if_not_exists,
                             false);    /* not quiet */
 
    if (!OidIsValid(newoid))
        return InvalidObjectAddress;
 
    /* Check that the locales can be loaded. */
    CommandCounterIncrement();
    (void) pg_newlocale_from_collation(newoid);
 
    ObjectAddressSet(address, CollationRelationId, newoid);
 
    return address;
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, builtin_locale_encoding(), builtin_validate_locale(), check_encoding_locale_matches(), CollationCreate(), collid, CommandCounterIncrement(), defGetBoolean(), defGetQualifiedName(), defGetString(), DefElem::defname, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, errorConflictingDefElem(), get_collation_actual_version(), get_collation_oid(), get_namespace_name(), GetDatabaseEncoding(), GETSTRUCT(), GetUserId(), HeapTupleIsValid, icu_language_tag(), icu_validate_locale(), icu_validation_level, InvalidObjectAddress, is_encoding_supported_by_icu(), IsBinaryUpgrade, lfirst_node, list_length(), locale, DefElem::location, NOTICE, object_aclcheck(), OBJECT_SCHEMA, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, parser_errposition(), pg_newlocale_from_collation(), pg_strcasecmp(), QualifiedNameGetCreationNamespace(), ReleaseSysCache(), SearchSysCache1(), SysCacheGetAttr(), and TextDatumGetCString.

Referenced by ProcessUtilitySlow().

if() [1/4]

if

(

!

pg_is_asciilocale

)

Definition at line 712 of file collationcmds.c.

    {
        elog(DEBUG1, "skipping locale with non-ASCII name: \"%s\"", locale);
        return -1;
    }

References DEBUG1, elog, and locale.

if() [2/4]

if

(

!

PG_VALID_BE_ENCODINGenc

)

Definition at line 724 of file collationcmds.c.

    {
        elog(DEBUG1, "skipping locale with client-only encoding: \"%s\"", locale);
        return -1;
    }

References DEBUG1, elog, and locale.

if() [3/4]

if

(

collid = CollationCreate(

enc = = PG_SQL_ASCII

)

Definition at line 729 of file collationcmds.c.

    {
        (*ncreatedp)++;
 
        /* Must do CCI between inserts to handle duplicates correctly */
        CommandCounterIncrement();
    }

if() [4/4]

if

(

)

Definition at line 719 of file collationcmds.c.

    {
        elog(DEBUG1, "skipping locale with unrecognized encoding: \"%s\"", locale);
        return -1;
    }

References DEBUG1, elog, and locale.

IsThereCollationInNamespace()

void IsThereCollationInNamespace	(	const char *	collname,
		Oid	nspOid
	)

Definition at line 400 of file collationcmds.c.

{
    /* make sure the name doesn't already exist in new schema */
    if (SearchSysCacheExists3(COLLNAMEENCNSP,
                              CStringGetDatum(collname),
                              Int32GetDatum(GetDatabaseEncoding()),
                              ObjectIdGetDatum(nspOid)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("collation \"%s\" for encoding \"%s\" already exists in schema \"%s\"",
                        collname, GetDatabaseEncodingName(),
                        get_namespace_name(nspOid))));
 
    /* mustn't match an any-encoding entry, either */
    if (SearchSysCacheExists3(COLLNAMEENCNSP,
                              CStringGetDatum(collname),
                              Int32GetDatum(-1),
                              ObjectIdGetDatum(nspOid)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("collation \"%s\" already exists in schema \"%s\"",
                        collname, get_namespace_name(nspOid))));
}

References CStringGetDatum(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, get_namespace_name(), GetDatabaseEncoding(), GetDatabaseEncodingName(), Int32GetDatum(), ObjectIdGetDatum(), and SearchSysCacheExists3.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

normalize_libc_locale_name()

static bool normalize_libc_locale_name ( char *  new, const char *  old  )

static

Definition at line 600 of file collationcmds.c.

{
    char       *n = new;
    const char *o = old;
    bool        changed = false;
 
    while (*o)
    {
        if (*o == '.')
        {
            /* skip over encoding tag such as ".utf8" or ".UTF-8" */
            o++;
            while ((*o >= 'A' && *o <= 'Z')
                   || (*o >= 'a' && *o <= 'z')
                   || (*o >= '0' && *o <= '9')
                   || (*o == '-'))
                o++;
            changed = true;
        }
        else
            *n++ = *o++;
    }
    *n = '\0';
 
    return changed;
}

Referenced by pg_import_system_collations().

pg_attribute_unused()

pg_attribute_unused

(

)

const

pg_collation_actual_version()

Datum pg_collation_actual_version

(

PG_FUNCTION_ARGS

)

Definition at line 511 of file collationcmds.c.

{
    Oid         collid = PG_GETARG_OID(0);
    char        provider;
    char       *locale;
    char       *version;
    Datum       datum;
 
    if (collid == DEFAULT_COLLATION_OID)
    {
        /* retrieve from pg_database */
 
        HeapTuple   dbtup = SearchSysCache1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));
 
        if (!HeapTupleIsValid(dbtup))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("database with OID %u does not exist", MyDatabaseId)));
 
        provider = ((Form_pg_database) GETSTRUCT(dbtup))->datlocprovider;
 
        if (provider == COLLPROVIDER_LIBC)
        {
            datum = SysCacheGetAttrNotNull(DATABASEOID, dbtup, Anum_pg_database_datcollate);
            locale = TextDatumGetCString(datum);
        }
        else
        {
            datum = SysCacheGetAttrNotNull(DATABASEOID, dbtup, Anum_pg_database_datlocale);
            locale = TextDatumGetCString(datum);
        }
 
        ReleaseSysCache(dbtup);
    }
    else
    {
        /* retrieve from pg_collation */
 
        HeapTuple   colltp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
 
        if (!HeapTupleIsValid(colltp))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("collation with OID %u does not exist", collid)));
 
        provider = ((Form_pg_collation) GETSTRUCT(colltp))->collprovider;
        Assert(provider != COLLPROVIDER_DEFAULT);
 
        if (provider == COLLPROVIDER_LIBC)
        {
            datum = SysCacheGetAttrNotNull(COLLOID, colltp, Anum_pg_collation_collcollate);
            locale = TextDatumGetCString(datum);
        }
        else
        {
            datum = SysCacheGetAttrNotNull(COLLOID, colltp, Anum_pg_collation_colllocale);
            locale = TextDatumGetCString(datum);
        }
 
        ReleaseSysCache(colltp);
    }
 
    version = get_collation_actual_version(provider, locale);
    if (version)
        PG_RETURN_TEXT_P(cstring_to_text(version));
    else
        PG_RETURN_NULL();
}

References Assert(), collid, cstring_to_text(), datlocprovider, ereport, errcode(), errmsg(), ERROR, get_collation_actual_version(), GETSTRUCT(), HeapTupleIsValid, locale, MyDatabaseId, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, provider, ReleaseSysCache(), SearchSysCache1(), SysCacheGetAttrNotNull(), and TextDatumGetCString.

pg_import_system_collations()

Datum pg_import_system_collations

(

PG_FUNCTION_ARGS

)

Definition at line 840 of file collationcmds.c.

{
    Oid         nspid = PG_GETARG_OID(0);
    int         ncreated = 0;
 
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to import system collations")));
 
    if (!SearchSysCacheExists1(NAMESPACEOID, ObjectIdGetDatum(nspid)))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_SCHEMA),
                 errmsg("schema with OID %u does not exist", nspid)));
 
    /* Load collations known to libc, using "locale -a" to enumerate them */
#ifdef READ_LOCALE_A_OUTPUT
    {
        FILE       *locale_a_handle;
        char        localebuf[LOCALE_NAME_BUFLEN];
        int         nvalid = 0;
        Oid         collid;
        CollAliasData *aliases;
        int         naliases,
                    maxaliases,
                    i;
 
        /* expansible array of aliases */
        maxaliases = 100;
        aliases = (CollAliasData *) palloc(maxaliases * sizeof(CollAliasData));
        naliases = 0;
 
        locale_a_handle = OpenPipeStream("locale -a", "r");
        if (locale_a_handle == NULL)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not execute command \"%s\": %m",
                            "locale -a")));
 
        while (fgets(localebuf, sizeof(localebuf), locale_a_handle))
        {
            size_t      len;
            int         enc;
            char        alias[LOCALE_NAME_BUFLEN];
 
            len = strlen(localebuf);
 
            if (len == 0 || localebuf[len - 1] != '\n')
            {
                elog(DEBUG1, "skipping locale with too-long name: \"%s\"", localebuf);
                continue;
            }
            localebuf[len - 1] = '\0';
 
            enc = create_collation_from_locale(localebuf, nspid, &nvalid, &ncreated);
            if (enc < 0)
                continue;
 
            /*
             * Generate aliases such as "en_US" in addition to "en_US.utf8"
             * for ease of use.  Note that collation names are unique per
             * encoding only, so this doesn't clash with "en_US" for LATIN1,
             * say.
             *
             * However, it might conflict with a name we'll see later in the
             * "locale -a" output.  So save up the aliases and try to add them
             * after we've read all the output.
             */
            if (normalize_libc_locale_name(alias, localebuf))
            {
                if (naliases >= maxaliases)
                {
                    maxaliases *= 2;
                    aliases = (CollAliasData *)
                        repalloc(aliases, maxaliases * sizeof(CollAliasData));
                }
                aliases[naliases].localename = pstrdup(localebuf);
                aliases[naliases].alias = pstrdup(alias);
                aliases[naliases].enc = enc;
                naliases++;
            }
        }
 
        /*
         * We don't check the return value of this, because we want to support
         * the case where there "locale" command does not exist.  (This is
         * unusual but can happen on minimalized Linux distributions, for
         * example.)  We will warn below if no locales could be found.
         */
        ClosePipeStream(locale_a_handle);
 
        /*
         * Before processing the aliases, sort them by locale name.  The point
         * here is that if "locale -a" gives us multiple locale names with the
         * same encoding and base name, say "en_US.utf8" and "en_US.utf-8", we
         * want to pick a deterministic one of them.  First in ASCII sort
         * order is a good enough rule.  (Before PG 10, the code corresponding
         * to this logic in initdb.c had an additional ordering rule, to
         * prefer the locale name exactly matching the alias, if any.  We
         * don't need to consider that here, because we would have already
         * created such a pg_collation entry above, and that one will win.)
         */
        if (naliases > 1)
            qsort(aliases, naliases, sizeof(CollAliasData), cmpaliases);
 
        /* Now add aliases, ignoring any that match pre-existing entries */
        for (i = 0; i < naliases; i++)
        {
            char       *locale = aliases[i].localename;
            char       *alias = aliases[i].alias;
            int         enc = aliases[i].enc;
 
            collid = CollationCreate(alias, nspid, GetUserId(),
                                     COLLPROVIDER_LIBC, true, enc,
                                     locale, locale, NULL, NULL,
                                     get_collation_actual_version(COLLPROVIDER_LIBC, locale),
                                     true, true);
            if (OidIsValid(collid))
            {
                ncreated++;
 
                CommandCounterIncrement();
            }
        }
 
        /* Give a warning if "locale -a" seems to be malfunctioning */
        if (nvalid == 0)
            ereport(WARNING,
                    (errmsg("no usable system locales were found")));
    }
#endif                          /* READ_LOCALE_A_OUTPUT */
 
    /*
     * Load collations known to ICU
     *
     * We use uloc_countAvailable()/uloc_getAvailable() rather than
     * ucol_countAvailable()/ucol_getAvailable().  The former returns a full
     * set of language+region combinations, whereas the latter only returns
     * language+region combinations if they are distinct from the language's
     * base collation.  So there might not be a de-DE or en-GB, which would be
     * confusing.
     */
#ifdef USE_ICU
    {
        int         i;
 
        /*
         * Start the loop at -1 to sneak in the root locale without too much
         * code duplication.
         */
        for (i = -1; i < uloc_countAvailable(); i++)
        {
            const char *name;
            char       *langtag;
            char       *icucomment;
            Oid         collid;
 
            if (i == -1)
                name = "";      /* ICU root locale */
            else
                name = uloc_getAvailable(i);
 
            langtag = icu_language_tag(name, ERROR);
 
            /*
             * Be paranoid about not allowing any non-ASCII strings into
             * pg_collation
             */
            if (!pg_is_ascii(langtag))
                continue;
 
            collid = CollationCreate(psprintf("%s-x-icu", langtag),
                                     nspid, GetUserId(),
                                     COLLPROVIDER_ICU, true, -1,
                                     NULL, NULL, langtag, NULL,
                                     get_collation_actual_version(COLLPROVIDER_ICU, langtag),
                                     true, true);
            if (OidIsValid(collid))
            {
                ncreated++;
 
                CommandCounterIncrement();
 
                icucomment = get_icu_locale_comment(name);
                if (icucomment)
                    CreateComments(collid, CollationRelationId, 0,
                                   icucomment);
            }
        }
    }
#endif                          /* USE_ICU */
 
    /* Load collations known to WIN32 */
#ifdef ENUM_SYSTEM_LOCALE
    {
        int         nvalid = 0;
        CollParam   param;
 
        param.nspid = nspid;
        param.ncreatedp = &ncreated;
        param.nvalidp = &nvalid;
 
        /*
         * Enumerate the locales that are either installed on or supported by
         * the OS.
         */
        if (!EnumSystemLocalesEx(win32_read_locale, LOCALE_ALL,
                                 (LPARAM) &param, NULL))
            _dosmaperr(GetLastError());
 
        /* Give a warning if EnumSystemLocalesEx seems to be malfunctioning */
        if (nvalid == 0)
            ereport(WARNING,
                    (errmsg("no usable system locales were found")));
    }
#endif                          /* ENUM_SYSTEM_LOCALE */
 
    PG_RETURN_INT32(ncreated);
}

References _dosmaperr(), CollAliasData::alias, ClosePipeStream(), cmpaliases(), CollationCreate(), collid, CommandCounterIncrement(), CreateComments(), DEBUG1, elog, CollAliasData::enc, enc, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, get_collation_actual_version(), GetUserId(), i, icu_language_tag(), len, locale, LOCALE_NAME_BUFLEN, CollAliasData::localename, name, normalize_libc_locale_name(), nspid, ObjectIdGetDatum(), OidIsValid, OpenPipeStream(), palloc(), PG_GETARG_OID, pg_is_ascii(), PG_RETURN_INT32, psprintf(), pstrdup(), qsort, repalloc(), SearchSysCacheExists1, superuser(), and WARNING.

Variable Documentation

collid

Oid collid

Definition at line 704 of file collationcmds.c.

Referenced by add_column_collation_dependency(), bpchar_sortsupport(), bpchareq(), bpcharne(), btnamesortsupport(), bttextsortsupport(), btvarstrequalimage(), check_collation_set(), citextcmp(), CollationGetCollid(), CollationIsVisible(), CollationIsVisibleExt(), convert_string_datum(), convert_to_scalar(), create_pg_locale(), create_pg_locale_builtin(), create_pg_locale_icu(), create_pg_locale_libc(), datetime_to_char_body(), DCH_from_char(), DCH_to_char(), DefineCollation(), do_to_timestamp(), ExecBuildGroupingEqual(), ExecBuildParamSetEqual(), executeDateTimeMethod(), find_expr_references_walker(), from_char_seq_search(), generate_collation_name(), get_atttypetypmodcoll(), hashbpchar(), hashbpcharextended(), hashtext(), hashtextextended(), lookup_collation(), mcv_get_match_bitmap(), mcv_match_expression(), namecmp(), nameeqtext(), namenetext(), ndistinct_for_combination(), parse_datetime(), pg_collation_actual_version(), pg_collation_for(), pg_import_system_collations(), pg_newlocale_from_collation(), ri_CompareWithCast(), seq_search_localized(), str_casefold(), str_initcap(), str_initcap_z(), str_tolower(), str_tolower_z(), str_toupper(), str_toupper_z(), t_starts_with(), text_cmp(), text_isequal(), text_position(), text_position_setup(), text_starts_with(), texteq(), texteqname(), textne(), textnename(), to_date(), to_timestamp(), varstr_cmp(), and varstr_sortsupport().

enc

return enc = pg_get_encoding_from_locale(locale, false)

Definition at line 718 of file collationcmds.c.

Referenced by checkJsonOutputFormat(), coerceJsonFuncExpr(), encode_to_ascii(), encodingid_to_string(), get_encoding_id(), getJsonEncodingConst(), pg_import_system_collations(), pg_stat_statements_internal(), pg_to_ascii(), pg_valid_client_encoding(), pg_valid_server_encoding(), to_ascii_default(), to_ascii_enc(), and to_ascii_encname().

ncreatedp

int int int* ncreatedp

Initial value:

{
    int         enc

Definition at line 701 of file collationcmds.c.

nspid

int nspid

Definition at line 700 of file collationcmds.c.

Referenced by CreateTableAsRelExists(), database_to_xml_internal(), get_namespace_name(), get_namespace_name_or_temp(), getDefaultACLs(), logicalrep_write_namespace(), map_sql_catalog_to_xmlschema_types(), map_sql_schema_to_xmlschema_types(), pg_import_system_collations(), RangeVarAdjustRelationPersistence(), RangeVarGetAndCheckCreationNamespace(), regnamespaceout(), schema_get_xml_visible_tables(), schema_to_xml(), schema_to_xml_and_xmlschema(), schema_to_xml_internal(), schema_to_xmlschema_internal(), and transformPartitionCmdForSplit().

nvalidp

int int* nvalidp

Definition at line 701 of file collationcmds.c.