enum.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/pg_enum.h"
#include "libpq/pqformat.h"
#include "storage/procarray.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for enum.c:

Go to the source code of this file.

Functions
static Oid	enum_endpoint (Oid enumtypoid, ScanDirection direction)
static ArrayType *	enum_range_internal (Oid enumtypoid, Oid lower, Oid upper)
static void	check_safe_enum_use (HeapTuple enumval_tup)
Datum	enum_in (PG_FUNCTION_ARGS)
Datum	enum_out (PG_FUNCTION_ARGS)
Datum	enum_recv (PG_FUNCTION_ARGS)
Datum	enum_send (PG_FUNCTION_ARGS)
static int	enum_cmp_internal (Oid arg1, Oid arg2, FunctionCallInfo fcinfo)
Datum	enum_lt (PG_FUNCTION_ARGS)
Datum	enum_le (PG_FUNCTION_ARGS)
Datum	enum_eq (PG_FUNCTION_ARGS)
Datum	enum_ne (PG_FUNCTION_ARGS)
Datum	enum_ge (PG_FUNCTION_ARGS)
Datum	enum_gt (PG_FUNCTION_ARGS)
Datum	enum_smaller (PG_FUNCTION_ARGS)
Datum	enum_larger (PG_FUNCTION_ARGS)
Datum	enum_cmp (PG_FUNCTION_ARGS)
Datum	enum_first (PG_FUNCTION_ARGS)
Datum	enum_last (PG_FUNCTION_ARGS)
Datum	enum_range_bounds (PG_FUNCTION_ARGS)
Datum	enum_range_all (PG_FUNCTION_ARGS)

Function Documentation

check_safe_enum_use()

static void check_safe_enum_use ( HeapTuple  enumval_tup )

static

Definition at line 63 of file enum.c.

{
    TransactionId xmin;
    Form_pg_enum en = (Form_pg_enum) GETSTRUCT(enumval_tup);
 
    /*
     * If the row is hinted as committed, it's surely safe.  This provides a
     * fast path for all normal use-cases.
     */
    if (HeapTupleHeaderXminCommitted(enumval_tup->t_data))
        return;
 
    /*
     * Usually, a row would get hinted as committed when it's read or loaded
     * into syscache; but just in case not, let's check the xmin directly.
     */
    xmin = HeapTupleHeaderGetXmin(enumval_tup->t_data);
    if (!TransactionIdIsInProgress(xmin) &&
        TransactionIdDidCommit(xmin))
        return;
 
    /*
     * Check if the enum value is listed as uncommitted.  If not, it's safe,
     * because it can't be shorter-lived than its owning type.  (This'd also
     * be false for values made by other transactions; but the previous tests
     * should have handled all of those.)
     */
    if (!EnumUncommitted(en->oid))
        return;
 
    /*
     * There might well be other tests we could do here to narrow down the
     * unsafe conditions, but for now just raise an exception.
     */
    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.")));
}

References EnumUncommitted(), ereport, errcode(), errhint(), errmsg(), ERROR, format_type_be(), GETSTRUCT, HeapTupleHeaderGetXmin, HeapTupleHeaderXminCommitted, NameStr, HeapTupleData::t_data, TransactionIdDidCommit(), and TransactionIdIsInProgress().

Referenced by enum_endpoint(), enum_in(), enum_range_internal(), and enum_recv().

enum_cmp()

Datum enum_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 378 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_INT32(enum_cmp_internal(a, b, fcinfo));
}

References a, b, enum_cmp_internal(), PG_GETARG_OID, and PG_RETURN_INT32.

Referenced by gbt_enumkey_cmp(), and gin_enum_cmp().

enum_cmp_internal()

static int enum_cmp_internal ( Oid  arg1, Oid  arg2, FunctionCallInfo  fcinfo  )

static

Definition at line 252 of file enum.c.

{
    TypeCacheEntry *tcache;
 
    /*
     * We don't need the typcache except in the hopefully-uncommon case that
     * one or both Oids are odd.  This means that cursory testing of code that
     * fails to pass flinfo to an enum comparison function might not disclose
     * the oversight.  To make such errors more obvious, Assert that we have a
     * place to cache even when we take a fast-path exit.
     */
    Assert(fcinfo->flinfo != NULL);
 
    /* Equal OIDs are equal no matter what */
    if (arg1 == arg2)
        return 0;
 
    /* Fast path: even-numbered Oids are known to compare correctly */
    if ((arg1 & 1) == 0 && (arg2 & 1) == 0)
    {
        if (arg1 < arg2)
            return -1;
        else
            return 1;
    }
 
    /* Locate the typcache entry for the enum type */
    tcache = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
    if (tcache == NULL)
    {
        HeapTuple   enum_tup;
        Form_pg_enum en;
        Oid         typeoid;
 
        /* Get the OID of the enum type containing arg1 */
        enum_tup = SearchSysCache1(ENUMOID, ObjectIdGetDatum(arg1));
        if (!HeapTupleIsValid(enum_tup))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                     errmsg("invalid internal value for enum: %u",
                            arg1)));
        en = (Form_pg_enum) GETSTRUCT(enum_tup);
        typeoid = en->enumtypid;
        ReleaseSysCache(enum_tup);
        /* Now locate and remember the typcache entry */
        tcache = lookup_type_cache(typeoid, 0);
        fcinfo->flinfo->fn_extra = (void *) tcache;
    }
 
    /* The remaining comparison logic is in typcache.c */
    return compare_values_of_enum(tcache, arg1, arg2);
}

References Assert, compare_values_of_enum(), ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, GETSTRUCT, HeapTupleIsValid, if(), lookup_type_cache(), ObjectIdGetDatum(), ReleaseSysCache(), and SearchSysCache1().

Referenced by enum_cmp(), enum_ge(), enum_gt(), enum_larger(), enum_le(), enum_lt(), and enum_smaller().

enum_endpoint()

static Oid enum_endpoint ( Oid  enumtypoid, ScanDirection  direction  )

static

Definition at line 392 of file enum.c.

{
    Relation    enum_rel;
    Relation    enum_idx;
    SysScanDesc enum_scan;
    HeapTuple   enum_tuple;
    ScanKeyData skey;
    Oid         minmax;
 
    /*
     * Find the first/last enum member using pg_enum_typid_sortorder_index.
     * Note we must not use the syscache.  See comments for RenumberEnumType
     * in catalog/pg_enum.c for more info.
     */
    ScanKeyInit(&skey,
                Anum_pg_enum_enumtypid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(enumtypoid));
 
    enum_rel = table_open(EnumRelationId, AccessShareLock);
    enum_idx = index_open(EnumTypIdSortOrderIndexId, AccessShareLock);
    enum_scan = systable_beginscan_ordered(enum_rel, enum_idx, NULL,
                                           1, &skey);
 
    enum_tuple = systable_getnext_ordered(enum_scan, direction);
    if (HeapTupleIsValid(enum_tuple))
    {
        /* check it's safe to use in SQL */
        check_safe_enum_use(enum_tuple);
        minmax = ((Form_pg_enum) GETSTRUCT(enum_tuple))->oid;
    }
    else
    {
        /* should only happen with an empty enum */
        minmax = InvalidOid;
    }
 
    systable_endscan_ordered(enum_scan);
    index_close(enum_idx, AccessShareLock);
    table_close(enum_rel, AccessShareLock);
 
    return minmax;
}

References AccessShareLock, BTEqualStrategyNumber, check_safe_enum_use(), GETSTRUCT, HeapTupleIsValid, index_close(), index_open(), InvalidOid, ObjectIdGetDatum(), ScanKeyInit(), systable_beginscan_ordered(), systable_endscan_ordered(), systable_getnext_ordered(), table_close(), and table_open().

Referenced by enum_first(), and enum_last().

enum_eq()

Datum enum_eq

(

PG_FUNCTION_ARGS

)

Definition at line 324 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(a == b);
}

References a, b, PG_GETARG_OID, and PG_RETURN_BOOL.

enum_first()

Datum enum_first

(

PG_FUNCTION_ARGS

)

Definition at line 437 of file enum.c.

{
    Oid         enumtypoid;
    Oid         min;
 
    /*
     * We rely on being able to get the specific enum type from the calling
     * expression tree.  Notice that the actual value of the argument isn't
     * examined at all; in particular it might be NULL.
     */
    enumtypoid = get_fn_expr_argtype(fcinfo->flinfo, 0);
    if (enumtypoid == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("could not determine actual enum type")));
 
    /* Get the OID using the index */
    min = enum_endpoint(enumtypoid, ForwardScanDirection);
 
    if (!OidIsValid(min))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("enum %s contains no values",
                        format_type_be(enumtypoid))));
 
    PG_RETURN_OID(min);
}

References enum_endpoint(), ereport, errcode(), errmsg(), ERROR, format_type_be(), ForwardScanDirection, get_fn_expr_argtype(), InvalidOid, OidIsValid, and PG_RETURN_OID.

enum_ge()

Datum enum_ge

(

PG_FUNCTION_ARGS

)

Definition at line 342 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(enum_cmp_internal(a, b, fcinfo) >= 0);
}

References a, b, enum_cmp_internal(), PG_GETARG_OID, and PG_RETURN_BOOL.

Referenced by gbt_enumge().

enum_gt()

Datum enum_gt

(

PG_FUNCTION_ARGS

)

Definition at line 351 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(enum_cmp_internal(a, b, fcinfo) > 0);
}

References a, b, enum_cmp_internal(), PG_GETARG_OID, and PG_RETURN_BOOL.

Referenced by gbt_enumgt().

enum_in()

Datum enum_in

(

PG_FUNCTION_ARGS

)

Definition at line 109 of file enum.c.

{
    char       *name = PG_GETARG_CSTRING(0);
    Oid         enumtypoid = PG_GETARG_OID(1);
    Node       *escontext = fcinfo->context;
    Oid         enumoid;
    HeapTuple   tup;
 
    /* must check length to prevent Assert failure within SearchSysCache */
    if (strlen(name) >= NAMEDATALEN)
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input value for enum %s: \"%s\"",
                        format_type_be(enumtypoid),
                        name)));
 
    tup = SearchSysCache2(ENUMTYPOIDNAME,
                          ObjectIdGetDatum(enumtypoid),
                          CStringGetDatum(name));
    if (!HeapTupleIsValid(tup))
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input value for enum %s: \"%s\"",
                        format_type_be(enumtypoid),
                        name)));
 
    /*
     * Check it's safe to use in SQL.  Perhaps we should take the trouble to
     * report "unsafe use" softly; but it's unclear that it's worth the
     * trouble, or indeed that that is a legitimate bad-input case at all
     * rather than an implementation shortcoming.
     */
    check_safe_enum_use(tup);
 
    /*
     * This comes from pg_enum.oid and stores system oids in user tables. This
     * oid must be preserved by binary upgrades.
     */
    enumoid = ((Form_pg_enum) GETSTRUCT(tup))->oid;
 
    ReleaseSysCache(tup);
 
    PG_RETURN_OID(enumoid);
}

References check_safe_enum_use(), CStringGetDatum(), ereturn, errcode(), errmsg(), format_type_be(), GETSTRUCT, HeapTupleIsValid, name, NAMEDATALEN, ObjectIdGetDatum(), PG_GETARG_CSTRING, PG_GETARG_OID, PG_RETURN_OID, ReleaseSysCache(), and SearchSysCache2().

enum_larger()

Datum enum_larger

(

PG_FUNCTION_ARGS

)

Definition at line 369 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_OID(enum_cmp_internal(a, b, fcinfo) > 0 ? a : b);
}

References a, b, enum_cmp_internal(), PG_GETARG_OID, and PG_RETURN_OID.

enum_last()

Datum enum_last

(

PG_FUNCTION_ARGS

)

Definition at line 466 of file enum.c.

{
    Oid         enumtypoid;
    Oid         max;
 
    /*
     * We rely on being able to get the specific enum type from the calling
     * expression tree.  Notice that the actual value of the argument isn't
     * examined at all; in particular it might be NULL.
     */
    enumtypoid = get_fn_expr_argtype(fcinfo->flinfo, 0);
    if (enumtypoid == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("could not determine actual enum type")));
 
    /* Get the OID using the index */
    max = enum_endpoint(enumtypoid, BackwardScanDirection);
 
    if (!OidIsValid(max))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("enum %s contains no values",
                        format_type_be(enumtypoid))));
 
    PG_RETURN_OID(max);
}

References BackwardScanDirection, enum_endpoint(), ereport, errcode(), errmsg(), ERROR, format_type_be(), get_fn_expr_argtype(), InvalidOid, OidIsValid, and PG_RETURN_OID.

enum_le()

Datum enum_le

(

PG_FUNCTION_ARGS

)

Definition at line 315 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(enum_cmp_internal(a, b, fcinfo) <= 0);
}

References a, b, enum_cmp_internal(), PG_GETARG_OID, and PG_RETURN_BOOL.

Referenced by gbt_enumle().

enum_lt()

Datum enum_lt

(

PG_FUNCTION_ARGS

)

Definition at line 306 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(enum_cmp_internal(a, b, fcinfo) < 0);
}

References a, b, enum_cmp_internal(), PG_GETARG_OID, and PG_RETURN_BOOL.

Referenced by gbt_enumlt().

enum_ne()

Datum enum_ne

(

PG_FUNCTION_ARGS

)

Definition at line 333 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(a != b);
}

References a, b, PG_GETARG_OID, and PG_RETURN_BOOL.

enum_out()

Datum enum_out

(

PG_FUNCTION_ARGS

)

Definition at line 155 of file enum.c.

{
    Oid         enumval = PG_GETARG_OID(0);
    char       *result;
    HeapTuple   tup;
    Form_pg_enum en;
 
    tup = SearchSysCache1(ENUMOID, ObjectIdGetDatum(enumval));
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid internal value for enum: %u",
                        enumval)));
    en = (Form_pg_enum) GETSTRUCT(tup);
 
    result = pstrdup(NameStr(en->enumlabel));
 
    ReleaseSysCache(tup);
 
    PG_RETURN_CSTRING(result);
}

References ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_CSTRING, pstrdup(), ReleaseSysCache(), and SearchSysCache1().

Referenced by anyenum_out().

enum_range_all()

Datum enum_range_all

(

PG_FUNCTION_ARGS

)

Definition at line 527 of file enum.c.

{
    Oid         enumtypoid;
 
    /*
     * We rely on being able to get the specific enum type from the calling
     * expression tree.  Notice that the actual value of the argument isn't
     * examined at all; in particular it might be NULL.
     */
    enumtypoid = get_fn_expr_argtype(fcinfo->flinfo, 0);
    if (enumtypoid == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("could not determine actual enum type")));
 
    PG_RETURN_ARRAYTYPE_P(enum_range_internal(enumtypoid,
                                              InvalidOid, InvalidOid));
}

References enum_range_internal(), ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), InvalidOid, and PG_RETURN_ARRAYTYPE_P.

enum_range_bounds()

Datum enum_range_bounds

(

PG_FUNCTION_ARGS

)

Definition at line 496 of file enum.c.

{
    Oid         lower;
    Oid         upper;
    Oid         enumtypoid;
 
    if (PG_ARGISNULL(0))
        lower = InvalidOid;
    else
        lower = PG_GETARG_OID(0);
    if (PG_ARGISNULL(1))
        upper = InvalidOid;
    else
        upper = PG_GETARG_OID(1);
 
    /*
     * We rely on being able to get the specific enum type from the calling
     * expression tree.  The generic type mechanism should have ensured that
     * both are of the same type.
     */
    enumtypoid = get_fn_expr_argtype(fcinfo->flinfo, 0);
    if (enumtypoid == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("could not determine actual enum type")));
 
    PG_RETURN_ARRAYTYPE_P(enum_range_internal(enumtypoid, lower, upper));
}

References enum_range_internal(), ereport, errcode(), errmsg(), ERROR, get_fn_expr_argtype(), InvalidOid, lower(), PG_ARGISNULL, PG_GETARG_OID, PG_RETURN_ARRAYTYPE_P, and upper().

enum_range_internal()

static ArrayType * enum_range_internal ( Oid  enumtypoid, Oid  lower, Oid  upper  )

static

Definition at line 547 of file enum.c.

{
    ArrayType  *result;
    Relation    enum_rel;
    Relation    enum_idx;
    SysScanDesc enum_scan;
    HeapTuple   enum_tuple;
    ScanKeyData skey;
    Datum      *elems;
    int         max,
                cnt;
    bool        left_found;
 
    /*
     * Scan the enum members in order using pg_enum_typid_sortorder_index.
     * Note we must not use the syscache.  See comments for RenumberEnumType
     * in catalog/pg_enum.c for more info.
     */
    ScanKeyInit(&skey,
                Anum_pg_enum_enumtypid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(enumtypoid));
 
    enum_rel = table_open(EnumRelationId, AccessShareLock);
    enum_idx = index_open(EnumTypIdSortOrderIndexId, AccessShareLock);
    enum_scan = systable_beginscan_ordered(enum_rel, enum_idx, NULL, 1, &skey);
 
    max = 64;
    elems = (Datum *) palloc(max * sizeof(Datum));
    cnt = 0;
    left_found = !OidIsValid(lower);
 
    while (HeapTupleIsValid(enum_tuple = systable_getnext_ordered(enum_scan, ForwardScanDirection)))
    {
        Oid         enum_oid = ((Form_pg_enum) GETSTRUCT(enum_tuple))->oid;
 
        if (!left_found && lower == enum_oid)
            left_found = true;
 
        if (left_found)
        {
            /* check it's safe to use in SQL */
            check_safe_enum_use(enum_tuple);
 
            if (cnt >= max)
            {
                max *= 2;
                elems = (Datum *) repalloc(elems, max * sizeof(Datum));
            }
 
            elems[cnt++] = ObjectIdGetDatum(enum_oid);
        }
 
        if (OidIsValid(upper) && upper == enum_oid)
            break;
    }
 
    systable_endscan_ordered(enum_scan);
    index_close(enum_idx, AccessShareLock);
    table_close(enum_rel, AccessShareLock);
 
    /* and build the result array */
    /* note this hardwires some details about the representation of Oid */
    result = construct_array(elems, cnt, enumtypoid,
                             sizeof(Oid), true, TYPALIGN_INT);
 
    pfree(elems);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, check_safe_enum_use(), construct_array(), ForwardScanDirection, GETSTRUCT, HeapTupleIsValid, index_close(), index_open(), lower(), ObjectIdGetDatum(), OidIsValid, palloc(), pfree(), repalloc(), ScanKeyInit(), systable_beginscan_ordered(), systable_endscan_ordered(), systable_getnext_ordered(), table_close(), table_open(), and upper().

Referenced by enum_range_all(), and enum_range_bounds().

enum_recv()

Datum enum_recv

(

PG_FUNCTION_ARGS

)

Definition at line 179 of file enum.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    Oid         enumtypoid = PG_GETARG_OID(1);
    Oid         enumoid;
    HeapTuple   tup;
    char       *name;
    int         nbytes;
 
    name = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
 
    /* must check length to prevent Assert failure within SearchSysCache */
    if (strlen(name) >= NAMEDATALEN)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input value for enum %s: \"%s\"",
                        format_type_be(enumtypoid),
                        name)));
 
    tup = SearchSysCache2(ENUMTYPOIDNAME,
                          ObjectIdGetDatum(enumtypoid),
                          CStringGetDatum(name));
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input value for enum %s: \"%s\"",
                        format_type_be(enumtypoid),
                        name)));
 
    /* check it's safe to use in SQL */
    check_safe_enum_use(tup);
 
    enumoid = ((Form_pg_enum) GETSTRUCT(tup))->oid;
 
    ReleaseSysCache(tup);
 
    pfree(name);
 
    PG_RETURN_OID(enumoid);
}

References buf, check_safe_enum_use(), CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, format_type_be(), GETSTRUCT, HeapTupleIsValid, name, NAMEDATALEN, ObjectIdGetDatum(), pfree(), PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_OID, pq_getmsgtext(), ReleaseSysCache(), and SearchSysCache2().

enum_send()

Datum enum_send

(

PG_FUNCTION_ARGS

)

Definition at line 221 of file enum.c.

{
    Oid         enumval = PG_GETARG_OID(0);
    StringInfoData buf;
    HeapTuple   tup;
    Form_pg_enum en;
 
    tup = SearchSysCache1(ENUMOID, ObjectIdGetDatum(enumval));
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid internal value for enum: %u",
                        enumval)));
    en = (Form_pg_enum) GETSTRUCT(tup);
 
    pq_begintypsend(&buf);
    pq_sendtext(&buf, NameStr(en->enumlabel), strlen(NameStr(en->enumlabel)));
 
    ReleaseSysCache(tup);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendtext(), ReleaseSysCache(), and SearchSysCache1().

enum_smaller()

Datum enum_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 360 of file enum.c.

{
    Oid         a = PG_GETARG_OID(0);
    Oid         b = PG_GETARG_OID(1);
 
    PG_RETURN_OID(enum_cmp_internal(a, b, fcinfo) < 0 ? a : b);
}

References a, b, enum_cmp_internal(), PG_GETARG_OID, and PG_RETURN_OID.