/*-------------------------------------------------------------------------
 *
 * tid.c
 *   Functions for the built-in type tuple id
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/utils/adt/tid.c
 *
 * NOTES
 *   input routine largely stolen from boxin().
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include <math.h>
#include <limits.h>

#include "access/sysattr.h"
#include "access/table.h"
#include "access/tableam.h"
#include "catalog/namespace.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "parser/parsetree.h"
#include "utils/acl.h"
#include "utils/fmgrprotos.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/varlena.h"


#define LDELIM   '('
#define RDELIM   ')'
#define DELIM   ','
#define NTIDARGS  2

static ItemPointer currtid_for_view(Relation viewrel, ItemPointer tid);

/* ----------------------------------------------------------------
 *  tidin
 * ----------------------------------------------------------------
 */
Datum
tidin(PG_FUNCTION_ARGS)
{
 char    *str = PG_GETARG_CSTRING(0);
 Node    *escontext = fcinfo->context;
 char    *p,
      *coord[NTIDARGS];
 int   i;
 ItemPointer result;
 BlockNumber blockNumber;
 OffsetNumber offsetNumber;
 char    *badp;
 unsigned long cvt;

 for (i = 0, p = str; *p && i < NTIDARGS && *p != RDELIM; p++)
  if (*p == DELIM || (*p == LDELIM && i == 0))
   coord[i++] = p + 1;

 if (i < NTIDARGS)
  ereturn(escontext, (Datum) 0,
    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     errmsg("invalid input syntax for type %s: \"%s\"",
      "tid", str)));

 errno = 0;
 cvt = strtoul(coord[0], &badp, 10);
 if (errno || *badp != DELIM)
  ereturn(escontext, (Datum) 0,
    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     errmsg("invalid input syntax for type %s: \"%s\"",
      "tid", str)));
 blockNumber = (BlockNumber) cvt;

 /*
  * Cope with possibility that unsigned long is wider than BlockNumber, in
  * which case strtoul will not raise an error for some values that are out
  * of the range of BlockNumber.  (See similar code in oidin().)
 */
#if SIZEOF_LONG > 4
 if (cvt != (unsigned long) blockNumber &&
  cvt != (unsigned long) ((int32) blockNumber))
  ereturn(escontext, (Datum) 0,
    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     errmsg("invalid input syntax for type %s: \"%s\"",
      "tid", str)));
#endif

 cvt = strtoul(coord[1], &badp, 10);
 if (errno || *badp != RDELIM ||
  cvt > USHRT_MAX)
  ereturn(escontext, (Datum) 0,
    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     errmsg("invalid input syntax for type %s: \"%s\"",
      "tid", str)));
 offsetNumber = (OffsetNumber) cvt;

 result = (ItemPointer) palloc(sizeof(ItemPointerData));

 ItemPointerSet(result, blockNumber, offsetNumber);

 PG_RETURN_ITEMPOINTER(result);
}

/* ----------------------------------------------------------------
 *  tidout
 * ----------------------------------------------------------------
 */
Datum
tidout(PG_FUNCTION_ARGS)
{
 ItemPointer itemPtr = PG_GETARG_ITEMPOINTER(0);
 BlockNumber blockNumber;
 OffsetNumber offsetNumber;
 char  buf[32];

 blockNumber = ItemPointerGetBlockNumberNoCheck(itemPtr);
 offsetNumber = ItemPointerGetOffsetNumberNoCheck(itemPtr);

 /* Perhaps someday we should output this as a record. */
 snprintf(buf, sizeof(buf), "(%u,%u)", blockNumber, offsetNumber);

 PG_RETURN_CSTRING(pstrdup(buf));
}

/*
 *  tidrecv   - converts external binary format to tid
 */
Datum
tidrecv(PG_FUNCTION_ARGS)
{
 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
 ItemPointer result;
 BlockNumber blockNumber;
 OffsetNumber offsetNumber;

 blockNumber = pq_getmsgint(buf, sizeof(blockNumber));
 offsetNumber = pq_getmsgint(buf, sizeof(offsetNumber));

 result = (ItemPointer) palloc(sizeof(ItemPointerData));

 ItemPointerSet(result, blockNumber, offsetNumber);

 PG_RETURN_ITEMPOINTER(result);
}

/*
 *  tidsend   - converts tid to binary format
 */
Datum
tidsend(PG_FUNCTION_ARGS)
{
 ItemPointer itemPtr = PG_GETARG_ITEMPOINTER(0);
 StringInfoData buf;

 pq_begintypsend(&buf);
 pq_sendint32(&buf, ItemPointerGetBlockNumberNoCheck(itemPtr));
 pq_sendint16(&buf, ItemPointerGetOffsetNumberNoCheck(itemPtr));
 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

/*****************************************************************************
 *  PUBLIC ROUTINES               *
 *****************************************************************************/

Datum
tideq(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) == 0);
}

Datum
tidne(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) != 0);
}

Datum
tidlt(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) < 0);
}

Datum
tidle(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) <= 0);
}

Datum
tidgt(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) > 0);
}

Datum
tidge(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) >= 0);
}

Datum
bttidcmp(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_INT32(ItemPointerCompare(arg1, arg2));
}

Datum
tidlarger(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_ITEMPOINTER(ItemPointerCompare(arg1, arg2) >= 0 ? arg1 : arg2);
}

Datum
tidsmaller(PG_FUNCTION_ARGS)
{
 ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
 ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);

 PG_RETURN_ITEMPOINTER(ItemPointerCompare(arg1, arg2) <= 0 ? arg1 : arg2);
}

Datum
hashtid(PG_FUNCTION_ARGS)
{
 ItemPointer key = PG_GETARG_ITEMPOINTER(0);

 /*
  * While you'll probably have a lot of trouble with a compiler that
  * insists on appending pad space to struct ItemPointerData, we can at
  * least make this code work, by not using sizeof(ItemPointerData).
  * Instead rely on knowing the sizes of the component fields.
 */
 return hash_any((unsigned char *) key,
     sizeof(BlockIdData) + sizeof(OffsetNumber));
}

Datum
hashtidextended(PG_FUNCTION_ARGS)
{
 ItemPointer key = PG_GETARG_ITEMPOINTER(0);
 uint64  seed = PG_GETARG_INT64(1);

 /* As above */
 return hash_any_extended((unsigned char *) key,
        sizeof(BlockIdData) + sizeof(OffsetNumber),
        seed);
}


/*
 * Functions to get latest tid of a specified tuple.
 *
 * Maybe these implementations should be moved to another place
 */

/*
 * Utility wrapper for current CTID functions.
 *  Returns the latest version of a tuple pointing at "tid" for
 *  relation "rel".
 */
static ItemPointer
currtid_internal(Relation rel, ItemPointer tid)
{
 ItemPointer result;
 AclResult aclresult;
 Snapshot snapshot;
 TableScanDesc scan;

 result = (ItemPointer) palloc(sizeof(ItemPointerData));

 aclresult = pg_class_aclcheck(RelationGetRelid(rel), GetUserId(),
          ACL_SELECT);
 if (aclresult != ACLCHECK_OK)
  aclcheck_error(aclresult, get_relkind_objtype(rel->rd_rel->relkind),
        RelationGetRelationName(rel));

 if (rel->rd_rel->relkind == RELKIND_VIEW)
  return currtid_for_view(rel, tid);

 if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
  ereport(ERROR,
    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    errmsg("cannot look at latest visible tid for relation \"%s.%s\"",
        get_namespace_name(RelationGetNamespace(rel)),
        RelationGetRelationName(rel)));

 ItemPointerCopy(tid, result);

 snapshot = RegisterSnapshot(GetLatestSnapshot());
 scan = table_beginscan_tid(rel, snapshot);
 table_tuple_get_latest_tid(scan, result);
 table_endscan(scan);
 UnregisterSnapshot(snapshot);

 return result;
}

/*
 * Handle CTIDs of views.
 *  CTID should be defined in the view and it must
 *  correspond to the CTID of a base relation.
 */
static ItemPointer
currtid_for_view(Relation viewrel, ItemPointer tid)
{
 TupleDesc att = RelationGetDescr(viewrel);
 RuleLock   *rulelock;
 RewriteRule *rewrite;
 int   i,
    natts = att->natts,
    tididx = -1;

 for (i = 0; i < natts; i++)
 {
  Form_pg_attribute attr = TupleDescAttr(att, i);

  if (strcmp(NameStr(attr->attname), "ctid") == 0)
  {
   if (attr->atttypid != TIDOID)
    ereport(ERROR,
      errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      errmsg("ctid isn't of type TID"));
   tididx = i;
   break;
  }
 }
 if (tididx < 0)
  ereport(ERROR,
    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    errmsg("currtid cannot handle views with no CTID"));
 rulelock = viewrel->rd_rules;
 if (!rulelock)
  ereport(ERROR,
    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    errmsg("the view has no rules"));
 for (i = 0; i < rulelock->numLocks; i++)
 {
  rewrite = rulelock->rules[i];
  if (rewrite->event == CMD_SELECT)
  {
   Query    *query;
   TargetEntry *tle;

   if (list_length(rewrite->actions) != 1)
    ereport(ERROR,
      errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      errmsg("only one select rule is allowed in views"));
   query = (Query *) linitial(rewrite->actions);
   tle = get_tle_by_resno(query->targetList, tididx + 1);
   if (tle && tle->expr && IsA(tle->expr, Var))
   {
    Var     *var = (Var *) tle->expr;
    RangeTblEntry *rte;

    if (!IS_SPECIAL_VARNO(var->varno) &&
     var->varattno == SelfItemPointerAttributeNumber)
    {
     rte = rt_fetch(var->varno, query->rtable);
     if (rte)
     {
      ItemPointer result;
      Relation rel;

      rel = table_open(rte->relid, AccessShareLock);
      result = currtid_internal(rel, tid);
      table_close(rel, AccessShareLock);
      return result;
     }
    }
   }
   break;
  }
 }
 elog(ERROR, "currtid cannot handle this view");
 return NULL;
}

/*
 * currtid_byrelname
 *  Get the latest tuple version of the tuple pointing at a CTID, for a
 *  given relation name.
 */
Datum
currtid_byrelname(PG_FUNCTION_ARGS)
{
 text    *relname = PG_GETARG_TEXT_PP(0);
 ItemPointer tid = PG_GETARG_ITEMPOINTER(1);
 ItemPointer result;
 RangeVar   *relrv;
 Relation rel;

 relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
 rel = table_openrv(relrv, AccessShareLock);

 /* grab the latest tuple version associated to this CTID */
 result = currtid_internal(rel, tid);

 table_close(rel, AccessShareLock);

 PG_RETURN_ITEMPOINTER(result);
}