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

 *

 * constraint.c

 *    PostgreSQL CONSTRAINT support code.

 *

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

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

 *

 * IDENTIFICATION

 *    src/backend/commands/constraint.c

 *

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

 */

#include "postgres.h"

#include "access/genam.h"

#include "access/tableam.h"

#include "catalog/index.h"

#include "commands/trigger.h"

#include "executor/executor.h"

#include "utils/fmgrprotos.h"

#include "utils/snapmgr.h"

/*

 * unique_key_recheck - trigger function to do a deferred uniqueness check.

 *

 * This now also does deferred exclusion-constraint checks, so the name is

 * somewhat historical.

 *

 * This is invoked as an AFTER ROW trigger for both INSERT and UPDATE,

 * for any rows recorded as potentially violating a deferrable unique

 * or exclusion constraint.

 *

 * This may be an end-of-statement check, a commit-time check, or a

 * check triggered by a SET CONSTRAINTS command.

 */

Datum

unique_key_recheck(PG_FUNCTION_ARGS)

{

  TriggerData *trigdata = (TriggerData *) fcinfo->context;

  const char *funcname = "unique_key_recheck";

  ItemPointerData checktid;

  ItemPointerData tmptid;

  Relation  indexRel;

  IndexInfo  *indexInfo;

  EState     *estate;

  ExprContext *econtext;

  TupleTableSlot *slot;

  Datum   values[INDEX_MAX_KEYS];

  bool    isnull[INDEX_MAX_KEYS];

  /*

   * Make sure this is being called as an AFTER ROW trigger.  Note:

   * translatable error strings are shared with ri_triggers.c, so resist the

   * temptation to fold the function name into them.

   */

  if (!CALLED_AS_TRIGGER(fcinfo))

    ereport(ERROR,

        (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),

         errmsg("function \"%s\" was not called by trigger manager",

            funcname)));

  if (!TRIGGER_FIRED_AFTER(trigdata->tg_event) ||

    !TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))

    ereport(ERROR,

        (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),

         errmsg("function \"%s\" must be fired AFTER ROW",

            funcname)));

  /*

   * Get the new data that was inserted/updated.

   */

  if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))

    checktid = trigdata->tg_trigslot->tts_tid;

  else if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))

    checktid = trigdata->tg_newslot->tts_tid;

  else

  {

    ereport(ERROR,

        (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),

         errmsg("function \"%s\" must be fired for INSERT or UPDATE",

            funcname)));

    ItemPointerSetInvalid(&checktid); /* keep compiler quiet */

  }

  slot = table_slot_create(trigdata->tg_relation, NULL);

  /*

   * If the row pointed at by checktid is now dead (ie, inserted and then

   * deleted within our transaction), we can skip the check.  However, we

   * have to be careful, because this trigger gets queued only in response

   * to index insertions; which means it does not get queued e.g. for HOT

   * updates.  The row we are called for might now be dead, but have a live

   * HOT child, in which case we still need to make the check ---

   * effectively, we're applying the check against the live child row,

   * although we can use the values from this row since by definition all

   * columns of interest to us are the same.

   *

   * This might look like just an optimization, because the index AM will

   * make this identical test before throwing an error.  But it's actually

   * needed for correctness, because the index AM will also throw an error

   * if it doesn't find the index entry for the row.  If the row's dead then

   * it's possible the index entry has also been marked dead, and even

   * removed.

   */

  tmptid = checktid;

  {

    IndexFetchTableData *scan = table_index_fetch_begin(trigdata->tg_relation,

                              SO_NONE);

    bool    call_again = false;

    if (!table_index_fetch_tuple(scan, &tmptid, SnapshotSelf, slot,

                   &call_again, NULL))

    {

      /*

       * All rows referenced by the index entry are dead, so skip the

       * check.

       */

      ExecDropSingleTupleTableSlot(slot);

      table_index_fetch_end(scan);

      return PointerGetDatum(NULL);

    }

    table_index_fetch_end(scan);

  }

  /*

   * Open the index, acquiring a RowExclusiveLock, just as if we were going

   * to update it.  (This protects against possible changes of the index

   * schema, not against concurrent updates.)

   */

  indexRel = index_open(trigdata->tg_trigger->tgconstrindid,

              RowExclusiveLock);

  indexInfo = BuildIndexInfo(indexRel);

  /*

   * Typically the index won't have expressions, but if it does we need an

   * EState to evaluate them.  We need it for exclusion constraints too,

   * even if they are just on simple columns.

   */

  if (indexInfo->ii_Expressions != NIL ||

    indexInfo->ii_ExclusionOps != NULL)

  {

    estate = CreateExecutorState();

    econtext = GetPerTupleExprContext(estate);

    econtext->ecxt_scantuple = slot;

  }

  else

    estate = NULL;

  /*

   * Form the index values and isnull flags for the index entry that we need

   * to check.

   *

   * Note: if the index uses functions that are not as immutable as they are

   * supposed to be, this could produce an index tuple different from the

   * original.  The index AM can catch such errors by verifying that it

   * finds a matching index entry with the tuple's TID.  For exclusion

   * constraints we check this in check_exclusion_constraint().

   */

  FormIndexDatum(indexInfo, slot, estate, values, isnull);

  /*

   * Now do the appropriate check.

   */

  if (indexInfo->ii_ExclusionOps == NULL)

  {

    /*

     * Note: this is not a real insert; it is a check that the index entry

     * that has already been inserted is unique.  Passing the tuple's tid

     * (i.e. unmodified by table_index_fetch_tuple()) is correct even if

     * the row is now dead, because that is the TID the index will know

     * about.

     */

    index_insert(indexRel, values, isnull, &checktid,

           trigdata->tg_relation, UNIQUE_CHECK_EXISTING,

           false, indexInfo);

    /* Cleanup cache possibly initialized by index_insert. */

    index_insert_cleanup(indexRel, indexInfo);

  }

  else

  {

    /*

     * For exclusion constraints we just do the normal check, but now it's

     * okay to throw error.  In the HOT-update case, we must use the live

     * HOT child's TID here, else check_exclusion_constraint will think

     * the child is a conflict.

     */

    check_exclusion_constraint(trigdata->tg_relation, indexRel, indexInfo,

                   &tmptid, values, isnull,

                   estate, false);

  }

  /*

   * If that worked, then this index entry is unique or non-excluded, and we

   * are done.

   */

  if (estate != NULL)

    FreeExecutorState(estate);

  ExecDropSingleTupleTableSlot(slot);

  index_close(indexRel, RowExclusiveLock);

  return PointerGetDatum(NULL);

}