Quelle  oid.c

/*-------------------------------------------------------------------------
 *
 * oid.c
 *   Functions for the built-in type Oid ... also oidvector.
 *
 * Portions Copyright (c) 1996-2025, 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);
}