oid.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * oid.c
 *    Functions for the built-in type Oid ... also oidvector.
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/utils/adt/oid.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"
 
#include <ctype.h>
#include <limits.h>
 
#include "catalog/pg_type.h"
#include "common/int.h"
#include "libpq/pqformat.h"
#include "nodes/miscnodes.h"
#include "nodes/value.h"
#include "utils/array.h"
#include "utils/builtins.h"
 
 
#define OidVectorSize(n)    (offsetof(oidvector, values) + (n) * sizeof(Oid))
 
 
/*****************************************************************************
 *   USER I/O ROUTINES                                                       *
 *****************************************************************************/
 
Datum
oidin(PG_FUNCTION_ARGS)
{
    char       *s = PG_GETARG_CSTRING(0);
    Oid         result;
 
    result = uint32in_subr(s, NULL, "oid", fcinfo->context);
    PG_RETURN_OID(result);
}
 
Datum
oidout(PG_FUNCTION_ARGS)
{
    Oid         o = PG_GETARG_OID(0);
    char       *result = (char *) palloc(12);
 
    snprintf(result, 12, "%u", o);
    PG_RETURN_CSTRING(result);
}
 
/*
 *      oidrecv         - converts external binary format to oid
 */
Datum
oidrecv(PG_FUNCTION_ARGS)
{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
 
    PG_RETURN_OID((Oid) pq_getmsgint(buf, sizeof(Oid)));
}
 
/*
 *      oidsend         - converts oid to binary format
 */
Datum
oidsend(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendint32(&buf, arg1);
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}
 
/*
 * construct oidvector given a raw array of Oids
 *
 * If oids is NULL then caller must fill values[] afterward
 */
oidvector *
buildoidvector(const Oid *oids, int n)
{
    oidvector  *result;
 
    result = (oidvector *) palloc0(OidVectorSize(n));
 
    if (n > 0 && oids)
        memcpy(result->values, oids, n * sizeof(Oid));
 
    /*
     * Attach standard array header.  For historical reasons, we set the index
     * lower bound to 0 not 1.
     */
    SET_VARSIZE(result, OidVectorSize(n));
    result->ndim = 1;
    result->dataoffset = 0;     /* never any nulls */
    result->elemtype = OIDOID;
    result->dim1 = n;
    result->lbound1 = 0;
 
    return result;
}
 
/*
 * validate that an array object meets the restrictions of oidvector
 *
 * We need this because there are pathways by which a general oid[] array can
 * be cast to oidvector, allowing the type's restrictions to be violated.
 * All code that receives an oidvector as a SQL parameter should check this.
 */
void
check_valid_oidvector(const oidvector *oidArray)
{
    /*
     * We insist on ndim == 1 and dataoffset == 0 (that is, no nulls) because
     * otherwise the array's layout will not be what calling code expects.  We
     * needn't be picky about the index lower bound though.  Checking elemtype
     * is just paranoia.
     */
    if (oidArray->ndim != 1 ||
        oidArray->dataoffset != 0 ||
        oidArray->elemtype != OIDOID)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("array is not a valid oidvector")));
}
 
/*
 *      oidvectorin         - converts "num num ..." to internal form
 */
Datum
oidvectorin(PG_FUNCTION_ARGS)
{
    char       *oidString = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
    oidvector  *result;
    int         nalloc;
    int         n;
 
    nalloc = 32;                /* arbitrary initial size guess */
    result = (oidvector *) palloc0(OidVectorSize(nalloc));
 
    for (n = 0;; n++)
    {
        while (*oidString && isspace((unsigned char) *oidString))
            oidString++;
        if (*oidString == '\0')
            break;
 
        if (n >= nalloc)
        {
            nalloc *= 2;
            result = (oidvector *) repalloc(result, OidVectorSize(nalloc));
        }
 
        result->values[n] = uint32in_subr(oidString, &oidString,
                                          "oid", escontext);
        if (SOFT_ERROR_OCCURRED(escontext))
            PG_RETURN_NULL();
    }
 
    SET_VARSIZE(result, OidVectorSize(n));
    result->ndim = 1;
    result->dataoffset = 0;     /* never any nulls */
    result->elemtype = OIDOID;
    result->dim1 = n;
    result->lbound1 = 0;
 
    PG_RETURN_POINTER(result);
}
 
/*
 *      oidvectorout - converts internal form to "num num ..."
 */
Datum
oidvectorout(PG_FUNCTION_ARGS)
{
    oidvector  *oidArray = (oidvector *) PG_GETARG_POINTER(0);
    int         num,
                nnums;
    char       *rp;
    char       *result;
 
    /* validate input before fetching dim1 */
    check_valid_oidvector(oidArray);
    nnums = oidArray->dim1;
 
    /* assumes sign, 10 digits, ' ' */
    rp = result = (char *) palloc(nnums * 12 + 1);
    for (num = 0; num < nnums; num++)
    {
        if (num != 0)
            *rp++ = ' ';
        sprintf(rp, "%u", oidArray->values[num]);
        while (*++rp != '\0')
            ;
    }
    *rp = '\0';
    PG_RETURN_CSTRING(result);
}
 
/*
 *      oidvectorrecv           - converts external binary format to oidvector
 */
Datum
oidvectorrecv(PG_FUNCTION_ARGS)
{
    LOCAL_FCINFO(locfcinfo, 3);
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    oidvector  *result;
 
    /*
     * Normally one would call array_recv() using DirectFunctionCall3, but
     * that does not work since array_recv wants to cache some data using
     * fcinfo->flinfo->fn_extra.  So we need to pass it our own flinfo
     * parameter.
     */
    InitFunctionCallInfoData(*locfcinfo, fcinfo->flinfo, 3,
                             InvalidOid, NULL, NULL);
 
    locfcinfo->args[0].value = PointerGetDatum(buf);
    locfcinfo->args[0].isnull = false;
    locfcinfo->args[1].value = ObjectIdGetDatum(OIDOID);
    locfcinfo->args[1].isnull = false;
    locfcinfo->args[2].value = Int32GetDatum(-1);
    locfcinfo->args[2].isnull = false;
 
    result = (oidvector *) DatumGetPointer(array_recv(locfcinfo));
 
    Assert(!locfcinfo->isnull);
 
    /* sanity checks: oidvector must be 1-D, 0-based, no nulls */
    if (ARR_NDIM(result) != 1 ||
        ARR_HASNULL(result) ||
        ARR_ELEMTYPE(result) != OIDOID ||
        ARR_LBOUND(result)[0] != 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid oidvector data")));
 
    PG_RETURN_POINTER(result);
}
 
/*
 *      oidvectorsend           - converts oidvector to binary format
 */
Datum
oidvectorsend(PG_FUNCTION_ARGS)
{
    /* We don't do check_valid_oidvector, since array_send won't care */
    return array_send(fcinfo);
}
 
/*
 *      oidparse                - get OID from ICONST/FCONST node
 */
Oid
oidparse(Node *node)
{
    switch (nodeTag(node))
    {
        case T_Integer:
            return intVal(node);
        case T_Float:
 
            /*
             * Values too large for int4 will be represented as Float
             * constants by the lexer.  Accept these if they are valid OID
             * strings.
             */
            return uint32in_subr(castNode(Float, node)->fval, NULL,
                                 "oid", NULL);
        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
    }
    return InvalidOid;          /* keep compiler quiet */
}
 
/* qsort comparison function for Oids */
int
oid_cmp(const void *p1, const void *p2)
{
    Oid         v1 = *((const Oid *) p1);
    Oid         v2 = *((const Oid *) p2);
 
    return pg_cmp_u32(v1, v2);
}
 
 
/*****************************************************************************
 *   PUBLIC ROUTINES                                                         *
 *****************************************************************************/
 
Datum
oideq(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    Oid         arg2 = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(arg1 == arg2);
}
 
Datum
oidne(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    Oid         arg2 = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(arg1 != arg2);
}
 
Datum
oidlt(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    Oid         arg2 = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(arg1 < arg2);
}
 
Datum
oidle(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    Oid         arg2 = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(arg1 <= arg2);
}
 
Datum
oidge(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    Oid         arg2 = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(arg1 >= arg2);
}
 
Datum
oidgt(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    Oid         arg2 = PG_GETARG_OID(1);
 
    PG_RETURN_BOOL(arg1 > arg2);
}
 
Datum
oidlarger(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    Oid         arg2 = PG_GETARG_OID(1);
 
    PG_RETURN_OID((arg1 > arg2) ? arg1 : arg2);
}
 
Datum
oidsmaller(PG_FUNCTION_ARGS)
{
    Oid         arg1 = PG_GETARG_OID(0);
    Oid         arg2 = PG_GETARG_OID(1);
 
    PG_RETURN_OID((arg1 < arg2) ? arg1 : arg2);
}
 
Datum
oidvectoreq(PG_FUNCTION_ARGS)
{
    int32       cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
 
    PG_RETURN_BOOL(cmp == 0);
}
 
Datum
oidvectorne(PG_FUNCTION_ARGS)
{
    int32       cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
 
    PG_RETURN_BOOL(cmp != 0);
}
 
Datum
oidvectorlt(PG_FUNCTION_ARGS)
{
    int32       cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
 
    PG_RETURN_BOOL(cmp < 0);
}
 
Datum
oidvectorle(PG_FUNCTION_ARGS)
{
    int32       cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
 
    PG_RETURN_BOOL(cmp <= 0);
}
 
Datum
oidvectorge(PG_FUNCTION_ARGS)
{
    int32       cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
 
    PG_RETURN_BOOL(cmp >= 0);
}
 
Datum
oidvectorgt(PG_FUNCTION_ARGS)
{
    int32       cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
 
    PG_RETURN_BOOL(cmp > 0);
}