<title>Notes</title>

<para>

<command>ALTER TYPE ... ADD VALUE</> (the form that adds a new value to an

enum type) cannot be executed inside a transaction block.

If <command>ALTER TYPE ... ADD VALUE</> (the form that adds a new value to

an enum type) is executed inside a transaction block, the new value cannot

be used until after the transaction has been committed, except in the case

that the enum type itself was created earlier in the same transaction.

</para>

<para>

AlterEnum(AlterEnumStmt*stmt,boolisTopLevel)

AlterEnum(AlterEnumStmt*stmt)

{

Oidenum_type_oid;

TypeName*typename;

if (!HeapTupleIsValid(tup))

elog(ERROR,"cache lookup failed for type %u",enum_type_oid);

if (HeapTupleHeaderGetXmin(tup->t_data)==GetCurrentTransactionId()&&

!(tup->t_data->t_infomask&HEAP_UPDATED))

/* safe to do inside transaction block */ ;

PreventTransactionChain(isTopLevel,"ALTER TYPE ... ADD");

checkEnumOwner(tup);

break;

caseT_AlterEnumStmt:/* ALTER TYPE (enum) */

address=AlterEnum((AlterEnumStmt*)parsetree,isTopLevel);

address=AlterEnum((AlterEnumStmt*)parsetree);

break;

caseT_ViewStmt:/* CREATE VIEW */

staticArrayType*enum_range_internal(Oidenumtypoid,Oidlower,Oidupper);

check_safe_enum_use(HeapTupleenumval_tup)

{

TransactionIdxmin;

Form_pg_enumen;

HeapTupleenumtyp_tup;

if (HeapTupleHeaderXminCommitted(enumval_tup->t_data))

return;

xmin=HeapTupleHeaderGetXmin(enumval_tup->t_data);

if (!TransactionIdIsInProgress(xmin)&&

TransactionIdDidCommit(xmin))

return;

en= (Form_pg_enum)GETSTRUCT(enumval_tup);

enumtyp_tup=SearchSysCache1(TYPEOID,ObjectIdGetDatum(en->enumtypid));

if (!HeapTupleIsValid(enumtyp_tup))

elog(ERROR,"cache lookup failed for type %u",en->enumtypid);

if (xmin==HeapTupleHeaderGetXmin(enumtyp_tup->t_data)&&

!(enumtyp_tup->t_data->t_infomask&HEAP_UPDATED))

{

ReleaseSysCache(enumtyp_tup);

return;

}

ereport(ERROR,

(errcode(ERRCODE_UNSAFE_NEW_ENUM_VALUE_USAGE),

errmsg("unsafe use of new value \"%s\" of enum type %s",

NameStr(en->enumlabel),

format_type_be(en->enumtypid)),

errhint("New enum values must be committed before they can be used.")));

}

format_type_be(enumtypoid),

name)));

check_safe_enum_use(tup);

format_type_be(enumtypoid),

name)));

check_safe_enum_use(tup);

enumoid=HeapTupleGetOid(tup);

ReleaseSysCache(tup);

enum_tuple=systable_getnext_ordered(enum_scan,direction);

if (HeapTupleIsValid(enum_tuple))

{

check_safe_enum_use(enum_tuple);

minmax=HeapTupleGetOid(enum_tuple);

}

{

minmax=InvalidOid;

}

systable_endscan_ordered(enum_scan);

index_close(enum_idx,AccessShareLock);

if (left_found)

{

check_safe_enum_use(enum_tuple);

if (cnt >=max)

{

max *=2;

55006 E ERRCODE_OBJECT_IN_USE object_in_use

55P02 E ERRCODE_CANT_CHANGE_RUNTIME_PARAM cant_change_runtime_param

55P03 E ERRCODE_LOCK_NOT_AVAILABLE lock_not_available

55P04 E ERRCODE_UNSAFE_NEW_ENUM_VALUE_USAGE unsafe_new_enum_value_usage

Section: Class 57 - Operator Intervention

externObjectAddressDefineDomain(CreateDomainStmt*stmt);

externObjectAddressDefineEnum(CreateEnumStmt*stmt);

externObjectAddressDefineRange(CreateRangeStmt*stmt);

externObjectAddressAlterEnum(AlterEnumStmt*stmt,boolisTopLevel);

externObjectAddressAlterEnum(AlterEnumStmt*stmt);

externObjectAddressDefineCompositeType(RangeVar*typevar,List*coldeflist);

externOidAssignTypeArrayOid(void);

-- check transactional behaviour of ALTER TYPE ... ADD VALUE

--

CREATE TYPE bogus AS ENUM('good');

-- check that we can't add new values to existing enums in a transaction

-- check that we can add new values to existing enums in a transaction

-- but we can't use them

BEGIN;

ALTER TYPE bogus ADD VALUE 'bad';

ERROR: ALTER TYPE ... ADD cannot run inside a transaction block

ALTER TYPE bogus ADD VALUE 'new';

SAVEPOINT x;

SELECT 'new'::bogus; -- unsafe

ERROR: unsafe use of new value "new" of enum type bogus

LINE 1: SELECT 'new'::bogus;

^

HINT: New enum values must be committed before they can be used.

ROLLBACK TO x;

SELECT enum_first(null::bogus); -- safe

enum_first

------------

good

(1 row)

SELECT enum_last(null::bogus); -- unsafe

ERROR: unsafe use of new value "new" of enum type bogus

HINT: New enum values must be committed before they can be used.

ROLLBACK TO x;

SELECT enum_range(null::bogus); -- unsafe

ERROR: unsafe use of new value "new" of enum type bogus

HINT: New enum values must be committed before they can be used.

ROLLBACK TO x;

COMMIT;

SELECT 'new'::bogus; -- now safe

bogus

-------

new

(1 row)

SELECT enumlabel, enumsortorder

FROM pg_enum

WHERE enumtypid = 'bogus'::regtype

ORDER BY 2;

enumlabel | enumsortorder

-----------+---------------

good | 1

new | 2

(2 rows)

-- check that we recognize the case where the enum already existed but was

-- modified in the current txn

-- modified in the current txn; this should not be considered safe

BEGIN;

ALTER TYPE bogus RENAME TO bogon;

ALTER TYPE bogon ADD VALUE 'bad';

ERROR: ALTER TYPE ... ADD cannot run inside a transaction block

SELECT 'bad'::bogon;

ERROR: unsafe use of new value "bad" of enum type bogon

LINE 1: SELECT 'bad'::bogon;

^

HINT: New enum values must be committed before they can be used.

ROLLBACK;

DROP TYPE bogus;

-- check that we*can* add new values to existing enums in a transaction,

-- if the type is new as well

-- check that we can add new values to existing enums in a transaction

--and use them,if the type is new as well

BEGIN;

CREATE TYPE bogus AS ENUM();

ALTER TYPE bogus ADD VALUE 'good';

CREATE TYPE bogus AS ENUM('good');

ALTER TYPE bogus ADD VALUE 'bad';

ALTER TYPE bogus ADD VALUE 'ugly';

SELECT enum_range(null::bogus);

enum_range

-----------------

{good,bad,ugly}

(1 row)

ROLLBACK;

--

-- Cleanup

CREATETYPEbogusAS ENUM('good');

BEGIN;

ALTERTYPE bogus ADD VALUE'bad';

ALTERTYPE bogus ADD VALUE'new';

SAVEPOINT x;

SELECT'new'::bogus;-- unsafe

ROLLBACK TO x;

SELECT enum_first(null::bogus);-- safe

SELECT enum_last(null::bogus);-- unsafe

ROLLBACK TO x;

SELECT enum_range(null::bogus);-- unsafe

ROLLBACK TO x;

COMMIT;

SELECT'new'::bogus;-- now safe

SELECT enumlabel, enumsortorder

FROM pg_enum

WHERE enumtypid='bogus'::regtype

ORDER BY2;

BEGIN;

ALTERTYPE bogus RENAME TO bogon;

ALTERTYPE bogon ADD VALUE'bad';

SELECT'bad'::bogon;

ROLLBACK;

DROPTYPE bogus;

BEGIN;

CREATETYPEbogusAS ENUM();

ALTERTYPE bogus ADD VALUE'good';

CREATETYPEbogusAS ENUM('good');

ALTERTYPE bogus ADD VALUE'bad';

ALTERTYPE bogus ADD VALUE'ugly';

SELECT enum_range(null::bogus);

ROLLBACK;