/*-------------------------------------------------------------------------

 *

 * attmap.c

 *    Attribute mapping support.

 *

 * This file provides utility routines to build and manage attribute

 * mappings by comparing input and output TupleDescs.  Such mappings

 * are typically used by DDL operating on inheritance and partition trees

 * to do a conversion between rowtypes logically equivalent but with

 * columns in a different order, taking into account dropped columns.

 * They are also used by the tuple conversion routines in tupconvert.c.

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/access/common/attmap.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/attmap.h"

#include "utils/builtins.h"

static bool check_attrmap_match(TupleDesc indesc,

                TupleDesc outdesc,

                AttrMap *attrMap);

/*

 * make_attrmap

 *

 * Utility routine to allocate an attribute map in the current memory

 * context.

 */

AttrMap *

make_attrmap(int maplen)

{

  AttrMap    *res;

  res = (AttrMap *) palloc0(sizeof(AttrMap));

  res->maplen = maplen;

  res->attnums = (AttrNumber *) palloc0(sizeof(AttrNumber) * maplen);

  return res;

}

/*

 * free_attrmap

 *

 * Utility routine to release an attribute map.

 */

void

free_attrmap(AttrMap *map)

{

  pfree(map->attnums);

  pfree(map);

}

/*

 * build_attrmap_by_position

 *

 * Return a palloc'd bare attribute map for tuple conversion, matching input

 * and output columns by position.  Dropped columns are ignored in both input

 * and output, marked as 0.  This is normally a subroutine for

 * convert_tuples_by_position in tupconvert.c, but it can be used standalone.

 *

 * Note: the errdetail messages speak of indesc as the "returned" rowtype,

 * outdesc as the "expected" rowtype.  This is okay for current uses but

 * might need generalization in future.

 */

AttrMap *

build_attrmap_by_position(TupleDesc indesc,

              TupleDesc outdesc,

              const char *msg)

{

  AttrMap    *attrMap;

  int     nincols;

  int     noutcols;

  int     n;

  int     i;

  int     j;

  bool    same;

  /*

   * The length is computed as the number of attributes of the expected

   * rowtype as it includes dropped attributes in its count.

   */

  n = outdesc->natts;

  attrMap = make_attrmap(n);

  j = 0;            /* j is next physical input attribute */

  nincols = noutcols = 0;   /* these count non-dropped attributes */

  same = true;

  for (i = 0; i < n; i++)

  {

    Form_pg_attribute outatt = TupleDescAttr(outdesc, i);

    if (outatt->attisdropped)

      continue;     /* attrMap->attnums[i] is already 0 */

    noutcols++;

    for (; j < indesc->natts; j++)

    {

      Form_pg_attribute inatt = TupleDescAttr(indesc, j);

      if (inatt->attisdropped)

        continue;

      nincols++;

      /* Found matching column, now check type */

      if (outatt->atttypid != inatt->atttypid ||

        (outatt->atttypmod != inatt->atttypmod && outatt->atttypmod >= 0))

        ereport(ERROR,

            (errcode(ERRCODE_DATATYPE_MISMATCH),

             errmsg_internal("%s", _(msg)),

             errdetail("Returned type %s does not match expected type %s in column \"%s\" (position %d).",

                   format_type_with_typemod(inatt->atttypid,

                              inatt->atttypmod),

                   format_type_with_typemod(outatt->atttypid,

                              outatt->atttypmod),

                   NameStr(outatt->attname),

                   noutcols)));

      attrMap->attnums[i] = (AttrNumber) (j + 1);

      j++;

      break;

    }

    if (attrMap->attnums[i] == 0)

      same = false;   /* we'll complain below */

  }

  /* Check for unused input columns */

  for (; j < indesc->natts; j++)

  {

    if (TupleDescCompactAttr(indesc, j)->attisdropped)

      continue;

    nincols++;

    same = false;     /* we'll complain below */

  }

  /* Report column count mismatch using the non-dropped-column counts */

  if (!same)

    ereport(ERROR,

        (errcode(ERRCODE_DATATYPE_MISMATCH),

         errmsg_internal("%s", _(msg)),

         errdetail("Number of returned columns (%d) does not match "

               "expected column count (%d).",

               nincols, noutcols)));

  /* Check if the map has a one-to-one match */

  if (check_attrmap_match(indesc, outdesc, attrMap))

  {

    /* Runtime conversion is not needed */

    free_attrmap(attrMap);

    return NULL;

  }

  return attrMap;

}

/*

 * build_attrmap_by_name

 *

 * Return a palloc'd bare attribute map for tuple conversion, matching input

 * and output columns by name.  (Dropped columns are ignored in both input and

 * output.)  This is normally a subroutine for convert_tuples_by_name in

 * tupconvert.c, but can be used standalone.

 *

 * If 'missing_ok' is true, a column from 'outdesc' not being present in

 * 'indesc' is not flagged as an error; AttrMap.attnums[] entry for such an

 * outdesc column will be 0 in that case.

 */

AttrMap *

build_attrmap_by_name(TupleDesc indesc,

            TupleDesc outdesc,

            bool missing_ok)

{

  AttrMap    *attrMap;

  int     outnatts;

  int     innatts;

  int     i;

  int     nextindesc = -1;

  outnatts = outdesc->natts;

  innatts = indesc->natts;

  attrMap = make_attrmap(outnatts);

  for (i = 0; i < outnatts; i++)

  {

    Form_pg_attribute outatt = TupleDescAttr(outdesc, i);

    char     *attname;

    Oid     atttypid;

    int32   atttypmod;

    int     j;

    if (outatt->attisdropped)

      continue;     /* attrMap->attnums[i] is already 0 */

    attname = NameStr(outatt->attname);

    atttypid = outatt->atttypid;

    atttypmod = outatt->atttypmod;

    /*

     * Now search for an attribute with the same name in the indesc. It

     * seems likely that a partitioned table will have the attributes in

     * the same order as the partition, so the search below is optimized

     * for that case.  It is possible that columns are dropped in one of

     * the relations, but not the other, so we use the 'nextindesc'

     * counter to track the starting point of the search.  If the inner

     * loop encounters dropped columns then it will have to skip over

     * them, but it should leave 'nextindesc' at the correct position for

     * the next outer loop.

     */

    for (j = 0; j < innatts; j++)

    {

      Form_pg_attribute inatt;

      nextindesc++;

      if (nextindesc >= innatts)

        nextindesc = 0;

      inatt = TupleDescAttr(indesc, nextindesc);

      if (inatt->attisdropped)

        continue;

      if (strcmp(attname, NameStr(inatt->attname)) == 0)

      {

        /* Found it, check type */

        if (atttypid != inatt->atttypid || atttypmod != inatt->atttypmod)

          ereport(ERROR,

              (errcode(ERRCODE_DATATYPE_MISMATCH),

               errmsg("could not convert row type"),

               errdetail("Attribute \"%s\" of type %s does not match corresponding attribute of type %s.",

                     attname,

                     format_type_be(outdesc->tdtypeid),

                     format_type_be(indesc->tdtypeid))));

        attrMap->attnums[i] = inatt->attnum;

        break;

      }

    }

    if (attrMap->attnums[i] == 0 && !missing_ok)

      ereport(ERROR,

          (errcode(ERRCODE_DATATYPE_MISMATCH),

           errmsg("could not convert row type"),

           errdetail("Attribute \"%s\" of type %s does not exist in type %s.",

                 attname,

                 format_type_be(outdesc->tdtypeid),

                 format_type_be(indesc->tdtypeid))));

  }

  return attrMap;

}

/*

 * build_attrmap_by_name_if_req

 *

 * Returns mapping created by build_attrmap_by_name, or NULL if no

 * conversion is required.  This is a convenience routine for

 * convert_tuples_by_name() in tupconvert.c and other functions, but it

 * can be used standalone.

 */

AttrMap *

build_attrmap_by_name_if_req(TupleDesc indesc,

               TupleDesc outdesc,

               bool missing_ok)

{

  AttrMap    *attrMap;

  /* Verify compatibility and prepare attribute-number map */

  attrMap = build_attrmap_by_name(indesc, outdesc, missing_ok);

  /* Check if the map has a one-to-one match */

  if (check_attrmap_match(indesc, outdesc, attrMap))

  {

    /* Runtime conversion is not needed */

    free_attrmap(attrMap);

    return NULL;

  }

  return attrMap;

}

/*

 * check_attrmap_match

 *

 * Check to see if the map is a one-to-one match, in which case we need

 * not to do a tuple conversion, and the attribute map is not necessary.

 */

static bool

check_attrmap_match(TupleDesc indesc,

          TupleDesc outdesc,

          AttrMap *attrMap)

{

  int     i;

  /* no match if attribute numbers are not the same */

  if (indesc->natts != outdesc->natts)

    return false;

  for (i = 0; i < attrMap->maplen; i++)

  {

    CompactAttribute *inatt = TupleDescCompactAttr(indesc, i);

    CompactAttribute *outatt;

    /*

     * If the input column has a missing attribute, we need a conversion.

     */

    if (inatt->atthasmissing)

      return false;

    if (attrMap->attnums[i] == (i + 1))

      continue;

    outatt = TupleDescCompactAttr(outdesc, i);

    /*

     * If it's a dropped column and the corresponding input column is also

     * dropped, we don't need a conversion.  However, attlen and

     * attalignby must agree.

     */

    if (attrMap->attnums[i] == 0 &&

      inatt->attisdropped &&

      inatt->attlen == outatt->attlen &&

      inatt->attalignby == outatt->attalignby)

      continue;

    return false;

  }

  return true;

}