pg_attrdef.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/relation.h"
#include "access/table.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_attrdef.h"
#include "executor/executor.h"
#include "optimizer/optimizer.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for pg_attrdef.c:

Go to the source code of this file.

Functions
Oid	StoreAttrDefault (Relation rel, AttrNumber attnum, Node *expr, bool is_internal, bool add_column_mode)
void	RemoveAttrDefault (Oid relid, AttrNumber attnum, DropBehavior behavior, bool complain, bool internal)
void	RemoveAttrDefaultById (Oid attrdefId)
Oid	GetAttrDefaultOid (Oid relid, AttrNumber attnum)
ObjectAddress	GetAttrDefaultColumnAddress (Oid attrdefoid)

Function Documentation

GetAttrDefaultColumnAddress()

ObjectAddress GetAttrDefaultColumnAddress

(

Oid

attrdefoid

)

Definition at line 381 of file pg_attrdef.c.

{
    ObjectAddress result = InvalidObjectAddress;
    Relation    attrdef;
    ScanKeyData skey[1];
    SysScanDesc scan;
    HeapTuple   tup;
 
    attrdef = table_open(AttrDefaultRelationId, AccessShareLock);
    ScanKeyInit(&skey[0],
                Anum_pg_attrdef_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(attrdefoid));
    scan = systable_beginscan(attrdef, AttrDefaultOidIndexId, true,
                              NULL, 1, skey);
 
    if (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_attrdef atdform = (Form_pg_attrdef) GETSTRUCT(tup);
 
        result.classId = RelationRelationId;
        result.objectId = atdform->adrelid;
        result.objectSubId = atdform->adnum;
    }
 
    systable_endscan(scan);
    table_close(attrdef, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, ObjectAddress::classId, GETSTRUCT, HeapTupleIsValid, InvalidObjectAddress, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by getObjectDescription(), getObjectIdentityParts(), and RememberAllDependentForRebuilding().

GetAttrDefaultOid()

Oid GetAttrDefaultOid	(	Oid	relid,
		AttrNumber	attnum
	)

Definition at line 339 of file pg_attrdef.c.

{
    Oid         result = InvalidOid;
    Relation    attrdef;
    ScanKeyData keys[2];
    SysScanDesc scan;
    HeapTuple   tup;
 
    attrdef = table_open(AttrDefaultRelationId, AccessShareLock);
    ScanKeyInit(&keys[0],
                Anum_pg_attrdef_adrelid,
                BTEqualStrategyNumber,
                F_OIDEQ,
                ObjectIdGetDatum(relid));
    ScanKeyInit(&keys[1],
                Anum_pg_attrdef_adnum,
                BTEqualStrategyNumber,
                F_INT2EQ,
                Int16GetDatum(attnum));
    scan = systable_beginscan(attrdef, AttrDefaultIndexId, true,
                              NULL, 2, keys);
 
    if (HeapTupleIsValid(tup = systable_getnext(scan)))
    {
        Form_pg_attrdef atdform = (Form_pg_attrdef) GETSTRUCT(tup);
 
        result = atdform->oid;
    }
 
    systable_endscan(scan);
    table_close(attrdef, AccessShareLock);
 
    return result;
}

References AccessShareLock, attnum, BTEqualStrategyNumber, GETSTRUCT, HeapTupleIsValid, Int16GetDatum(), InvalidOid, ObjectIdGetDatum(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ATExecAlterColumnType(), ATExecDropExpression(), ATExecSetExpression(), and get_object_address_attrdef().

RemoveAttrDefault()

void RemoveAttrDefault	(	Oid	relid,
		AttrNumber	attnum,
		DropBehavior	behavior,
		bool	complain,
		bool	internal
	)

Definition at line 213 of file pg_attrdef.c.

{
    Relation    attrdef_rel;
    ScanKeyData scankeys[2];
    SysScanDesc scan;
    HeapTuple   tuple;
    bool        found = false;
 
    attrdef_rel = table_open(AttrDefaultRelationId, RowExclusiveLock);
 
    ScanKeyInit(&scankeys[0],
                Anum_pg_attrdef_adrelid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(relid));
    ScanKeyInit(&scankeys[1],
                Anum_pg_attrdef_adnum,
                BTEqualStrategyNumber, F_INT2EQ,
                Int16GetDatum(attnum));
 
    scan = systable_beginscan(attrdef_rel, AttrDefaultIndexId, true,
                              NULL, 2, scankeys);
 
    /* There should be at most one matching tuple, but we loop anyway */
    while (HeapTupleIsValid(tuple = systable_getnext(scan)))
    {
        ObjectAddress object;
        Form_pg_attrdef attrtuple = (Form_pg_attrdef) GETSTRUCT(tuple);
 
        object.classId = AttrDefaultRelationId;
        object.objectId = attrtuple->oid;
        object.objectSubId = 0;
 
        performDeletion(&object, behavior,
                        internal ? PERFORM_DELETION_INTERNAL : 0);
 
        found = true;
    }
 
    systable_endscan(scan);
    table_close(attrdef_rel, RowExclusiveLock);
 
    if (complain && !found)
        elog(ERROR, "could not find attrdef tuple for relation %u attnum %d",
             relid, attnum);
}

References attnum, BTEqualStrategyNumber, elog, ERROR, GETSTRUCT, HeapTupleIsValid, Int16GetDatum(), ObjectIdGetDatum(), PERFORM_DELETION_INTERNAL, performDeletion(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ATExecAlterColumnType(), ATExecColumnDefault(), ATExecCookedColumnDefault(), ATExecDropExpression(), and ATExecSetExpression().

RemoveAttrDefaultById()

void RemoveAttrDefaultById

(

Oid

attrdefId

)

Definition at line 268 of file pg_attrdef.c.

{
    Relation    attrdef_rel;
    Relation    attr_rel;
    Relation    myrel;
    ScanKeyData scankeys[1];
    SysScanDesc scan;
    HeapTuple   tuple;
    Oid         myrelid;
    AttrNumber  myattnum;
 
    /* Grab an appropriate lock on the pg_attrdef relation */
    attrdef_rel = table_open(AttrDefaultRelationId, RowExclusiveLock);
 
    /* Find the pg_attrdef tuple */
    ScanKeyInit(&scankeys[0],
                Anum_pg_attrdef_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(attrdefId));
 
    scan = systable_beginscan(attrdef_rel, AttrDefaultOidIndexId, true,
                              NULL, 1, scankeys);
 
    tuple = systable_getnext(scan);
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "could not find tuple for attrdef %u", attrdefId);
 
    myrelid = ((Form_pg_attrdef) GETSTRUCT(tuple))->adrelid;
    myattnum = ((Form_pg_attrdef) GETSTRUCT(tuple))->adnum;
 
    /* Get an exclusive lock on the relation owning the attribute */
    myrel = relation_open(myrelid, AccessExclusiveLock);
 
    /* Now we can delete the pg_attrdef row */
    CatalogTupleDelete(attrdef_rel, &tuple->t_self);
 
    systable_endscan(scan);
    table_close(attrdef_rel, RowExclusiveLock);
 
    /* Fix the pg_attribute row */
    attr_rel = table_open(AttributeRelationId, RowExclusiveLock);
 
    tuple = SearchSysCacheCopy2(ATTNUM,
                                ObjectIdGetDatum(myrelid),
                                Int16GetDatum(myattnum));
    if (!HeapTupleIsValid(tuple))   /* shouldn't happen */
        elog(ERROR, "cache lookup failed for attribute %d of relation %u",
             myattnum, myrelid);
 
    ((Form_pg_attribute) GETSTRUCT(tuple))->atthasdef = false;
 
    CatalogTupleUpdate(attr_rel, &tuple->t_self, tuple);
 
    /*
     * Our update of the pg_attribute row will force a relcache rebuild, so
     * there's nothing else to do here.
     */
    table_close(attr_rel, RowExclusiveLock);
 
    /* Keep lock on attribute's rel until end of xact */
    relation_close(myrel, NoLock);
}

References AccessExclusiveLock, BTEqualStrategyNumber, CatalogTupleDelete(), CatalogTupleUpdate(), elog, ERROR, GETSTRUCT, HeapTupleIsValid, Int16GetDatum(), NoLock, ObjectIdGetDatum(), relation_close(), relation_open(), RowExclusiveLock, ScanKeyInit(), SearchSysCacheCopy2, systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

StoreAttrDefault()

Oid StoreAttrDefault	(	Relation	rel,
		AttrNumber	attnum,
		Node *	expr,
		bool	is_internal,
		bool	add_column_mode
	)

Definition at line 46 of file pg_attrdef.c.

{
    char       *adbin;
    Relation    adrel;
    HeapTuple   tuple;
    Datum       values[4];
    static bool nulls[4] = {false, false, false, false};
    Relation    attrrel;
    HeapTuple   atttup;
    Form_pg_attribute attStruct;
    char        attgenerated;
    Oid         attrdefOid;
    ObjectAddress colobject,
                defobject;
 
    adrel = table_open(AttrDefaultRelationId, RowExclusiveLock);
 
    /*
     * Flatten expression to string form for storage.
     */
    adbin = nodeToString(expr);
 
    /*
     * Make the pg_attrdef entry.
     */
    attrdefOid = GetNewOidWithIndex(adrel, AttrDefaultOidIndexId,
                                    Anum_pg_attrdef_oid);
    values[Anum_pg_attrdef_oid - 1] = ObjectIdGetDatum(attrdefOid);
    values[Anum_pg_attrdef_adrelid - 1] = RelationGetRelid(rel);
    values[Anum_pg_attrdef_adnum - 1] = attnum;
    values[Anum_pg_attrdef_adbin - 1] = CStringGetTextDatum(adbin);
 
    tuple = heap_form_tuple(adrel->rd_att, values, nulls);
    CatalogTupleInsert(adrel, tuple);
 
    defobject.classId = AttrDefaultRelationId;
    defobject.objectId = attrdefOid;
    defobject.objectSubId = 0;
 
    table_close(adrel, RowExclusiveLock);
 
    /* now can free some of the stuff allocated above */
    pfree(DatumGetPointer(values[Anum_pg_attrdef_adbin - 1]));
    heap_freetuple(tuple);
    pfree(adbin);
 
    /*
     * Update the pg_attribute entry for the column to show that a default
     * exists.
     */
    attrrel = table_open(AttributeRelationId, RowExclusiveLock);
    atttup = SearchSysCacheCopy2(ATTNUM,
                                 ObjectIdGetDatum(RelationGetRelid(rel)),
                                 Int16GetDatum(attnum));
    if (!HeapTupleIsValid(atttup))
        elog(ERROR, "cache lookup failed for attribute %d of relation %u",
             attnum, RelationGetRelid(rel));
    attStruct = (Form_pg_attribute) GETSTRUCT(atttup);
    attgenerated = attStruct->attgenerated;
    if (!attStruct->atthasdef)
    {
        Form_pg_attribute defAttStruct;
 
        ExprState  *exprState;
        Expr       *expr2 = (Expr *) expr;
        EState     *estate = NULL;
        ExprContext *econtext;
        Datum       valuesAtt[Natts_pg_attribute] = {0};
        bool        nullsAtt[Natts_pg_attribute] = {0};
        bool        replacesAtt[Natts_pg_attribute] = {0};
        Datum       missingval = (Datum) 0;
        bool        missingIsNull = true;
 
        valuesAtt[Anum_pg_attribute_atthasdef - 1] = true;
        replacesAtt[Anum_pg_attribute_atthasdef - 1] = true;
 
        if (rel->rd_rel->relkind == RELKIND_RELATION && add_column_mode &&
            !attgenerated)
        {
            expr2 = expression_planner(expr2);
            estate = CreateExecutorState();
            exprState = ExecPrepareExpr(expr2, estate);
            econtext = GetPerTupleExprContext(estate);
 
            missingval = ExecEvalExpr(exprState, econtext,
                                      &missingIsNull);
 
            FreeExecutorState(estate);
 
            defAttStruct = TupleDescAttr(rel->rd_att, attnum - 1);
 
            if (missingIsNull)
            {
                /* if the default evaluates to NULL, just store a NULL array */
                missingval = (Datum) 0;
            }
            else
            {
                /* otherwise make a one-element array of the value */
                missingval = PointerGetDatum(construct_array(&missingval,
                                                             1,
                                                             defAttStruct->atttypid,
                                                             defAttStruct->attlen,
                                                             defAttStruct->attbyval,
                                                             defAttStruct->attalign));
            }
 
            valuesAtt[Anum_pg_attribute_atthasmissing - 1] = !missingIsNull;
            replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;
            valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;
            replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
            nullsAtt[Anum_pg_attribute_attmissingval - 1] = missingIsNull;
        }
        atttup = heap_modify_tuple(atttup, RelationGetDescr(attrrel),
                                   valuesAtt, nullsAtt, replacesAtt);
 
        CatalogTupleUpdate(attrrel, &atttup->t_self, atttup);
 
        if (!missingIsNull)
            pfree(DatumGetPointer(missingval));
    }
    table_close(attrrel, RowExclusiveLock);
    heap_freetuple(atttup);
 
    /*
     * Make a dependency so that the pg_attrdef entry goes away if the column
     * (or whole table) is deleted.  In the case of a generated column, make
     * it an internal dependency to prevent the default expression from being
     * deleted separately.
     */
    colobject.classId = RelationRelationId;
    colobject.objectId = RelationGetRelid(rel);
    colobject.objectSubId = attnum;
 
    recordDependencyOn(&defobject, &colobject,
                       attgenerated ? DEPENDENCY_INTERNAL : DEPENDENCY_AUTO);
 
    /*
     * Record dependencies on objects used in the expression, too.
     */
    recordDependencyOnSingleRelExpr(&defobject, expr, RelationGetRelid(rel),
                                    DEPENDENCY_NORMAL,
                                    DEPENDENCY_NORMAL, false);
 
    /*
     * Post creation hook for attribute defaults.
     *
     * XXX. ALTER TABLE ALTER COLUMN SET/DROP DEFAULT is implemented with a
     * couple of deletion/creation of the attribute's default entry, so the
     * callee should check existence of an older version of this entry if it
     * needs to distinguish.
     */
    InvokeObjectPostCreateHookArg(AttrDefaultRelationId,
                                  RelationGetRelid(rel), attnum, is_internal);
 
    return attrdefOid;
}

References attnum, CatalogTupleInsert(), CatalogTupleUpdate(), ObjectAddress::classId, construct_array(), CreateExecutorState(), CStringGetTextDatum, DatumGetPointer(), DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, DEPENDENCY_NORMAL, elog, ERROR, ExecEvalExpr(), ExecPrepareExpr(), expression_planner(), FreeExecutorState(), GetNewOidWithIndex(), GetPerTupleExprContext, GETSTRUCT, heap_form_tuple(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, Int16GetDatum(), InvokeObjectPostCreateHookArg, nodeToString(), ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, pfree(), PointerGetDatum(), RelationData::rd_att, RelationData::rd_rel, recordDependencyOn(), recordDependencyOnSingleRelExpr(), RelationGetDescr, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy2, HeapTupleData::t_self, table_close(), table_open(), TupleDescAttr, and values.

Referenced by AddRelationNewConstraints(), ATExecAlterColumnType(), ATExecCookedColumnDefault(), and StoreConstraints().