constraint.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/heapam.h"
#include "access/tableam.h"
#include "catalog/index.h"
#include "commands/trigger.h"
#include "executor/executor.h"
#include "utils/builtins.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"

Include dependency graph for constraint.c:

Go to the source code of this file.

Functions
Datum	unique_key_recheck (PG_FUNCTION_ARGS)

Function Documentation

unique_key_recheck()

Datum unique_key_recheck

(

PG_FUNCTION_ARGS

)

Definition at line 41 of file constraint.c.

References BuildIndexInfo(), CALLED_AS_TRIGGER, castNode, check_exclusion_constraint(), CreateExecutorState(), ExprContext::ecxt_scantuple, ereport, errcode(), errmsg(), ERROR, ExecDropSingleTupleTableSlot(), FormIndexDatum(), FreeExecutorState(), GetPerTupleExprContext, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Expressions, index_close(), index_insert(), INDEX_MAX_KEYS, index_open(), ItemPointerSetInvalid, NIL, PointerGetDatum, RowExclusiveLock, SnapshotSelf, table_index_fetch_begin(), table_index_fetch_end(), table_index_fetch_tuple(), table_slot_create(), TriggerData::tg_event, TriggerData::tg_newslot, TriggerData::tg_relation, TriggerData::tg_trigger, TriggerData::tg_trigslot, Trigger::tgconstrindid, TRIGGER_FIRED_AFTER, TRIGGER_FIRED_BY_INSERT, TRIGGER_FIRED_BY_UPDATE, TRIGGER_FIRED_FOR_ROW, TupleTableSlot::tts_tid, UNIQUE_CHECK_EXISTING, and values.

{
    TriggerData *trigdata = castNode(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);
        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,
                     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);
}