2011-02-12 14:54:13 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* collationcmds.c
|
2011-03-11 19:20:11 +01:00
|
|
|
* collation-related commands support code
|
2011-02-12 14:54:13 +01:00
|
|
|
*
|
|
|
|
* Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
|
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
|
|
|
* src/backend/commands/collationcmds.c
|
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#include "postgres.h"
|
|
|
|
|
|
|
|
#include "access/heapam.h"
|
2011-03-04 21:14:37 +01:00
|
|
|
#include "access/xact.h"
|
2011-02-12 14:54:13 +01:00
|
|
|
#include "catalog/dependency.h"
|
|
|
|
#include "catalog/indexing.h"
|
|
|
|
#include "catalog/namespace.h"
|
|
|
|
#include "catalog/pg_collation.h"
|
|
|
|
#include "catalog/pg_collation_fn.h"
|
|
|
|
#include "commands/alter.h"
|
|
|
|
#include "commands/collationcmds.h"
|
|
|
|
#include "commands/dbcommands.h"
|
|
|
|
#include "commands/defrem.h"
|
|
|
|
#include "mb/pg_wchar.h"
|
|
|
|
#include "miscadmin.h"
|
|
|
|
#include "utils/acl.h"
|
|
|
|
#include "utils/builtins.h"
|
|
|
|
#include "utils/lsyscache.h"
|
2011-03-04 21:14:37 +01:00
|
|
|
#include "utils/pg_locale.h"
|
2011-02-12 14:54:13 +01:00
|
|
|
#include "utils/syscache.h"
|
|
|
|
|
|
|
|
static void AlterCollationOwner_internal(Relation rel, Oid collationOid,
|
|
|
|
Oid newOwnerId);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CREATE COLLATION
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
DefineCollation(List *names, List *parameters)
|
|
|
|
{
|
|
|
|
char *collName;
|
|
|
|
Oid collNamespace;
|
|
|
|
AclResult aclresult;
|
|
|
|
ListCell *pl;
|
|
|
|
DefElem *fromEl = NULL;
|
|
|
|
DefElem *localeEl = NULL;
|
|
|
|
DefElem *lccollateEl = NULL;
|
|
|
|
DefElem *lcctypeEl = NULL;
|
|
|
|
char *collcollate = NULL;
|
|
|
|
char *collctype = NULL;
|
2011-03-04 21:14:37 +01:00
|
|
|
Oid newoid;
|
2011-02-12 14:54:13 +01:00
|
|
|
|
|
|
|
collNamespace = QualifiedNameGetCreationNamespace(names, &collName);
|
|
|
|
|
|
|
|
aclresult = pg_namespace_aclcheck(collNamespace, GetUserId(), ACL_CREATE);
|
|
|
|
if (aclresult != ACLCHECK_OK)
|
|
|
|
aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
|
|
|
|
get_namespace_name(collNamespace));
|
|
|
|
|
|
|
|
foreach(pl, parameters)
|
|
|
|
{
|
|
|
|
DefElem *defel = (DefElem *) lfirst(pl);
|
|
|
|
DefElem **defelp;
|
|
|
|
|
|
|
|
if (pg_strcasecmp(defel->defname, "from") == 0)
|
|
|
|
defelp = &fromEl;
|
|
|
|
else if (pg_strcasecmp(defel->defname, "locale") == 0)
|
|
|
|
defelp = &localeEl;
|
|
|
|
else if (pg_strcasecmp(defel->defname, "lc_collate") == 0)
|
|
|
|
defelp = &lccollateEl;
|
|
|
|
else if (pg_strcasecmp(defel->defname, "lc_ctype") == 0)
|
|
|
|
defelp = &lcctypeEl;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
|
|
errmsg("collation attribute \"%s\" not recognized",
|
|
|
|
defel->defname)));
|
|
|
|
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;
|
|
|
|
|
Remove collation information from TypeName, where it does not belong.
The initial collations patch treated a COLLATE spec as part of a TypeName,
following what can only be described as brain fade on the part of the SQL
committee. It's a lot more reasonable to treat COLLATE as a syntactically
separate object, so that it can be added in only the productions where it
actually belongs, rather than needing to reject it in a boatload of places
where it doesn't belong (something the original patch mostly failed to do).
In addition this change lets us meet the spec's requirement to allow
COLLATE anywhere in the clauses of a ColumnDef, and it avoids unfriendly
behavior for constructs such as "foo::type COLLATE collation".
To do this, pull collation information out of TypeName and put it in
ColumnDef instead, thus reverting most of the collation-related changes in
parse_type.c's API. I made one additional structural change, which was to
use a ColumnDef as an intermediate node in AT_AlterColumnType AlterTableCmd
nodes. This provides enough room to get rid of the "transform" wart in
AlterTableCmd too, since the ColumnDef can carry the USING expression
easily enough.
Also fix some other minor bugs that have crept in in the same areas,
like failure to copy recently-added fields of ColumnDef in copyfuncs.c.
While at it, document the formerly secret ability to specify a collation
in ALTER TABLE ALTER COLUMN TYPE, ALTER TYPE ADD ATTRIBUTE, and
ALTER TYPE ALTER ATTRIBUTE TYPE; and correct some misstatements about
what the default collation selection will be when COLLATE is omitted.
BTW, the three-parameter form of format_type() should go away too,
since it just contributes to the confusion in this area; but I'll do
that in a separate patch.
2011-03-10 04:38:52 +01:00
|
|
|
collid = get_collation_oid(defGetQualifiedName(fromEl), false);
|
2011-02-12 14:54:13 +01:00
|
|
|
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));
|
|
|
|
|
|
|
|
ReleaseSysCache(tp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (localeEl)
|
|
|
|
{
|
|
|
|
collcollate = defGetString(localeEl);
|
|
|
|
collctype = defGetString(localeEl);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lccollateEl)
|
|
|
|
collcollate = defGetString(lccollateEl);
|
|
|
|
|
|
|
|
if (lcctypeEl)
|
|
|
|
collctype = defGetString(lcctypeEl);
|
|
|
|
|
|
|
|
if (!collcollate)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
|
|
|
|
errmsg("parameter \"lc_collate\" parameter must be specified")));
|
|
|
|
|
|
|
|
if (!collctype)
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
|
|
|
|
errmsg("parameter \"lc_ctype\" must be specified")));
|
|
|
|
|
|
|
|
check_encoding_locale_matches(GetDatabaseEncoding(), collcollate, collctype);
|
|
|
|
|
2011-03-04 21:14:37 +01:00
|
|
|
newoid = CollationCreate(collName,
|
2011-03-11 19:20:11 +01:00
|
|
|
collNamespace,
|
|
|
|
GetUserId(),
|
|
|
|
GetDatabaseEncoding(),
|
|
|
|
collcollate,
|
|
|
|
collctype);
|
2011-03-04 21:14:37 +01:00
|
|
|
|
|
|
|
/* check that the locales can be loaded */
|
|
|
|
CommandCounterIncrement();
|
|
|
|
pg_newlocale_from_collation(newoid);
|
2011-02-12 14:54:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DROP COLLATION
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
DropCollationsCommand(DropStmt *drop)
|
|
|
|
{
|
|
|
|
ObjectAddresses *objects;
|
|
|
|
ListCell *cell;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First we identify all the collations, then we delete them in a single
|
|
|
|
* performMultipleDeletions() call. This is to avoid unwanted DROP
|
|
|
|
* RESTRICT errors if one of the collations depends on another. (Not that
|
|
|
|
* that is very likely, but we may as well do this consistently.)
|
|
|
|
*/
|
|
|
|
objects = new_object_addresses();
|
|
|
|
|
|
|
|
foreach(cell, drop->objects)
|
|
|
|
{
|
|
|
|
List *name = (List *) lfirst(cell);
|
|
|
|
Oid collationOid;
|
|
|
|
HeapTuple tuple;
|
|
|
|
Form_pg_collation coll;
|
|
|
|
ObjectAddress object;
|
|
|
|
|
|
|
|
collationOid = get_collation_oid(name, drop->missing_ok);
|
|
|
|
|
|
|
|
if (!OidIsValid(collationOid))
|
|
|
|
{
|
|
|
|
ereport(NOTICE,
|
|
|
|
(errmsg("collation \"%s\" does not exist, skipping",
|
|
|
|
NameListToString(name))));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
tuple = SearchSysCache1(COLLOID, ObjectIdGetDatum(collationOid));
|
|
|
|
if (!HeapTupleIsValid(tuple))
|
|
|
|
elog(ERROR, "cache lookup failed for collation %u",
|
|
|
|
collationOid);
|
|
|
|
coll = (Form_pg_collation) GETSTRUCT(tuple);
|
|
|
|
|
|
|
|
/* Permission check: must own collation or its namespace */
|
|
|
|
if (!pg_collation_ownercheck(collationOid, GetUserId()) &&
|
|
|
|
!pg_namespace_ownercheck(coll->collnamespace, GetUserId()))
|
|
|
|
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_COLLATION,
|
|
|
|
NameStr(coll->collname));
|
|
|
|
|
|
|
|
object.classId = CollationRelationId;
|
|
|
|
object.objectId = collationOid;
|
|
|
|
object.objectSubId = 0;
|
|
|
|
|
|
|
|
add_exact_object_address(&object, objects);
|
|
|
|
|
|
|
|
ReleaseSysCache(tuple);
|
|
|
|
}
|
|
|
|
|
|
|
|
performMultipleDeletions(objects, drop->behavior);
|
|
|
|
|
|
|
|
free_object_addresses(objects);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rename collation
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
RenameCollation(List *name, const char *newname)
|
|
|
|
{
|
|
|
|
Oid collationOid;
|
|
|
|
Oid namespaceOid;
|
|
|
|
HeapTuple tup;
|
|
|
|
Relation rel;
|
|
|
|
AclResult aclresult;
|
|
|
|
|
|
|
|
rel = heap_open(CollationRelationId, RowExclusiveLock);
|
|
|
|
|
|
|
|
collationOid = get_collation_oid(name, false);
|
|
|
|
|
|
|
|
tup = SearchSysCacheCopy1(COLLOID, ObjectIdGetDatum(collationOid));
|
|
|
|
if (!HeapTupleIsValid(tup)) /* should not happen */
|
|
|
|
elog(ERROR, "cache lookup failed for collation %u", collationOid);
|
|
|
|
|
|
|
|
namespaceOid = ((Form_pg_collation) GETSTRUCT(tup))->collnamespace;
|
|
|
|
|
|
|
|
/* make sure the new name doesn't exist */
|
|
|
|
if (SearchSysCacheExists3(COLLNAMEENCNSP,
|
|
|
|
CStringGetDatum(newname),
|
|
|
|
Int32GetDatum(GetDatabaseEncoding()),
|
|
|
|
ObjectIdGetDatum(namespaceOid)))
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DUPLICATE_OBJECT),
|
2011-03-11 19:20:11 +01:00
|
|
|
errmsg("collation \"%s\" for encoding \"%s\" already exists in schema \"%s\"",
|
2011-02-12 14:54:13 +01:00
|
|
|
newname,
|
|
|
|
GetDatabaseEncodingName(),
|
|
|
|
get_namespace_name(namespaceOid))));
|
|
|
|
|
2011-03-11 19:20:11 +01:00
|
|
|
/* mustn't match an any-encoding entry, either */
|
|
|
|
if (SearchSysCacheExists3(COLLNAMEENCNSP,
|
|
|
|
CStringGetDatum(newname),
|
|
|
|
Int32GetDatum(-1),
|
|
|
|
ObjectIdGetDatum(namespaceOid)))
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DUPLICATE_OBJECT),
|
|
|
|
errmsg("collation \"%s\" already exists in schema \"%s\"",
|
|
|
|
newname,
|
|
|
|
get_namespace_name(namespaceOid))));
|
|
|
|
|
2011-02-12 14:54:13 +01:00
|
|
|
/* must be owner */
|
|
|
|
if (!pg_collation_ownercheck(collationOid, GetUserId()))
|
|
|
|
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_COLLATION,
|
|
|
|
NameListToString(name));
|
|
|
|
|
|
|
|
/* must have CREATE privilege on namespace */
|
|
|
|
aclresult = pg_namespace_aclcheck(namespaceOid, GetUserId(), ACL_CREATE);
|
|
|
|
if (aclresult != ACLCHECK_OK)
|
|
|
|
aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
|
|
|
|
get_namespace_name(namespaceOid));
|
|
|
|
|
|
|
|
/* rename */
|
|
|
|
namestrcpy(&(((Form_pg_collation) GETSTRUCT(tup))->collname), newname);
|
|
|
|
simple_heap_update(rel, &tup->t_self, tup);
|
|
|
|
CatalogUpdateIndexes(rel, tup);
|
|
|
|
|
|
|
|
heap_freetuple(tup);
|
2011-03-11 19:20:11 +01:00
|
|
|
|
|
|
|
heap_close(rel, RowExclusiveLock);
|
2011-02-12 14:54:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change collation owner, by name
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
AlterCollationOwner(List *name, Oid newOwnerId)
|
|
|
|
{
|
|
|
|
Oid collationOid;
|
|
|
|
Relation rel;
|
|
|
|
|
|
|
|
rel = heap_open(CollationRelationId, RowExclusiveLock);
|
|
|
|
|
|
|
|
collationOid = get_collation_oid(name, false);
|
|
|
|
|
|
|
|
AlterCollationOwner_internal(rel, collationOid, newOwnerId);
|
|
|
|
|
2011-03-11 19:20:11 +01:00
|
|
|
heap_close(rel, RowExclusiveLock);
|
2011-02-12 14:54:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change collation owner, by oid
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
AlterCollationOwner_oid(Oid collationOid, Oid newOwnerId)
|
|
|
|
{
|
|
|
|
Relation rel;
|
|
|
|
|
|
|
|
rel = heap_open(CollationRelationId, RowExclusiveLock);
|
|
|
|
|
|
|
|
AlterCollationOwner_internal(rel, collationOid, newOwnerId);
|
|
|
|
|
2011-03-11 19:20:11 +01:00
|
|
|
heap_close(rel, RowExclusiveLock);
|
2011-02-12 14:54:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* AlterCollationOwner_internal
|
|
|
|
*
|
|
|
|
* Internal routine for changing the owner. rel must be pg_collation, already
|
|
|
|
* open and suitably locked; it will not be closed.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
AlterCollationOwner_internal(Relation rel, Oid collationOid, Oid newOwnerId)
|
|
|
|
{
|
|
|
|
Form_pg_collation collForm;
|
|
|
|
HeapTuple tup;
|
|
|
|
|
|
|
|
Assert(RelationGetRelid(rel) == CollationRelationId);
|
|
|
|
|
|
|
|
tup = SearchSysCacheCopy1(COLLOID, ObjectIdGetDatum(collationOid));
|
|
|
|
if (!HeapTupleIsValid(tup)) /* should not happen */
|
|
|
|
elog(ERROR, "cache lookup failed for collation %u", collationOid);
|
|
|
|
|
|
|
|
collForm = (Form_pg_collation) GETSTRUCT(tup);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the new owner is the same as the existing owner, consider the
|
|
|
|
* command to have succeeded. This is for dump restoration purposes.
|
|
|
|
*/
|
|
|
|
if (collForm->collowner != newOwnerId)
|
|
|
|
{
|
|
|
|
AclResult aclresult;
|
|
|
|
|
|
|
|
/* Superusers can always do it */
|
|
|
|
if (!superuser())
|
|
|
|
{
|
|
|
|
/* Otherwise, must be owner of the existing object */
|
|
|
|
if (!pg_collation_ownercheck(HeapTupleGetOid(tup), GetUserId()))
|
|
|
|
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_COLLATION,
|
|
|
|
NameStr(collForm->collname));
|
|
|
|
|
|
|
|
/* Must be able to become new owner */
|
|
|
|
check_is_member_of_role(GetUserId(), newOwnerId);
|
|
|
|
|
|
|
|
/* New owner must have CREATE privilege on namespace */
|
|
|
|
aclresult = pg_namespace_aclcheck(collForm->collnamespace,
|
|
|
|
newOwnerId,
|
|
|
|
ACL_CREATE);
|
|
|
|
if (aclresult != ACLCHECK_OK)
|
|
|
|
aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
|
|
|
|
get_namespace_name(collForm->collnamespace));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Modify the owner --- okay to scribble on tup because it's a copy
|
|
|
|
*/
|
|
|
|
collForm->collowner = newOwnerId;
|
|
|
|
|
|
|
|
simple_heap_update(rel, &tup->t_self, tup);
|
|
|
|
|
|
|
|
CatalogUpdateIndexes(rel, tup);
|
|
|
|
|
|
|
|
/* Update owner dependency reference */
|
|
|
|
changeDependencyOnOwner(CollationRelationId, collationOid,
|
|
|
|
newOwnerId);
|
|
|
|
}
|
|
|
|
|
|
|
|
heap_freetuple(tup);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Execute ALTER COLLATION SET SCHEMA
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
AlterCollationNamespace(List *name, const char *newschema)
|
|
|
|
{
|
2011-03-11 19:20:11 +01:00
|
|
|
Oid collOid,
|
|
|
|
nspOid;
|
2011-02-12 14:54:13 +01:00
|
|
|
|
|
|
|
collOid = get_collation_oid(name, false);
|
|
|
|
|
|
|
|
nspOid = LookupCreationNamespace(newschema);
|
|
|
|
|
2011-03-11 19:20:11 +01:00
|
|
|
AlterCollationNamespace_oid(collOid, nspOid);
|
2011-02-12 14:54:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Change collation schema, by oid
|
|
|
|
*/
|
|
|
|
Oid
|
|
|
|
AlterCollationNamespace_oid(Oid collOid, Oid newNspOid)
|
|
|
|
{
|
|
|
|
Oid oldNspOid;
|
|
|
|
Relation rel;
|
2011-03-11 19:20:11 +01:00
|
|
|
char *collation_name;
|
2011-02-12 14:54:13 +01:00
|
|
|
|
|
|
|
rel = heap_open(CollationRelationId, RowExclusiveLock);
|
|
|
|
|
2011-03-11 19:20:11 +01:00
|
|
|
/*
|
|
|
|
* We have to check for name collision ourselves, because
|
|
|
|
* AlterObjectNamespace doesn't know how to deal with the encoding
|
|
|
|
* considerations.
|
|
|
|
*/
|
|
|
|
collation_name = get_collation_name(collOid);
|
|
|
|
if (!collation_name)
|
|
|
|
elog(ERROR, "cache lookup failed for collation %u", collOid);
|
|
|
|
|
|
|
|
/* make sure the name doesn't already exist in new schema */
|
|
|
|
if (SearchSysCacheExists3(COLLNAMEENCNSP,
|
|
|
|
CStringGetDatum(collation_name),
|
|
|
|
Int32GetDatum(GetDatabaseEncoding()),
|
|
|
|
ObjectIdGetDatum(newNspOid)))
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DUPLICATE_OBJECT),
|
|
|
|
errmsg("collation \"%s\" for encoding \"%s\" already exists in schema \"%s\"",
|
|
|
|
collation_name,
|
|
|
|
GetDatabaseEncodingName(),
|
|
|
|
get_namespace_name(newNspOid))));
|
|
|
|
|
|
|
|
/* mustn't match an any-encoding entry, either */
|
|
|
|
if (SearchSysCacheExists3(COLLNAMEENCNSP,
|
|
|
|
CStringGetDatum(collation_name),
|
|
|
|
Int32GetDatum(-1),
|
|
|
|
ObjectIdGetDatum(newNspOid)))
|
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_DUPLICATE_OBJECT),
|
|
|
|
errmsg("collation \"%s\" already exists in schema \"%s\"",
|
|
|
|
collation_name,
|
|
|
|
get_namespace_name(newNspOid))));
|
|
|
|
|
|
|
|
/* OK, do the work */
|
2011-02-12 14:54:13 +01:00
|
|
|
oldNspOid = AlterObjectNamespace(rel, COLLOID, -1,
|
|
|
|
collOid, newNspOid,
|
|
|
|
Anum_pg_collation_collname,
|
|
|
|
Anum_pg_collation_collnamespace,
|
|
|
|
Anum_pg_collation_collowner,
|
|
|
|
ACL_KIND_COLLATION);
|
|
|
|
|
|
|
|
heap_close(rel, RowExclusiveLock);
|
|
|
|
|
|
|
|
return oldNspOid;
|
|
|
|
}
|