pg_enum.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/binary_upgrade.h"
#include "catalog/catalog.h"
#include "catalog/indexing.h"
#include "catalog/pg_enum.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "nodes/value.h"
#include "storage/lmgr.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/fmgroids.h"
#include "utils/hsearch.h"
#include "utils/memutils.h"
#include "utils/syscache.h"

Include dependency graph for pg_enum.c:

Go to the source code of this file.

Functions
static void	init_uncommitted_enum_types (void)
static void	init_uncommitted_enum_values (void)
static bool	EnumTypeUncommitted (Oid typ_id)
static void	RenumberEnumType (Relation pg_enum, HeapTuple *existing, int nelems)
static int	sort_order_cmp (const void *p1, const void *p2)
void	EnumValuesCreate (Oid enumTypeOid, List *vals)
void	EnumValuesDelete (Oid enumTypeOid)
void	AddEnumLabel (Oid enumTypeOid, const char *newVal, const char *neighbor, bool newValIsAfter, bool skipIfExists)
void	RenameEnumLabel (Oid enumTypeOid, const char *oldVal, const char *newVal)
bool	EnumUncommitted (Oid enum_id)
void	AtEOXact_Enum (void)
Size	EstimateUncommittedEnumsSpace (void)
void	SerializeUncommittedEnums (void *space, Size size)
void	RestoreUncommittedEnums (void *space)

Variables
Oid	binary_upgrade_next_pg_enum_oid = InvalidOid
static HTAB *	uncommitted_enum_types = NULL
static HTAB *	uncommitted_enum_values = NULL

Function Documentation

AddEnumLabel()

void AddEnumLabel	(	Oid	enumTypeOid,
		const char *	newVal,
		const char *	neighbor,
		bool	newValIsAfter,
		bool	skipIfExists
	)

Definition at line 292 of file pg_enum.c.

{
    Relation    pg_enum;
    Oid         newOid;
    Datum       values[Natts_pg_enum];
    bool        nulls[Natts_pg_enum];
    NameData    enumlabel;
    HeapTuple   enum_tup;
    float4      newelemorder;
    HeapTuple  *existing;
    CatCList   *list;
    int         nelems;
    int         i;
 
    /* check length of new label is ok */
    if (strlen(newVal) > (NAMEDATALEN - 1))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("invalid enum label \"%s\"", newVal),
                 errdetail("Labels must be %d bytes or less.",
                           NAMEDATALEN - 1)));
 
    /*
     * Acquire a lock on the enum type, which we won't release until commit.
     * This ensures that two backends aren't concurrently modifying the same
     * enum type.  Without that, we couldn't be sure to get a consistent view
     * of the enum members via the syscache.  Note that this does not block
     * other backends from inspecting the type; see comments for
     * RenumberEnumType.
     */
    LockDatabaseObject(TypeRelationId, enumTypeOid, 0, ExclusiveLock);
 
    /*
     * Check if label is already in use.  The unique index on pg_enum would
     * catch this anyway, but we prefer a friendlier error message, and
     * besides we need a check to support IF NOT EXISTS.
     */
    enum_tup = SearchSysCache2(ENUMTYPOIDNAME,
                               ObjectIdGetDatum(enumTypeOid),
                               CStringGetDatum(newVal));
    if (HeapTupleIsValid(enum_tup))
    {
        ReleaseSysCache(enum_tup);
        if (skipIfExists)
        {
            ereport(NOTICE,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("enum label \"%s\" already exists, skipping",
                            newVal)));
            return;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("enum label \"%s\" already exists",
                            newVal)));
    }
 
    pg_enum = table_open(EnumRelationId, RowExclusiveLock);
 
    /* If we have to renumber the existing members, we restart from here */
restart:
 
    /* Get the list of existing members of the enum */
    list = SearchSysCacheList1(ENUMTYPOIDNAME,
                               ObjectIdGetDatum(enumTypeOid));
    nelems = list->n_members;
 
    /* Sort the existing members by enumsortorder */
    existing = (HeapTuple *) palloc(nelems * sizeof(HeapTuple));
    for (i = 0; i < nelems; i++)
        existing[i] = &(list->members[i]->tuple);
 
    qsort(existing, nelems, sizeof(HeapTuple), sort_order_cmp);
 
    if (neighbor == NULL)
    {
        /*
         * Put the new label at the end of the list. No change to existing
         * tuples is required.
         */
        if (nelems > 0)
        {
            Form_pg_enum en = (Form_pg_enum) GETSTRUCT(existing[nelems - 1]);
 
            newelemorder = en->enumsortorder + 1;
        }
        else
            newelemorder = 1;
    }
    else
    {
        /* BEFORE or AFTER was specified */
        int         nbr_index;
        int         other_nbr_index;
        Form_pg_enum nbr_en;
        Form_pg_enum other_nbr_en;
 
        /* Locate the neighbor element */
        for (nbr_index = 0; nbr_index < nelems; nbr_index++)
        {
            Form_pg_enum en = (Form_pg_enum) GETSTRUCT(existing[nbr_index]);
 
            if (strcmp(NameStr(en->enumlabel), neighbor) == 0)
                break;
        }
        if (nbr_index >= nelems)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("\"%s\" is not an existing enum label",
                            neighbor)));
        nbr_en = (Form_pg_enum) GETSTRUCT(existing[nbr_index]);
 
        /*
         * Attempt to assign an appropriate enumsortorder value: one less than
         * the smallest member, one more than the largest member, or halfway
         * between two existing members.
         *
         * In the "halfway" case, because of the finite precision of float4,
         * we might compute a value that's actually equal to one or the other
         * of its neighbors.  In that case we renumber the existing members
         * and try again.
         */
        if (newValIsAfter)
            other_nbr_index = nbr_index + 1;
        else
            other_nbr_index = nbr_index - 1;
 
        if (other_nbr_index < 0)
            newelemorder = nbr_en->enumsortorder - 1;
        else if (other_nbr_index >= nelems)
            newelemorder = nbr_en->enumsortorder + 1;
        else
        {
            /*
             * The midpoint value computed here has to be rounded to float4
             * precision, else our equality comparisons against the adjacent
             * values are meaningless.  The most portable way of forcing that
             * to happen with non-C-standard-compliant compilers is to store
             * it into a volatile variable.
             */
            volatile float4 midpoint;
 
            other_nbr_en = (Form_pg_enum) GETSTRUCT(existing[other_nbr_index]);
            midpoint = (nbr_en->enumsortorder +
                        other_nbr_en->enumsortorder) / 2;
 
            if (midpoint == nbr_en->enumsortorder ||
                midpoint == other_nbr_en->enumsortorder)
            {
                RenumberEnumType(pg_enum, existing, nelems);
                /* Clean up and start over */
                pfree(existing);
                ReleaseCatCacheList(list);
                goto restart;
            }
 
            newelemorder = midpoint;
        }
    }
 
    /* Get a new OID for the new label */
    if (IsBinaryUpgrade)
    {
        if (!OidIsValid(binary_upgrade_next_pg_enum_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("pg_enum OID value not set when in binary upgrade mode")));
 
        /*
         * Use binary-upgrade override for pg_enum.oid, if supplied. During
         * binary upgrade, all pg_enum.oid's are set this way so they are
         * guaranteed to be consistent.
         */
        if (neighbor != NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("ALTER TYPE ADD BEFORE/AFTER is incompatible with binary upgrade")));
 
        newOid = binary_upgrade_next_pg_enum_oid;
        binary_upgrade_next_pg_enum_oid = InvalidOid;
    }
    else
    {
        /*
         * Normal case: we need to allocate a new Oid for the value.
         *
         * We want to give the new element an even-numbered Oid if it's safe,
         * which is to say it compares correctly to all pre-existing even
         * numbered Oids in the enum.  Otherwise, we must give it an odd Oid.
         */
        for (;;)
        {
            bool        sorts_ok;
 
            /* Get a new OID (different from all existing pg_enum tuples) */
            newOid = GetNewOidWithIndex(pg_enum, EnumOidIndexId,
                                        Anum_pg_enum_oid);
 
            /*
             * Detect whether it sorts correctly relative to existing
             * even-numbered labels of the enum.  We can ignore existing
             * labels with odd Oids, since a comparison involving one of those
             * will not take the fast path anyway.
             */
            sorts_ok = true;
            for (i = 0; i < nelems; i++)
            {
                HeapTuple   exists_tup = existing[i];
                Form_pg_enum exists_en = (Form_pg_enum) GETSTRUCT(exists_tup);
                Oid         exists_oid = exists_en->oid;
 
                if (exists_oid & 1)
                    continue;   /* ignore odd Oids */
 
                if (exists_en->enumsortorder < newelemorder)
                {
                    /* should sort before */
                    if (exists_oid >= newOid)
                    {
                        sorts_ok = false;
                        break;
                    }
                }
                else
                {
                    /* should sort after */
                    if (exists_oid <= newOid)
                    {
                        sorts_ok = false;
                        break;
                    }
                }
            }
 
            if (sorts_ok)
            {
                /* If it's even and sorts OK, we're done. */
                if ((newOid & 1) == 0)
                    break;
 
                /*
                 * If it's odd, and sorts OK, loop back to get another OID and
                 * try again.  Probably, the next available even OID will sort
                 * correctly too, so it's worth trying.
                 */
            }
            else
            {
                /*
                 * If it's odd, and does not sort correctly, we're done.
                 * (Probably, the next available even OID would sort
                 * incorrectly too, so no point in trying again.)
                 */
                if (newOid & 1)
                    break;
 
                /*
                 * If it's even, and does not sort correctly, loop back to get
                 * another OID and try again.  (We *must* reject this case.)
                 */
            }
        }
    }
 
    /* Done with info about existing members */
    pfree(existing);
    ReleaseCatCacheList(list);
 
    /* Create the new pg_enum entry */
    memset(nulls, false, sizeof(nulls));
    values[Anum_pg_enum_oid - 1] = ObjectIdGetDatum(newOid);
    values[Anum_pg_enum_enumtypid - 1] = ObjectIdGetDatum(enumTypeOid);
    values[Anum_pg_enum_enumsortorder - 1] = Float4GetDatum(newelemorder);
    namestrcpy(&enumlabel, newVal);
    values[Anum_pg_enum_enumlabel - 1] = NameGetDatum(&enumlabel);
    enum_tup = heap_form_tuple(RelationGetDescr(pg_enum), values, nulls);
    CatalogTupleInsert(pg_enum, enum_tup);
    heap_freetuple(enum_tup);
 
    table_close(pg_enum, RowExclusiveLock);
 
    /*
     * If the enum type itself is uncommitted, we need not enter the new enum
     * value into uncommitted_enum_values, because the type won't survive if
     * the value doesn't.  (This is basically the same reasoning as for values
     * made directly by CREATE TYPE AS ENUM.)  However, apply this rule only
     * when we are not inside a subtransaction; if we're more deeply nested
     * than the CREATE TYPE then the conclusion doesn't hold.  We could expend
     * more effort to track the subtransaction level of CREATE TYPE, but for
     * now we're only concerned about making the world safe for pg_dump in
     * binary upgrade mode, and that won't use subtransactions.
     */
    if (GetCurrentTransactionNestLevel() == 1 &&
        EnumTypeUncommitted(enumTypeOid))
        return;
 
    /* Set up the uncommitted values table if not already done in this tx */
    if (uncommitted_enum_values == NULL)
        init_uncommitted_enum_values();
 
    /* Add the new value to the table */
    (void) hash_search(uncommitted_enum_values, &newOid, HASH_ENTER, NULL);
}

References binary_upgrade_next_pg_enum_oid, CatalogTupleInsert(), CStringGetDatum(), EnumTypeUncommitted(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail(), errmsg(), ERROR, ExclusiveLock, Float4GetDatum(), GetCurrentTransactionNestLevel(), GetNewOidWithIndex(), GETSTRUCT, HASH_ENTER, hash_search(), heap_form_tuple(), heap_freetuple(), HeapTupleIsValid, i, init_uncommitted_enum_values(), InvalidOid, IsBinaryUpgrade, sort-test::list, LockDatabaseObject(), NAMEDATALEN, NameGetDatum(), NameStr, namestrcpy(), NOTICE, ObjectIdGetDatum(), OidIsValid, palloc(), pfree(), qsort, RelationGetDescr, ReleaseCatCacheList(), ReleaseSysCache(), RenumberEnumType(), RowExclusiveLock, SearchSysCache2(), SearchSysCacheList1, sort_order_cmp(), table_close(), table_open(), uncommitted_enum_values, and values.

Referenced by AlterEnum().

AtEOXact_Enum()

void AtEOXact_Enum

(

void

)

Definition at line 726 of file pg_enum.c.

{
    /*
     * Reset the uncommitted tables, as all our tuples are now committed. The
     * memory will go away automatically when TopTransactionContext is freed;
     * it's sufficient to clear our pointers.
     */
    uncommitted_enum_types = NULL;
    uncommitted_enum_values = NULL;
}

References uncommitted_enum_types, and uncommitted_enum_values.

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

EnumTypeUncommitted()

static bool EnumTypeUncommitted ( Oid  typ_id )

static

Definition at line 690 of file pg_enum.c.

{
    bool        found;
 
    /* If we've made no uncommitted types table, it's not in the table */
    if (uncommitted_enum_types == NULL)
        return false;
 
    /* Else, is it in the table? */
    (void) hash_search(uncommitted_enum_types, &typ_id, HASH_FIND, &found);
    return found;
}

References HASH_FIND, hash_search(), and uncommitted_enum_types.

Referenced by AddEnumLabel().

EnumUncommitted()

bool EnumUncommitted

(

Oid

enum_id

)

Definition at line 708 of file pg_enum.c.

{
    bool        found;
 
    /* If we've made no uncommitted values table, it's not in the table */
    if (uncommitted_enum_values == NULL)
        return false;
 
    /* Else, is it in the table? */
    (void) hash_search(uncommitted_enum_values, &enum_id, HASH_FIND, &found);
    return found;
}

References HASH_FIND, hash_search(), and uncommitted_enum_values.

Referenced by check_safe_enum_use().

EnumValuesCreate()

void EnumValuesCreate	(	Oid	enumTypeOid,
		List *	vals
	)

Definition at line 84 of file pg_enum.c.

{
    Relation    pg_enum;
    Oid        *oids;
    int         elemno,
                num_elems;
    ListCell   *lc;
    int         slotCount = 0;
    int         nslots;
    CatalogIndexState indstate;
    TupleTableSlot **slot;
 
    /*
     * Remember the type OID as being made in the current transaction, but not
     * if we're in a subtransaction.  (We could remember the OID anyway, in
     * case a subsequent ALTER ADD VALUE occurs at outer level.  But that
     * usage pattern seems unlikely enough that we'd probably just be wasting
     * hashtable maintenance effort.)
     */
    if (GetCurrentTransactionNestLevel() == 1)
    {
        if (uncommitted_enum_types == NULL)
            init_uncommitted_enum_types();
        (void) hash_search(uncommitted_enum_types, &enumTypeOid,
                           HASH_ENTER, NULL);
    }
 
    num_elems = list_length(vals);
 
    /*
     * We do not bother to check the list of values for duplicates --- if you
     * have any, you'll get a less-than-friendly unique-index violation. It is
     * probably not worth trying harder.
     */
 
    pg_enum = table_open(EnumRelationId, RowExclusiveLock);
 
    /*
     * Allocate OIDs for the enum's members.
     *
     * While this method does not absolutely guarantee that we generate no
     * duplicate OIDs (since we haven't entered each oid into the table before
     * allocating the next), trouble could only occur if the OID counter wraps
     * all the way around before we finish. Which seems unlikely.
     */
    oids = (Oid *) palloc(num_elems * sizeof(Oid));
 
    for (elemno = 0; elemno < num_elems; elemno++)
    {
        /*
         * We assign even-numbered OIDs to all the new enum labels.  This
         * tells the comparison functions the OIDs are in the correct sort
         * order and can be compared directly.
         */
        Oid         new_oid;
 
        do
        {
            new_oid = GetNewOidWithIndex(pg_enum, EnumOidIndexId,
                                         Anum_pg_enum_oid);
        } while (new_oid & 1);
        oids[elemno] = new_oid;
    }
 
    /* sort them, just in case OID counter wrapped from high to low */
    qsort(oids, num_elems, sizeof(Oid), oid_cmp);
 
    /* and make the entries */
    indstate = CatalogOpenIndexes(pg_enum);
 
    /* allocate the slots to use and initialize them */
    nslots = Min(num_elems,
                 MAX_CATALOG_MULTI_INSERT_BYTES / sizeof(FormData_pg_enum));
    slot = palloc(sizeof(TupleTableSlot *) * nslots);
    for (int i = 0; i < nslots; i++)
        slot[i] = MakeSingleTupleTableSlot(RelationGetDescr(pg_enum),
                                           &TTSOpsHeapTuple);
 
    elemno = 0;
    foreach(lc, vals)
    {
        char       *lab = strVal(lfirst(lc));
        Name        enumlabel = palloc0(NAMEDATALEN);
 
        /*
         * labels are stored in a name field, for easier syscache lookup, so
         * check the length to make sure it's within range.
         */
        if (strlen(lab) > (NAMEDATALEN - 1))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_NAME),
                     errmsg("invalid enum label \"%s\"", lab),
                     errdetail("Labels must be %d bytes or less.",
                               NAMEDATALEN - 1)));
 
        ExecClearTuple(slot[slotCount]);
 
        memset(slot[slotCount]->tts_isnull, false,
               slot[slotCount]->tts_tupleDescriptor->natts * sizeof(bool));
 
        slot[slotCount]->tts_values[Anum_pg_enum_oid - 1] = ObjectIdGetDatum(oids[elemno]);
        slot[slotCount]->tts_values[Anum_pg_enum_enumtypid - 1] = ObjectIdGetDatum(enumTypeOid);
        slot[slotCount]->tts_values[Anum_pg_enum_enumsortorder - 1] = Float4GetDatum(elemno + 1);
 
        namestrcpy(enumlabel, lab);
        slot[slotCount]->tts_values[Anum_pg_enum_enumlabel - 1] = NameGetDatum(enumlabel);
 
        ExecStoreVirtualTuple(slot[slotCount]);
        slotCount++;
 
        /* if slots are full, insert a batch of tuples */
        if (slotCount == nslots)
        {
            CatalogTuplesMultiInsertWithInfo(pg_enum, slot, slotCount,
                                             indstate);
            slotCount = 0;
        }
 
        elemno++;
    }
 
    /* Insert any tuples left in the buffer */
    if (slotCount > 0)
        CatalogTuplesMultiInsertWithInfo(pg_enum, slot, slotCount,
                                         indstate);
 
    /* clean up */
    pfree(oids);
    for (int i = 0; i < nslots; i++)
        ExecDropSingleTupleTableSlot(slot[i]);
    CatalogCloseIndexes(indstate);
    table_close(pg_enum, RowExclusiveLock);
}

References CatalogCloseIndexes(), CatalogOpenIndexes(), CatalogTuplesMultiInsertWithInfo(), ereport, errcode(), errdetail(), errmsg(), ERROR, ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecStoreVirtualTuple(), Float4GetDatum(), FormData_pg_enum, GetCurrentTransactionNestLevel(), GetNewOidWithIndex(), HASH_ENTER, hash_search(), i, init_uncommitted_enum_types(), lfirst, list_length(), MakeSingleTupleTableSlot(), MAX_CATALOG_MULTI_INSERT_BYTES, Min, NAMEDATALEN, NameGetDatum(), namestrcpy(), ObjectIdGetDatum(), oid_cmp(), palloc(), palloc0(), pfree(), qsort, RelationGetDescr, RowExclusiveLock, strVal, table_close(), table_open(), TupleTableSlot::tts_values, TTSOpsHeapTuple, and uncommitted_enum_types.

Referenced by DefineEnum().

EnumValuesDelete()

void EnumValuesDelete

(

Oid

enumTypeOid

)

Definition at line 224 of file pg_enum.c.

{
    Relation    pg_enum;
    ScanKeyData key[1];
    SysScanDesc scan;
    HeapTuple   tup;
 
    pg_enum = table_open(EnumRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_enum_enumtypid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(enumTypeOid));
 
    scan = systable_beginscan(pg_enum, EnumTypIdLabelIndexId, true,
                              NULL, 1, key);
 
    while (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        CatalogTupleDelete(pg_enum, &tup->t_self);
    }
 
    systable_endscan(scan);
 
    table_close(pg_enum, RowExclusiveLock);
}

References BTEqualStrategyNumber, CatalogTupleDelete(), HeapTupleIsValid, sort-test::key, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by RemoveTypeById().

EstimateUncommittedEnumsSpace()

Size EstimateUncommittedEnumsSpace

(

void

)

Definition at line 813 of file pg_enum.c.

{
    size_t      entries = 0;
 
    if (uncommitted_enum_types)
        entries += hash_get_num_entries(uncommitted_enum_types);
    if (uncommitted_enum_values)
        entries += hash_get_num_entries(uncommitted_enum_values);
 
    /* Add two for the terminators. */
    return sizeof(Oid) * (entries + 2);
}

References hash_get_num_entries(), uncommitted_enum_types, and uncommitted_enum_values.

Referenced by InitializeParallelDSM(), and SerializeUncommittedEnums().

init_uncommitted_enum_types()

static void init_uncommitted_enum_types ( void  )

static

Definition at line 255 of file pg_enum.c.

{
    HASHCTL     hash_ctl;
 
    hash_ctl.keysize = sizeof(Oid);
    hash_ctl.entrysize = sizeof(Oid);
    hash_ctl.hcxt = TopTransactionContext;
    uncommitted_enum_types = hash_create("Uncommitted enum types",
                                         32,
                                         &hash_ctl,
                                         HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
}

References HASHCTL::entrysize, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASHCTL::hcxt, HASHCTL::keysize, TopTransactionContext, and uncommitted_enum_types.

Referenced by EnumValuesCreate(), and RestoreUncommittedEnums().

init_uncommitted_enum_values()

static void init_uncommitted_enum_values ( void  )

static

Definition at line 272 of file pg_enum.c.

{
    HASHCTL     hash_ctl;
 
    hash_ctl.keysize = sizeof(Oid);
    hash_ctl.entrysize = sizeof(Oid);
    hash_ctl.hcxt = TopTransactionContext;
    uncommitted_enum_values = hash_create("Uncommitted enum values",
                                          32,
                                          &hash_ctl,
                                          HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
}

References HASHCTL::entrysize, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASHCTL::hcxt, HASHCTL::keysize, TopTransactionContext, and uncommitted_enum_values.

Referenced by AddEnumLabel(), and RestoreUncommittedEnums().

RenameEnumLabel()

void RenameEnumLabel	(	Oid	enumTypeOid,
		const char *	oldVal,
		const char *	newVal
	)

Definition at line 607 of file pg_enum.c.

{
    Relation    pg_enum;
    HeapTuple   enum_tup;
    Form_pg_enum en;
    CatCList   *list;
    int         nelems;
    HeapTuple   old_tup;
    bool        found_new;
    int         i;
 
    /* check length of new label is ok */
    if (strlen(newVal) > (NAMEDATALEN - 1))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("invalid enum label \"%s\"", newVal),
                 errdetail("Labels must be %d bytes or less.",
                           NAMEDATALEN - 1)));
 
    /*
     * Acquire a lock on the enum type, which we won't release until commit.
     * This ensures that two backends aren't concurrently modifying the same
     * enum type.  Since we are not changing the type's sort order, this is
     * probably not really necessary, but there seems no reason not to take
     * the lock to be sure.
     */
    LockDatabaseObject(TypeRelationId, enumTypeOid, 0, ExclusiveLock);
 
    pg_enum = table_open(EnumRelationId, RowExclusiveLock);
 
    /* Get the list of existing members of the enum */
    list = SearchSysCacheList1(ENUMTYPOIDNAME,
                               ObjectIdGetDatum(enumTypeOid));
    nelems = list->n_members;
 
    /*
     * Locate the element to rename and check if the new label is already in
     * use.  (The unique index on pg_enum would catch that anyway, but we
     * prefer a friendlier error message.)
     */
    old_tup = NULL;
    found_new = false;
    for (i = 0; i < nelems; i++)
    {
        enum_tup = &(list->members[i]->tuple);
        en = (Form_pg_enum) GETSTRUCT(enum_tup);
        if (strcmp(NameStr(en->enumlabel), oldVal) == 0)
            old_tup = enum_tup;
        if (strcmp(NameStr(en->enumlabel), newVal) == 0)
            found_new = true;
    }
    if (!old_tup)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("\"%s\" is not an existing enum label",
                        oldVal)));
    if (found_new)
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("enum label \"%s\" already exists",
                        newVal)));
 
    /* OK, make a writable copy of old tuple */
    enum_tup = heap_copytuple(old_tup);
    en = (Form_pg_enum) GETSTRUCT(enum_tup);
 
    ReleaseCatCacheList(list);
 
    /* Update the pg_enum entry */
    namestrcpy(&en->enumlabel, newVal);
    CatalogTupleUpdate(pg_enum, &enum_tup->t_self, enum_tup);
    heap_freetuple(enum_tup);
 
    table_close(pg_enum, RowExclusiveLock);
}

References CatalogTupleUpdate(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail(), errmsg(), ERROR, ExclusiveLock, GETSTRUCT, heap_copytuple(), heap_freetuple(), i, sort-test::list, LockDatabaseObject(), NAMEDATALEN, NameStr, namestrcpy(), ObjectIdGetDatum(), ReleaseCatCacheList(), RowExclusiveLock, SearchSysCacheList1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by AlterEnum().

RenumberEnumType()

static void RenumberEnumType ( Relation  pg_enum, HeapTuple *  existing, int  nelems  )

static

Definition at line 761 of file pg_enum.c.

{
    int         i;
 
    /*
     * We should only need to increase existing elements' enumsortorders,
     * never decrease them.  Therefore, work from the end backwards, to avoid
     * unwanted uniqueness violations.
     */
    for (i = nelems - 1; i >= 0; i--)
    {
        HeapTuple   newtup;
        Form_pg_enum en;
        float4      newsortorder;
 
        newtup = heap_copytuple(existing[i]);
        en = (Form_pg_enum) GETSTRUCT(newtup);
 
        newsortorder = i + 1;
        if (en->enumsortorder != newsortorder)
        {
            en->enumsortorder = newsortorder;
 
            CatalogTupleUpdate(pg_enum, &newtup->t_self, newtup);
        }
 
        heap_freetuple(newtup);
    }
 
    /* Make the updates visible */
    CommandCounterIncrement();
}

References CatalogTupleUpdate(), CommandCounterIncrement(), GETSTRUCT, heap_copytuple(), heap_freetuple(), i, and HeapTupleData::t_self.

Referenced by AddEnumLabel().

RestoreUncommittedEnums()

void RestoreUncommittedEnums

(

void *

space

)

Definition at line 873 of file pg_enum.c.

{
    Oid        *serialized = (Oid *) space;
 
    Assert(!uncommitted_enum_types);
    Assert(!uncommitted_enum_values);
 
    /*
     * If either list is empty then don't even bother to create that hash
     * table.  This is the common case, since most transactions don't create
     * or alter enums.
     */
    if (OidIsValid(*serialized))
    {
        /* Read all the types into a new hash table. */
        init_uncommitted_enum_types();
        do
        {
            (void) hash_search(uncommitted_enum_types, serialized++,
                               HASH_ENTER, NULL);
        } while (OidIsValid(*serialized));
    }
    serialized++;
    if (OidIsValid(*serialized))
    {
        /* Read all the values into a new hash table. */
        init_uncommitted_enum_values();
        do
        {
            (void) hash_search(uncommitted_enum_values, serialized++,
                               HASH_ENTER, NULL);
        } while (OidIsValid(*serialized));
    }
}

References Assert, HASH_ENTER, hash_search(), init_uncommitted_enum_types(), init_uncommitted_enum_values(), OidIsValid, uncommitted_enum_types, and uncommitted_enum_values.

Referenced by ParallelWorkerMain().

SerializeUncommittedEnums()

void SerializeUncommittedEnums	(	void *	space,
		Size	size
	)

Definition at line 827 of file pg_enum.c.

{
    Oid        *serialized = (Oid *) space;
 
    /*
     * Make sure the hash tables haven't changed in size since the caller
     * reserved the space.
     */
    Assert(size == EstimateUncommittedEnumsSpace());
 
    /* Write out all the OIDs from the types hash table, if there is one. */
    if (uncommitted_enum_types)
    {
        HASH_SEQ_STATUS status;
        Oid        *value;
 
        hash_seq_init(&status, uncommitted_enum_types);
        while ((value = (Oid *) hash_seq_search(&status)))
            *serialized++ = *value;
    }
 
    /* Write out the terminator. */
    *serialized++ = InvalidOid;
 
    /* Write out all the OIDs from the values hash table, if there is one. */
    if (uncommitted_enum_values)
    {
        HASH_SEQ_STATUS status;
        Oid        *value;
 
        hash_seq_init(&status, uncommitted_enum_values);
        while ((value = (Oid *) hash_seq_search(&status)))
            *serialized++ = *value;
    }
 
    /* Write out the terminator. */
    *serialized++ = InvalidOid;
 
    /*
     * Make sure the amount of space we actually used matches what was
     * estimated.
     */
    Assert((char *) serialized == ((char *) space) + size);
}

References Assert, EstimateUncommittedEnumsSpace(), hash_seq_init(), hash_seq_search(), InvalidOid, size, uncommitted_enum_types, uncommitted_enum_values, and value.

Referenced by InitializeParallelDSM().

sort_order_cmp()

static int sort_order_cmp ( const void *  p1, const void *  p2  )

static

Definition at line 797 of file pg_enum.c.

{
    HeapTuple   v1 = *((const HeapTuple *) p1);
    HeapTuple   v2 = *((const HeapTuple *) p2);
    Form_pg_enum en1 = (Form_pg_enum) GETSTRUCT(v1);
    Form_pg_enum en2 = (Form_pg_enum) GETSTRUCT(v2);
 
    if (en1->enumsortorder < en2->enumsortorder)
        return -1;
    else if (en1->enumsortorder > en2->enumsortorder)
        return 1;
    else
        return 0;
}

References GETSTRUCT, and p2.

Referenced by AddEnumLabel().

Variable Documentation

binary_upgrade_next_pg_enum_oid

Oid binary_upgrade_next_pg_enum_oid = InvalidOid

Definition at line 36 of file pg_enum.c.

Referenced by AddEnumLabel(), and binary_upgrade_set_next_pg_enum_oid().

uncommitted_enum_types

HTAB* uncommitted_enum_types = NULL

static

Definition at line 62 of file pg_enum.c.

Referenced by AtEOXact_Enum(), EnumTypeUncommitted(), EnumValuesCreate(), EstimateUncommittedEnumsSpace(), init_uncommitted_enum_types(), RestoreUncommittedEnums(), and SerializeUncommittedEnums().

uncommitted_enum_values

HTAB* uncommitted_enum_values = NULL

static

Definition at line 63 of file pg_enum.c.

Referenced by AddEnumLabel(), AtEOXact_Enum(), EnumUncommitted(), EstimateUncommittedEnumsSpace(), init_uncommitted_enum_values(), RestoreUncommittedEnums(), and SerializeUncommittedEnums().