collationcmds.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_collation.h"
#include "commands/alter.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

Functions
ObjectAddress	DefineCollation (ParseState *pstate, List *names, List *parameters, bool if_not_exists)
void	IsThereCollationInNamespace (const char *collname, Oid nspOid)
Datum	pg_collation_actual_version (PG_FUNCTION_ARGS)
Datum	pg_import_system_collations (PG_FUNCTION_ARGS)

Function Documentation

DefineCollation()

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

Definition at line 53 of file collationcmds.c.

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, check_encoding_locale_matches(), CollationCreate(), COLLOID, CommandCounterIncrement(), defGetBoolean(), defGetQualifiedName(), defGetString(), DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, get_collation_oid(), get_namespace_name(), GetDatabaseEncoding(), GETSTRUCT, GetUserId(), HeapTupleIsValid, InvalidObjectAddress, lc_collate_is_c(), lc_ctype_is_c(), lfirst_node, list_length(), DefElem::location, NameStr, OBJECT_SCHEMA, ObjectAddressSet, ObjectIdGetDatum, OidIsValid, parser_errposition(), pg_namespace_aclcheck(), pg_newlocale_from_collation(), pg_strcasecmp(), pstrdup(), QualifiedNameGetCreationNamespace(), ReleaseSysCache(), and SearchSysCache1().

Referenced by ProcessUtilitySlow().

{
    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;
    char       *collcollate = NULL;
    char       *collctype = NULL;
    char       *collproviderstr = NULL;
    bool        collisdeterministic = true;
    int         collencoding = 0;
    char        collprovider = 0;
    Oid         newoid;
    ObjectAddress address;

    collNamespace = QualifiedNameGetCreationNamespace(names, &collName);

    aclresult = pg_namespace_aclcheck(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
        {
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("collation attribute \"%s\" not recognized",
                            defel->defname),
                     parser_errposition(pstate, defel->location)));
            break;
        }

        *defelp = defel;
    }

    if ((localeEl && (lccollateEl || lcctypeEl))
        || (fromEl && list_length(parameters) != 1))
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("conflicting or redundant options")));

    if (fromEl)
    {
        Oid         collid;
        HeapTuple   tp;

        collid = get_collation_oid(defGetQualifiedName(fromEl), false);
        tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
        if (!HeapTupleIsValid(tp))
            elog(ERROR, "cache lookup failed for collation %u", collid);

        collcollate = pstrdup(NameStr(((Form_pg_collation) GETSTRUCT(tp))->collcollate));
        collctype = pstrdup(NameStr(((Form_pg_collation) GETSTRUCT(tp))->collctype));
        collprovider = ((Form_pg_collation) GETSTRUCT(tp))->collprovider;
        collisdeterministic = ((Form_pg_collation) GETSTRUCT(tp))->collisdeterministic;
        collencoding = ((Form_pg_collation) GETSTRUCT(tp))->collencoding;

        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")));
    }

    if (localeEl)
    {
        collcollate = defGetString(localeEl);
        collctype = defGetString(localeEl);
    }

    if (lccollateEl)
        collcollate = defGetString(lccollateEl);

    if (lcctypeEl)
        collctype = defGetString(lcctypeEl);

    if (providerEl)
        collproviderstr = defGetString(providerEl);

    if (deterministicEl)
        collisdeterministic = defGetBoolean(deterministicEl);

    if (collproviderstr)
    {
        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 if (!fromEl)
        collprovider = COLLPROVIDER_LIBC;

    if (!collcollate)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("parameter \"lc_collate\" must be specified")));

    if (!collctype)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("parameter \"lc_ctype\" must be specified")));

    /*
     * 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 (!fromEl)
    {
        if (collprovider == COLLPROVIDER_ICU)
            collencoding = -1;
        else
        {
            collencoding = GetDatabaseEncoding();
            check_encoding_locale_matches(collencoding, collcollate, collctype);
        }
    }

    newoid = CollationCreate(collName,
                             collNamespace,
                             GetUserId(),
                             collprovider,
                             collisdeterministic,
                             collencoding,
                             collcollate,
                             collctype,
                             if_not_exists,
                             false);    /* not quiet */

    if (!OidIsValid(newoid))
        return InvalidObjectAddress;

    /*
     * Check that the locales can be loaded.  NB: pg_newlocale_from_collation
     * is only supposed to be called on non-C-equivalent locales.
     */
    CommandCounterIncrement();
    if (!lc_collate_is_c(newoid) || !lc_ctype_is_c(newoid))
        (void) pg_newlocale_from_collation(newoid);

    ObjectAddressSet(address, CollationRelationId, newoid);

    return address;
}

IsThereCollationInNamespace()

void IsThereCollationInNamespace	(	const char *	collname,
		Oid	nspOid
	)

Definition at line 246 of file collationcmds.c.

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

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

{
    /* 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))));
}

pg_collation_actual_version()

Datum pg_collation_actual_version

(

PG_FUNCTION_ARGS

)

Definition at line 271 of file collationcmds.c.

References buf, cstring_to_text(), ereport, errmsg(), ERROR, get_collation_version_for_oid(), i, lengthof, CollAliasData::localename, palloc(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, pstrdup(), and status().

{
    Oid         collid = PG_GETARG_OID(0);
    char       *version;

    version = get_collation_version_for_oid(collid, true);

    if (version)
        PG_RETURN_TEXT_P(cstring_to_text(version));
    else
        PG_RETURN_NULL();
}

pg_import_system_collations()

Datum pg_import_system_collations

(

PG_FUNCTION_ARGS

)

Definition at line 405 of file collationcmds.c.

References CollAliasData::alias, ClosePipeStream(), CollationCreate(), CommandCounterIncrement(), CreateComments(), DEBUG1, elog, CollAliasData::enc, enc, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, GetUserId(), i, locale, CollAliasData::localename, name, NAMEDATALEN, NAMESPACEOID, ObjectIdGetDatum, OidIsValid, OpenPipeStream(), palloc(), pg_get_encoding_from_locale(), PG_GETARG_OID, pg_is_ascii(), PG_RETURN_INT32, PG_SQL_ASCII, PG_VALID_BE_ENCODING, psprintf(), pstrdup(), qsort, repalloc(), SearchSysCacheExists1, superuser(), and WARNING.

{
    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[NAMEDATALEN]; /* we assume ASCII so this is fine */
        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[NAMEDATALEN];

            len = strlen(localebuf);

            if (len == 0 || localebuf[len - 1] != '\n')
            {
                elog(DEBUG1, "locale name too long, skipped: \"%s\"", localebuf);
                continue;
            }
            localebuf[len - 1] = '\0';

            /*
             * Some systems have locale names that don't consist entirely of
             * ASCII letters (such as "bokmål" or "français").
             * This is pretty silly, since we need the locale itself to
             * interpret the non-ASCII characters. We can't do much with
             * those, so we filter them out.
             */
            if (!pg_is_ascii(localebuf))
            {
                elog(DEBUG1, "locale name has non-ASCII characters, skipped: \"%s\"", localebuf);
                continue;
            }

            enc = pg_get_encoding_from_locale(localebuf, false);
            if (enc < 0)
            {
                /* error message printed by pg_get_encoding_from_locale() */
                continue;
            }
            if (!PG_VALID_BE_ENCODING(enc))
                continue;       /* ignore locales for client-only encodings */
            if (enc == PG_SQL_ASCII)
                continue;       /* C/POSIX are already in the catalog */

            /* count valid locales found in operating system */
            nvalid++;

            /*
             * Create a collation named the same as the locale, but quietly
             * doing nothing if it already exists.  This is the behavior we
             * need even at initdb time, because some versions of "locale -a"
             * can report the same locale name more than once.  And it's
             * convenient for later import runs, too, since you just about
             * always want to add on new locales without a lot of chatter
             * about existing ones.
             */
            collid = CollationCreate(localebuf, nspid, GetUserId(),
                                     COLLPROVIDER_LIBC, true, enc,
                                     localebuf, localebuf,
                                     true, true);
            if (OidIsValid(collid))
            {
                ncreated++;

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

            /*
             * 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++;
            }
        }

        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((void *) 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,
                                     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;
            const char *collcollate;
            Oid         collid;

            if (i == -1)
                name = "";      /* ICU root locale */
            else
                name = uloc_getAvailable(i);

            langtag = get_icu_language_tag(name);
            collcollate = U_ICU_VERSION_MAJOR_NUM >= 54 ? langtag : name;

            /*
             * Be paranoid about not allowing any non-ASCII strings into
             * pg_collation
             */
            if (!pg_is_ascii(langtag) || !pg_is_ascii(collcollate))
                continue;

            collid = CollationCreate(psprintf("%s-x-icu", langtag),
                                     nspid, GetUserId(),
                                     COLLPROVIDER_ICU, true, -1,
                                     collcollate, collcollate,
                                     true, true);
            if (OidIsValid(collid))
            {
                ncreated++;

                CommandCounterIncrement();

                icucomment = get_icu_locale_comment(name);
                if (icucomment)
                    CreateComments(collid, CollationRelationId, 0,
                                   icucomment);
            }
        }
    }
#endif                          /* USE_ICU */

    PG_RETURN_INT32(ncreated);
}