opclasscmds.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/genam.h"
#include "access/hash.h"
#include "access/htup_details.h"
#include "access/nbtree.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_am.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_amproc.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "commands/alter.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
#include "miscadmin.h"
#include "parser/parse_func.h"
#include "parser/parse_oper.h"
#include "parser/parse_type.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for opclasscmds.c:

Go to the source code of this file.

Functions
static void	AlterOpFamilyAdd (AlterOpFamilyStmt *stmt, Oid amoid, Oid opfamilyoid, int maxOpNumber, int maxProcNumber, int optsProcNumber, List *items)
static void	AlterOpFamilyDrop (AlterOpFamilyStmt *stmt, Oid amoid, Oid opfamilyoid, int maxOpNumber, int maxProcNumber, List *items)
static void	processTypesSpec (List *args, Oid *lefttype, Oid *righttype)
static void	assignOperTypes (OpFamilyMember *member, Oid amoid, Oid typeoid)
static void	assignProcTypes (OpFamilyMember *member, Oid amoid, Oid typeoid, int opclassOptsProcNum)
static void	addFamilyMember (List **list, OpFamilyMember *member)
static void	storeOperators (List *opfamilyname, Oid amoid, Oid opfamilyoid, List *operators, bool isAdd)
static void	storeProcedures (List *opfamilyname, Oid amoid, Oid opfamilyoid, List *procedures, bool isAdd)
static void	dropOperators (List *opfamilyname, Oid amoid, Oid opfamilyoid, List *operators)
static void	dropProcedures (List *opfamilyname, Oid amoid, Oid opfamilyoid, List *procedures)
static HeapTuple	OpFamilyCacheLookup (Oid amID, List *opfamilyname, bool missing_ok)
Oid	get_opfamily_oid (Oid amID, List *opfamilyname, bool missing_ok)
static HeapTuple	OpClassCacheLookup (Oid amID, List *opclassname, bool missing_ok)
Oid	get_opclass_oid (Oid amID, List *opclassname, bool missing_ok)
static ObjectAddress	CreateOpFamily (CreateOpFamilyStmt *stmt, const char *opfname, Oid namespaceoid, Oid amoid)
ObjectAddress	DefineOpClass (CreateOpClassStmt *stmt)
ObjectAddress	DefineOpFamily (CreateOpFamilyStmt *stmt)
Oid	AlterOpFamily (AlterOpFamilyStmt *stmt)
void	IsThereOpClassInNamespace (const char *opcname, Oid opcmethod, Oid opcnamespace)
void	IsThereOpFamilyInNamespace (const char *opfname, Oid opfmethod, Oid opfnamespace)

Function Documentation

addFamilyMember()

static void addFamilyMember ( List **  list, OpFamilyMember *  member  )

static

Definition at line 1392 of file opclasscmds.c.

{
    ListCell   *l;
 
    foreach(l, *list)
    {
        OpFamilyMember *old = (OpFamilyMember *) lfirst(l);
 
        if (old->number == member->number &&
            old->lefttype == member->lefttype &&
            old->righttype == member->righttype)
        {
            if (member->is_func)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("function number %d for (%s,%s) appears more than once",
                                member->number,
                                format_type_be(member->lefttype),
                                format_type_be(member->righttype))));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("operator number %d for (%s,%s) appears more than once",
                                member->number,
                                format_type_be(member->lefttype),
                                format_type_be(member->righttype))));
        }
    }
    *list = lappend(*list, member);
}

References ereport, errcode(), errmsg(), ERROR, format_type_be(), OpFamilyMember::is_func, lappend(), OpFamilyMember::lefttype, lfirst, sort-test::list, OpFamilyMember::number, and OpFamilyMember::righttype.

Referenced by AlterOpFamilyAdd(), AlterOpFamilyDrop(), and DefineOpClass().

AlterOpFamily()

Oid AlterOpFamily

(

AlterOpFamilyStmt *

stmt

)

Definition at line 817 of file opclasscmds.c.

{
    Oid         amoid,          /* our AM's oid */
                opfamilyoid;    /* oid of opfamily */
    int         maxOpNumber,    /* amstrategies value */
                optsProcNumber, /* amoptsprocnum value */
                maxProcNumber;  /* amsupport value */
    HeapTuple   tup;
    Form_pg_am  amform;
    IndexAmRoutine *amroutine;
 
    /* Get necessary info about access method */
    tup = SearchSysCache1(AMNAME, CStringGetDatum(stmt->amname));
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("access method \"%s\" does not exist",
                        stmt->amname)));
 
    amform = (Form_pg_am) GETSTRUCT(tup);
    amoid = amform->oid;
    amroutine = GetIndexAmRoutineByAmId(amoid, false);
    ReleaseSysCache(tup);
 
    maxOpNumber = amroutine->amstrategies;
    /* if amstrategies is zero, just enforce that op numbers fit in int16 */
    if (maxOpNumber <= 0)
        maxOpNumber = SHRT_MAX;
    maxProcNumber = amroutine->amsupport;
    optsProcNumber = amroutine->amoptsprocnum;
 
    /* XXX Should we make any privilege check against the AM? */
 
    /* Look up the opfamily */
    opfamilyoid = get_opfamily_oid(amoid, stmt->opfamilyname, false);
 
    /*
     * Currently, we require superuser privileges to alter an opfamily.
     *
     * XXX re-enable NOT_USED code sections below if you remove this test.
     */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to alter an operator family")));
 
    /*
     * ADD and DROP cases need separate code from here on down.
     */
    if (stmt->isDrop)
        AlterOpFamilyDrop(stmt, amoid, opfamilyoid,
                          maxOpNumber, maxProcNumber, stmt->items);
    else
        AlterOpFamilyAdd(stmt, amoid, opfamilyoid,
                         maxOpNumber, maxProcNumber, optsProcNumber,
                         stmt->items);
 
    return opfamilyoid;
}

References AlterOpFamilyAdd(), AlterOpFamilyDrop(), AMNAME, IndexAmRoutine::amoptsprocnum, IndexAmRoutine::amstrategies, IndexAmRoutine::amsupport, CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, get_opfamily_oid(), GetIndexAmRoutineByAmId(), GETSTRUCT, HeapTupleIsValid, ReleaseSysCache(), SearchSysCache1(), stmt, and superuser().

Referenced by ProcessUtilitySlow().

AlterOpFamilyAdd()

static void AlterOpFamilyAdd ( AlterOpFamilyStmt *  stmt, Oid  amoid, Oid  opfamilyoid, int  maxOpNumber, int  maxProcNumber, int  optsProcNumber, List *  items  )

static

Definition at line 881 of file opclasscmds.c.

{
    IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(amoid, false);
    List       *operators;      /* OpFamilyMember list for operators */
    List       *procedures;     /* OpFamilyMember list for support procs */
    ListCell   *l;
 
    operators = NIL;
    procedures = NIL;
 
    /*
     * Scan the "items" list to obtain additional info.
     */
    foreach(l, items)
    {
        CreateOpClassItem *item = lfirst_node(CreateOpClassItem, l);
        Oid         operOid;
        Oid         funcOid;
        Oid         sortfamilyOid;
        OpFamilyMember *member;
 
        switch (item->itemtype)
        {
            case OPCLASS_ITEM_OPERATOR:
                if (item->number <= 0 || item->number > maxOpNumber)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("invalid operator number %d,"
                                    " must be between 1 and %d",
                                    item->number, maxOpNumber)));
                if (item->name->objargs != NIL)
                    operOid = LookupOperWithArgs(item->name, false);
                else
                {
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("operator argument types must be specified in ALTER OPERATOR FAMILY")));
                    operOid = InvalidOid;   /* keep compiler quiet */
                }
 
                if (item->order_family)
                    sortfamilyOid = get_opfamily_oid(BTREE_AM_OID,
                                                     item->order_family,
                                                     false);
                else
                    sortfamilyOid = InvalidOid;
 
#ifdef NOT_USED
                /* XXX this is unnecessary given the superuser check above */
                /* Caller must own operator and its underlying function */
                if (!object_ownercheck(OperatorRelationId, operOid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                                   get_opname(operOid));
                funcOid = get_opcode(operOid);
                if (!object_ownercheck(ProcedureRelationId, funcOid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
                                   get_func_name(funcOid));
#endif
 
                /* Save the info */
                member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
                member->is_func = false;
                member->object = operOid;
                member->number = item->number;
                member->sortfamily = sortfamilyOid;
                /* We can set up dependency fields immediately */
                /* Historically, ALTER ADD has created soft dependencies */
                member->ref_is_hard = false;
                member->ref_is_family = true;
                member->refobjid = opfamilyoid;
                assignOperTypes(member, amoid, InvalidOid);
                addFamilyMember(&operators, member);
                break;
            case OPCLASS_ITEM_FUNCTION:
                if (item->number <= 0 || item->number > maxProcNumber)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("invalid function number %d,"
                                    " must be between 1 and %d",
                                    item->number, maxProcNumber)));
                funcOid = LookupFuncWithArgs(OBJECT_FUNCTION, item->name, false);
#ifdef NOT_USED
                /* XXX this is unnecessary given the superuser check above */
                /* Caller must own function */
                if (!object_ownercheck(ProcedureRelationId, funcOid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
                                   get_func_name(funcOid));
#endif
 
                /* Save the info */
                member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
                member->is_func = true;
                member->object = funcOid;
                member->number = item->number;
                /* We can set up dependency fields immediately */
                /* Historically, ALTER ADD has created soft dependencies */
                member->ref_is_hard = false;
                member->ref_is_family = true;
                member->refobjid = opfamilyoid;
 
                /* allow overriding of the function's actual arg types */
                if (item->class_args)
                    processTypesSpec(item->class_args,
                                     &member->lefttype, &member->righttype);
 
                assignProcTypes(member, amoid, InvalidOid, optsProcNumber);
                addFamilyMember(&procedures, member);
                break;
            case OPCLASS_ITEM_STORAGETYPE:
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("STORAGE cannot be specified in ALTER OPERATOR FAMILY")));
                break;
            default:
                elog(ERROR, "unrecognized item type: %d", item->itemtype);
                break;
        }
    }
 
    /*
     * Let the index AM editorialize on the dependency choices.  It could also
     * do further validation on the operators and functions, if it likes.
     */
    if (amroutine->amadjustmembers)
        amroutine->amadjustmembers(opfamilyoid,
                                   InvalidOid,  /* no specific opclass */
                                   operators,
                                   procedures);
 
    /*
     * Add tuples to pg_amop and pg_amproc tying in the operators and
     * functions.  Dependencies on them are inserted, too.
     */
    storeOperators(stmt->opfamilyname, amoid, opfamilyoid,
                   operators, true);
    storeProcedures(stmt->opfamilyname, amoid, opfamilyoid,
                    procedures, true);
 
    /* make information available to event triggers */
    EventTriggerCollectAlterOpFam(stmt, opfamilyoid,
                                  operators, procedures);
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, addFamilyMember(), IndexAmRoutine::amadjustmembers, assignOperTypes(), assignProcTypes(), CreateOpClassItem::class_args, elog(), ereport, errcode(), errmsg(), ERROR, EventTriggerCollectAlterOpFam(), get_func_name(), get_opcode(), get_opfamily_oid(), get_opname(), GetIndexAmRoutineByAmId(), GetUserId(), InvalidOid, OpFamilyMember::is_func, CreateOpClassItem::itemtype, OpFamilyMember::lefttype, lfirst_node, LookupFuncWithArgs(), LookupOperWithArgs(), CreateOpClassItem::name, NIL, OpFamilyMember::number, CreateOpClassItem::number, ObjectWithArgs::objargs, OpFamilyMember::object, OBJECT_FUNCTION, OBJECT_OPERATOR, object_ownercheck(), OPCLASS_ITEM_FUNCTION, OPCLASS_ITEM_OPERATOR, OPCLASS_ITEM_STORAGETYPE, CreateOpClassItem::order_family, palloc0(), processTypesSpec(), OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, OpFamilyMember::refobjid, OpFamilyMember::righttype, OpFamilyMember::sortfamily, stmt, storeOperators(), and storeProcedures().

Referenced by AlterOpFamily().

AlterOpFamilyDrop()

static void AlterOpFamilyDrop ( AlterOpFamilyStmt *  stmt, Oid  amoid, Oid  opfamilyoid, int  maxOpNumber, int  maxProcNumber, List *  items  )

static

Definition at line 1030 of file opclasscmds.c.

{
    List       *operators;      /* OpFamilyMember list for operators */
    List       *procedures;     /* OpFamilyMember list for support procs */
    ListCell   *l;
 
    operators = NIL;
    procedures = NIL;
 
    /*
     * Scan the "items" list to obtain additional info.
     */
    foreach(l, items)
    {
        CreateOpClassItem *item = lfirst_node(CreateOpClassItem, l);
        Oid         lefttype,
                    righttype;
        OpFamilyMember *member;
 
        switch (item->itemtype)
        {
            case OPCLASS_ITEM_OPERATOR:
                if (item->number <= 0 || item->number > maxOpNumber)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("invalid operator number %d,"
                                    " must be between 1 and %d",
                                    item->number, maxOpNumber)));
                processTypesSpec(item->class_args, &lefttype, &righttype);
                /* Save the info */
                member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
                member->is_func = false;
                member->number = item->number;
                member->lefttype = lefttype;
                member->righttype = righttype;
                addFamilyMember(&operators, member);
                break;
            case OPCLASS_ITEM_FUNCTION:
                if (item->number <= 0 || item->number > maxProcNumber)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("invalid function number %d,"
                                    " must be between 1 and %d",
                                    item->number, maxProcNumber)));
                processTypesSpec(item->class_args, &lefttype, &righttype);
                /* Save the info */
                member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
                member->is_func = true;
                member->number = item->number;
                member->lefttype = lefttype;
                member->righttype = righttype;
                addFamilyMember(&procedures, member);
                break;
            case OPCLASS_ITEM_STORAGETYPE:
                /* grammar prevents this from appearing */
            default:
                elog(ERROR, "unrecognized item type: %d", item->itemtype);
                break;
        }
    }
 
    /*
     * Remove tuples from pg_amop and pg_amproc.
     */
    dropOperators(stmt->opfamilyname, amoid, opfamilyoid, operators);
    dropProcedures(stmt->opfamilyname, amoid, opfamilyoid, procedures);
 
    /* make information available to event triggers */
    EventTriggerCollectAlterOpFam(stmt, opfamilyoid,
                                  operators, procedures);
}

References addFamilyMember(), CreateOpClassItem::class_args, dropOperators(), dropProcedures(), elog(), ereport, errcode(), errmsg(), ERROR, EventTriggerCollectAlterOpFam(), OpFamilyMember::is_func, CreateOpClassItem::itemtype, OpFamilyMember::lefttype, lfirst_node, NIL, OpFamilyMember::number, CreateOpClassItem::number, OPCLASS_ITEM_FUNCTION, OPCLASS_ITEM_OPERATOR, OPCLASS_ITEM_STORAGETYPE, palloc0(), processTypesSpec(), OpFamilyMember::righttype, and stmt.

Referenced by AlterOpFamily().

assignOperTypes()

static void assignOperTypes ( OpFamilyMember *  member, Oid  amoid, Oid  typeoid  )

static

Definition at line 1137 of file opclasscmds.c.

{
    Operator    optup;
    Form_pg_operator opform;
 
    /* Fetch the operator definition */
    optup = SearchSysCache1(OPEROID, ObjectIdGetDatum(member->object));
    if (!HeapTupleIsValid(optup))
        elog(ERROR, "cache lookup failed for operator %u", member->object);
    opform = (Form_pg_operator) GETSTRUCT(optup);
 
    /*
     * Opfamily operators must be binary.
     */
    if (opform->oprkind != 'b')
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("index operators must be binary")));
 
    if (OidIsValid(member->sortfamily))
    {
        /*
         * Ordering op, check index supports that.  (We could perhaps also
         * check that the operator returns a type supported by the sortfamily,
         * but that seems more trouble than it's worth here.  If it does not,
         * the operator will never be matchable to any ORDER BY clause, but no
         * worse consequences can ensue.  Also, trying to check that would
         * create an ordering hazard during dump/reload: it's possible that
         * the family has been created but not yet populated with the required
         * operators.)
         */
        IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(amoid, false);
 
        if (!amroutine->amcanorderbyop)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("access method \"%s\" does not support ordering operators",
                            get_am_name(amoid))));
    }
    else
    {
        /*
         * Search operators must return boolean.
         */
        if (opform->oprresult != BOOLOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("index search operators must return boolean")));
    }
 
    /*
     * If lefttype/righttype isn't specified, use the operator's input types
     */
    if (!OidIsValid(member->lefttype))
        member->lefttype = opform->oprleft;
    if (!OidIsValid(member->righttype))
        member->righttype = opform->oprright;
 
    ReleaseSysCache(optup);
}

References IndexAmRoutine::amcanorderbyop, elog(), ereport, errcode(), errmsg(), ERROR, get_am_name(), GetIndexAmRoutineByAmId(), GETSTRUCT, HeapTupleIsValid, OpFamilyMember::lefttype, OpFamilyMember::object, ObjectIdGetDatum(), OidIsValid, OPEROID, ReleaseSysCache(), OpFamilyMember::righttype, SearchSysCache1(), and OpFamilyMember::sortfamily.

Referenced by AlterOpFamilyAdd(), and DefineOpClass().

assignProcTypes()

static void assignProcTypes ( OpFamilyMember *  member, Oid  amoid, Oid  typeoid, int  opclassOptsProcNum  )

static

Definition at line 1203 of file opclasscmds.c.

{
    HeapTuple   proctup;
    Form_pg_proc procform;
 
    /* Fetch the procedure definition */
    proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(member->object));
    if (!HeapTupleIsValid(proctup))
        elog(ERROR, "cache lookup failed for function %u", member->object);
    procform = (Form_pg_proc) GETSTRUCT(proctup);
 
    /* Check the signature of the opclass options parsing function */
    if (member->number == opclassOptsProcNum)
    {
        if (OidIsValid(typeoid))
        {
            if ((OidIsValid(member->lefttype) && member->lefttype != typeoid) ||
                (OidIsValid(member->righttype) && member->righttype != typeoid))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("associated data types for operator class options parsing functions must match opclass input type")));
        }
        else
        {
            if (member->lefttype != member->righttype)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("left and right associated data types for operator class options parsing functions must match")));
        }
 
        if (procform->prorettype != VOIDOID ||
            procform->pronargs != 1 ||
            procform->proargtypes.values[0] != INTERNALOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("invalid operator class options parsing function"),
                     errhint("Valid signature of operator class options parsing function is %s.",
                             "(internal) RETURNS void")));
    }
 
    /*
     * btree comparison procs must be 2-arg procs returning int4.  btree
     * sortsupport procs must take internal and return void.  btree in_range
     * procs must be 5-arg procs returning bool.  btree equalimage procs must
     * take 1 arg and return bool.  hash support proc 1 must be a 1-arg proc
     * returning int4, while proc 2 must be a 2-arg proc returning int8.
     * Otherwise we don't know.
     */
    else if (amoid == BTREE_AM_OID)
    {
        if (member->number == BTORDER_PROC)
        {
            if (procform->pronargs != 2)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree comparison functions must have two arguments")));
            if (procform->prorettype != INT4OID)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree comparison functions must return integer")));
 
            /*
             * If lefttype/righttype isn't specified, use the proc's input
             * types
             */
            if (!OidIsValid(member->lefttype))
                member->lefttype = procform->proargtypes.values[0];
            if (!OidIsValid(member->righttype))
                member->righttype = procform->proargtypes.values[1];
        }
        else if (member->number == BTSORTSUPPORT_PROC)
        {
            if (procform->pronargs != 1 ||
                procform->proargtypes.values[0] != INTERNALOID)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree sort support functions must accept type \"internal\"")));
            if (procform->prorettype != VOIDOID)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree sort support functions must return void")));
 
            /*
             * Can't infer lefttype/righttype from proc, so use default rule
             */
        }
        else if (member->number == BTINRANGE_PROC)
        {
            if (procform->pronargs != 5)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree in_range functions must have five arguments")));
            if (procform->prorettype != BOOLOID)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree in_range functions must return boolean")));
 
            /*
             * If lefttype/righttype isn't specified, use the proc's input
             * types (we look at the test-value and offset arguments)
             */
            if (!OidIsValid(member->lefttype))
                member->lefttype = procform->proargtypes.values[0];
            if (!OidIsValid(member->righttype))
                member->righttype = procform->proargtypes.values[2];
        }
        else if (member->number == BTEQUALIMAGE_PROC)
        {
            if (procform->pronargs != 1)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree equal image functions must have one argument")));
            if (procform->prorettype != BOOLOID)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree equal image functions must return boolean")));
 
            /*
             * pg_amproc functions are indexed by (lefttype, righttype), but
             * an equalimage function can only be called at CREATE INDEX time.
             * The same opclass opcintype OID is always used for lefttype and
             * righttype.  Providing a cross-type routine isn't sensible.
             * Reject cross-type ALTER OPERATOR FAMILY ...  ADD FUNCTION 4
             * statements here.
             */
            if (member->lefttype != member->righttype)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("btree equal image functions must not be cross-type")));
        }
    }
    else if (amoid == HASH_AM_OID)
    {
        if (member->number == HASHSTANDARD_PROC)
        {
            if (procform->pronargs != 1)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("hash function 1 must have one argument")));
            if (procform->prorettype != INT4OID)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("hash function 1 must return integer")));
        }
        else if (member->number == HASHEXTENDED_PROC)
        {
            if (procform->pronargs != 2)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("hash function 2 must have two arguments")));
            if (procform->prorettype != INT8OID)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("hash function 2 must return bigint")));
        }
 
        /*
         * If lefttype/righttype isn't specified, use the proc's input type
         */
        if (!OidIsValid(member->lefttype))
            member->lefttype = procform->proargtypes.values[0];
        if (!OidIsValid(member->righttype))
            member->righttype = procform->proargtypes.values[0];
    }
 
    /*
     * The default in CREATE OPERATOR CLASS is to use the class' opcintype as
     * lefttype and righttype.  In CREATE or ALTER OPERATOR FAMILY, opcintype
     * isn't available, so make the user specify the types.
     */
    if (!OidIsValid(member->lefttype))
        member->lefttype = typeoid;
    if (!OidIsValid(member->righttype))
        member->righttype = typeoid;
 
    if (!OidIsValid(member->lefttype) || !OidIsValid(member->righttype))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("associated data types must be specified for index support function")));
 
    ReleaseSysCache(proctup);
}

References BTEQUALIMAGE_PROC, BTINRANGE_PROC, BTORDER_PROC, BTSORTSUPPORT_PROC, elog(), ereport, errcode(), errhint(), errmsg(), ERROR, GETSTRUCT, HASHEXTENDED_PROC, HASHSTANDARD_PROC, HeapTupleIsValid, OpFamilyMember::lefttype, OpFamilyMember::number, OpFamilyMember::object, ObjectIdGetDatum(), OidIsValid, PROCOID, ReleaseSysCache(), OpFamilyMember::righttype, and SearchSysCache1().

Referenced by AlterOpFamilyAdd(), and DefineOpClass().

CreateOpFamily()

static ObjectAddress CreateOpFamily ( CreateOpFamilyStmt *  stmt, const char *  opfname, Oid  namespaceoid, Oid  amoid  )

static

Definition at line 243 of file opclasscmds.c.

{
    Oid         opfamilyoid;
    Relation    rel;
    HeapTuple   tup;
    Datum       values[Natts_pg_opfamily];
    bool        nulls[Natts_pg_opfamily];
    NameData    opfName;
    ObjectAddress myself,
                referenced;
 
    rel = table_open(OperatorFamilyRelationId, RowExclusiveLock);
 
    /*
     * Make sure there is no existing opfamily of this name (this is just to
     * give a more friendly error message than "duplicate key").
     */
    if (SearchSysCacheExists3(OPFAMILYAMNAMENSP,
                              ObjectIdGetDatum(amoid),
                              CStringGetDatum(opfname),
                              ObjectIdGetDatum(namespaceoid)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("operator family \"%s\" for access method \"%s\" already exists",
                        opfname, stmt->amname)));
 
    /*
     * Okay, let's create the pg_opfamily entry.
     */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));
 
    opfamilyoid = GetNewOidWithIndex(rel, OpfamilyOidIndexId,
                                     Anum_pg_opfamily_oid);
    values[Anum_pg_opfamily_oid - 1] = ObjectIdGetDatum(opfamilyoid);
    values[Anum_pg_opfamily_opfmethod - 1] = ObjectIdGetDatum(amoid);
    namestrcpy(&opfName, opfname);
    values[Anum_pg_opfamily_opfname - 1] = NameGetDatum(&opfName);
    values[Anum_pg_opfamily_opfnamespace - 1] = ObjectIdGetDatum(namespaceoid);
    values[Anum_pg_opfamily_opfowner - 1] = ObjectIdGetDatum(GetUserId());
 
    tup = heap_form_tuple(rel->rd_att, values, nulls);
 
    CatalogTupleInsert(rel, tup);
 
    heap_freetuple(tup);
 
    /*
     * Create dependencies for the opfamily proper.
     */
    myself.classId = OperatorFamilyRelationId;
    myself.objectId = opfamilyoid;
    myself.objectSubId = 0;
 
    /* dependency on access method */
    referenced.classId = AccessMethodRelationId;
    referenced.objectId = amoid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
 
    /* dependency on namespace */
    referenced.classId = NamespaceRelationId;
    referenced.objectId = namespaceoid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
    /* dependency on owner */
    recordDependencyOnOwner(OperatorFamilyRelationId, opfamilyoid, GetUserId());
 
    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, false);
 
    /* Report the new operator family to possibly interested event triggers */
    EventTriggerCollectSimpleCommand(myself, InvalidObjectAddress,
                                     (Node *) stmt);
 
    /* Post creation hook for new operator family */
    InvokeObjectPostCreateHook(OperatorFamilyRelationId, opfamilyoid, 0);
 
    table_close(rel, RowExclusiveLock);
 
    return myself;
}

References CatalogTupleInsert(), ObjectAddress::classId, CStringGetDatum(), DEPENDENCY_AUTO, DEPENDENCY_NORMAL, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, EventTriggerCollectSimpleCommand(), GetNewOidWithIndex(), GetUserId(), heap_form_tuple(), heap_freetuple(), InvalidObjectAddress, InvokeObjectPostCreateHook, NameGetDatum(), namestrcpy(), ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OPFAMILYAMNAMENSP, RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), RowExclusiveLock, SearchSysCacheExists3, stmt, table_close(), table_open(), and values.

Referenced by DefineOpClass(), and DefineOpFamily().

DefineOpClass()

ObjectAddress DefineOpClass

(

CreateOpClassStmt *

stmt

)

Definition at line 333 of file opclasscmds.c.

{
    char       *opcname;        /* name of opclass we're creating */
    Oid         amoid,          /* our AM's oid */
                typeoid,        /* indexable datatype oid */
                storageoid,     /* storage datatype oid, if any */
                namespaceoid,   /* namespace to create opclass in */
                opfamilyoid,    /* oid of containing opfamily */
                opclassoid;     /* oid of opclass we create */
    int         maxOpNumber,    /* amstrategies value */
                optsProcNumber, /* amoptsprocnum value */
                maxProcNumber;  /* amsupport value */
    bool        amstorage;      /* amstorage flag */
    List       *operators;      /* OpFamilyMember list for operators */
    List       *procedures;     /* OpFamilyMember list for support procs */
    ListCell   *l;
    Relation    rel;
    HeapTuple   tup;
    Form_pg_am  amform;
    IndexAmRoutine *amroutine;
    Datum       values[Natts_pg_opclass];
    bool        nulls[Natts_pg_opclass];
    AclResult   aclresult;
    NameData    opcName;
    ObjectAddress myself,
                referenced;
 
    /* Convert list of names to a name and namespace */
    namespaceoid = QualifiedNameGetCreationNamespace(stmt->opclassname,
                                                     &opcname);
 
    /* Check we have creation rights in target namespace */
    aclresult = object_aclcheck(NamespaceRelationId, namespaceoid, GetUserId(), ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA,
                       get_namespace_name(namespaceoid));
 
    /* Get necessary info about access method */
    tup = SearchSysCache1(AMNAME, CStringGetDatum(stmt->amname));
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("access method \"%s\" does not exist",
                        stmt->amname)));
 
    amform = (Form_pg_am) GETSTRUCT(tup);
    amoid = amform->oid;
    amroutine = GetIndexAmRoutineByAmId(amoid, false);
    ReleaseSysCache(tup);
 
    maxOpNumber = amroutine->amstrategies;
    /* if amstrategies is zero, just enforce that op numbers fit in int16 */
    if (maxOpNumber <= 0)
        maxOpNumber = SHRT_MAX;
    maxProcNumber = amroutine->amsupport;
    optsProcNumber = amroutine->amoptsprocnum;
    amstorage = amroutine->amstorage;
 
    /* XXX Should we make any privilege check against the AM? */
 
    /*
     * The question of appropriate permissions for CREATE OPERATOR CLASS is
     * interesting.  Creating an opclass is tantamount to granting public
     * execute access on the functions involved, since the index machinery
     * generally does not check access permission before using the functions.
     * A minimum expectation therefore is that the caller have execute
     * privilege with grant option.  Since we don't have a way to make the
     * opclass go away if the grant option is revoked, we choose instead to
     * require ownership of the functions.  It's also not entirely clear what
     * permissions should be required on the datatype, but ownership seems
     * like a safe choice.
     *
     * Currently, we require superuser privileges to create an opclass. This
     * seems necessary because we have no way to validate that the offered set
     * of operators and functions are consistent with the AM's expectations.
     * It would be nice to provide such a check someday, if it can be done
     * without solving the halting problem :-(
     *
     * XXX re-enable NOT_USED code sections below if you remove this test.
     */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to create an operator class")));
 
    /* Look up the datatype */
    typeoid = typenameTypeId(NULL, stmt->datatype);
 
#ifdef NOT_USED
    /* XXX this is unnecessary given the superuser check above */
    /* Check we have ownership of the datatype */
    if (!object_ownercheck(TypeRelationId, typeoid, GetUserId()))
        aclcheck_error_type(ACLCHECK_NOT_OWNER, typeoid);
#endif
 
    /*
     * Look up the containing operator family, or create one if FAMILY option
     * was omitted and there's not a match already.
     */
    if (stmt->opfamilyname)
    {
        opfamilyoid = get_opfamily_oid(amoid, stmt->opfamilyname, false);
    }
    else
    {
        /* Lookup existing family of same name and namespace */
        tup = SearchSysCache3(OPFAMILYAMNAMENSP,
                              ObjectIdGetDatum(amoid),
                              PointerGetDatum(opcname),
                              ObjectIdGetDatum(namespaceoid));
        if (HeapTupleIsValid(tup))
        {
            opfamilyoid = ((Form_pg_opfamily) GETSTRUCT(tup))->oid;
 
            /*
             * XXX given the superuser check above, there's no need for an
             * ownership check here
             */
            ReleaseSysCache(tup);
        }
        else
        {
            CreateOpFamilyStmt *opfstmt;
            ObjectAddress tmpAddr;
 
            opfstmt = makeNode(CreateOpFamilyStmt);
            opfstmt->opfamilyname = stmt->opclassname;
            opfstmt->amname = stmt->amname;
 
            /*
             * Create it ... again no need for more permissions ...
             */
            tmpAddr = CreateOpFamily(opfstmt, opcname, namespaceoid, amoid);
            opfamilyoid = tmpAddr.objectId;
        }
    }
 
    operators = NIL;
    procedures = NIL;
 
    /* Storage datatype is optional */
    storageoid = InvalidOid;
 
    /*
     * Scan the "items" list to obtain additional info.
     */
    foreach(l, stmt->items)
    {
        CreateOpClassItem *item = lfirst_node(CreateOpClassItem, l);
        Oid         operOid;
        Oid         funcOid;
        Oid         sortfamilyOid;
        OpFamilyMember *member;
 
        switch (item->itemtype)
        {
            case OPCLASS_ITEM_OPERATOR:
                if (item->number <= 0 || item->number > maxOpNumber)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("invalid operator number %d,"
                                    " must be between 1 and %d",
                                    item->number, maxOpNumber)));
                if (item->name->objargs != NIL)
                    operOid = LookupOperWithArgs(item->name, false);
                else
                {
                    /* Default to binary op on input datatype */
                    operOid = LookupOperName(NULL, item->name->objname,
                                             typeoid, typeoid,
                                             false, -1);
                }
 
                if (item->order_family)
                    sortfamilyOid = get_opfamily_oid(BTREE_AM_OID,
                                                     item->order_family,
                                                     false);
                else
                    sortfamilyOid = InvalidOid;
 
#ifdef NOT_USED
                /* XXX this is unnecessary given the superuser check above */
                /* Caller must own operator and its underlying function */
                if (!object_ownercheck(OperatorRelationId, operOid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                                   get_opname(operOid));
                funcOid = get_opcode(operOid);
                if (!object_ownercheck(ProcedureRelationId, funcOid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
                                   get_func_name(funcOid));
#endif
 
                /* Save the info */
                member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
                member->is_func = false;
                member->object = operOid;
                member->number = item->number;
                member->sortfamily = sortfamilyOid;
                assignOperTypes(member, amoid, typeoid);
                addFamilyMember(&operators, member);
                break;
            case OPCLASS_ITEM_FUNCTION:
                if (item->number <= 0 || item->number > maxProcNumber)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("invalid function number %d,"
                                    " must be between 1 and %d",
                                    item->number, maxProcNumber)));
                funcOid = LookupFuncWithArgs(OBJECT_FUNCTION, item->name, false);
#ifdef NOT_USED
                /* XXX this is unnecessary given the superuser check above */
                /* Caller must own function */
                if (!object_ownercheck(ProcedureRelationId, funcOid, GetUserId()))
                    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
                                   get_func_name(funcOid));
#endif
                /* Save the info */
                member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember));
                member->is_func = true;
                member->object = funcOid;
                member->number = item->number;
 
                /* allow overriding of the function's actual arg types */
                if (item->class_args)
                    processTypesSpec(item->class_args,
                                     &member->lefttype, &member->righttype);
 
                assignProcTypes(member, amoid, typeoid, optsProcNumber);
                addFamilyMember(&procedures, member);
                break;
            case OPCLASS_ITEM_STORAGETYPE:
                if (OidIsValid(storageoid))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("storage type specified more than once")));
                storageoid = typenameTypeId(NULL, item->storedtype);
 
#ifdef NOT_USED
                /* XXX this is unnecessary given the superuser check above */
                /* Check we have ownership of the datatype */
                if (!object_ownercheck(TypeRelationId, storageoid, GetUserId()))
                    aclcheck_error_type(ACLCHECK_NOT_OWNER, storageoid);
#endif
                break;
            default:
                elog(ERROR, "unrecognized item type: %d", item->itemtype);
                break;
        }
    }
 
    /*
     * If storagetype is specified, make sure it's legal.
     */
    if (OidIsValid(storageoid))
    {
        /* Just drop the spec if same as column datatype */
        if (storageoid == typeoid)
            storageoid = InvalidOid;
        else if (!amstorage)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("storage type cannot be different from data type for access method \"%s\"",
                            stmt->amname)));
    }
 
    rel = table_open(OperatorClassRelationId, RowExclusiveLock);
 
    /*
     * Make sure there is no existing opclass of this name (this is just to
     * give a more friendly error message than "duplicate key").
     */
    if (SearchSysCacheExists3(CLAAMNAMENSP,
                              ObjectIdGetDatum(amoid),
                              CStringGetDatum(opcname),
                              ObjectIdGetDatum(namespaceoid)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("operator class \"%s\" for access method \"%s\" already exists",
                        opcname, stmt->amname)));
 
    /*
     * If we are creating a default opclass, check there isn't one already.
     * (Note we do not restrict this test to visible opclasses; this ensures
     * that typcache.c can find unique solutions to its questions.)
     */
    if (stmt->isDefault)
    {
        ScanKeyData skey[1];
        SysScanDesc scan;
 
        ScanKeyInit(&skey[0],
                    Anum_pg_opclass_opcmethod,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(amoid));
 
        scan = systable_beginscan(rel, OpclassAmNameNspIndexId, true,
                                  NULL, 1, skey);
 
        while (HeapTupleIsValid(tup = systable_getnext(scan)))
        {
            Form_pg_opclass opclass = (Form_pg_opclass) GETSTRUCT(tup);
 
            if (opclass->opcintype == typeoid && opclass->opcdefault)
                ereport(ERROR,
                        (errcode(ERRCODE_DUPLICATE_OBJECT),
                         errmsg("could not make operator class \"%s\" be default for type %s",
                                opcname,
                                TypeNameToString(stmt->datatype)),
                         errdetail("Operator class \"%s\" already is the default.",
                                   NameStr(opclass->opcname))));
        }
 
        systable_endscan(scan);
    }
 
    /*
     * Okay, let's create the pg_opclass entry.
     */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));
 
    opclassoid = GetNewOidWithIndex(rel, OpclassOidIndexId,
                                    Anum_pg_opclass_oid);
    values[Anum_pg_opclass_oid - 1] = ObjectIdGetDatum(opclassoid);
    values[Anum_pg_opclass_opcmethod - 1] = ObjectIdGetDatum(amoid);
    namestrcpy(&opcName, opcname);
    values[Anum_pg_opclass_opcname - 1] = NameGetDatum(&opcName);
    values[Anum_pg_opclass_opcnamespace - 1] = ObjectIdGetDatum(namespaceoid);
    values[Anum_pg_opclass_opcowner - 1] = ObjectIdGetDatum(GetUserId());
    values[Anum_pg_opclass_opcfamily - 1] = ObjectIdGetDatum(opfamilyoid);
    values[Anum_pg_opclass_opcintype - 1] = ObjectIdGetDatum(typeoid);
    values[Anum_pg_opclass_opcdefault - 1] = BoolGetDatum(stmt->isDefault);
    values[Anum_pg_opclass_opckeytype - 1] = ObjectIdGetDatum(storageoid);
 
    tup = heap_form_tuple(rel->rd_att, values, nulls);
 
    CatalogTupleInsert(rel, tup);
 
    heap_freetuple(tup);
 
    /*
     * Now that we have the opclass OID, set up default dependency info for
     * the pg_amop and pg_amproc entries.  Historically, CREATE OPERATOR CLASS
     * has created hard dependencies on the opclass, so that's what we use.
     */
    foreach(l, operators)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(l);
 
        op->ref_is_hard = true;
        op->ref_is_family = false;
        op->refobjid = opclassoid;
    }
    foreach(l, procedures)
    {
        OpFamilyMember *proc = (OpFamilyMember *) lfirst(l);
 
        proc->ref_is_hard = true;
        proc->ref_is_family = false;
        proc->refobjid = opclassoid;
    }
 
    /*
     * Let the index AM editorialize on the dependency choices.  It could also
     * do further validation on the operators and functions, if it likes.
     */
    if (amroutine->amadjustmembers)
        amroutine->amadjustmembers(opfamilyoid,
                                   opclassoid,
                                   operators,
                                   procedures);
 
    /*
     * Now add tuples to pg_amop and pg_amproc tying in the operators and
     * functions.  Dependencies on them are inserted, too.
     */
    storeOperators(stmt->opfamilyname, amoid, opfamilyoid,
                   operators, false);
    storeProcedures(stmt->opfamilyname, amoid, opfamilyoid,
                    procedures, false);
 
    /* let event triggers know what happened */
    EventTriggerCollectCreateOpClass(stmt, opclassoid, operators, procedures);
 
    /*
     * Create dependencies for the opclass proper.  Note: we do not need a
     * dependency link to the AM, because that exists through the opfamily.
     */
    myself.classId = OperatorClassRelationId;
    myself.objectId = opclassoid;
    myself.objectSubId = 0;
 
    /* dependency on namespace */
    referenced.classId = NamespaceRelationId;
    referenced.objectId = namespaceoid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
    /* dependency on opfamily */
    referenced.classId = OperatorFamilyRelationId;
    referenced.objectId = opfamilyoid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
 
    /* dependency on indexed datatype */
    referenced.classId = TypeRelationId;
    referenced.objectId = typeoid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
    /* dependency on storage datatype */
    if (OidIsValid(storageoid))
    {
        referenced.classId = TypeRelationId;
        referenced.objectId = storageoid;
        referenced.objectSubId = 0;
        recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
    }
 
    /* dependency on owner */
    recordDependencyOnOwner(OperatorClassRelationId, opclassoid, GetUserId());
 
    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, false);
 
    /* Post creation hook for new operator class */
    InvokeObjectPostCreateHook(OperatorClassRelationId, opclassoid, 0);
 
    table_close(rel, RowExclusiveLock);
 
    return myself;
}

References ACL_CREATE, aclcheck_error(), aclcheck_error_type(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, addFamilyMember(), IndexAmRoutine::amadjustmembers, CreateOpFamilyStmt::amname, AMNAME, IndexAmRoutine::amoptsprocnum, IndexAmRoutine::amstorage, IndexAmRoutine::amstrategies, IndexAmRoutine::amsupport, assignOperTypes(), assignProcTypes(), BoolGetDatum(), BTEqualStrategyNumber, CatalogTupleInsert(), CLAAMNAMENSP, CreateOpClassItem::class_args, ObjectAddress::classId, CreateOpFamily(), CStringGetDatum(), DEPENDENCY_AUTO, DEPENDENCY_NORMAL, elog(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail(), errmsg(), ERROR, EventTriggerCollectCreateOpClass(), get_func_name(), get_namespace_name(), get_opcode(), get_opfamily_oid(), get_opname(), GetIndexAmRoutineByAmId(), GetNewOidWithIndex(), GETSTRUCT, GetUserId(), heap_form_tuple(), heap_freetuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostCreateHook, OpFamilyMember::is_func, CreateOpClassItem::itemtype, OpFamilyMember::lefttype, lfirst, lfirst_node, LookupFuncWithArgs(), LookupOperName(), LookupOperWithArgs(), makeNode, CreateOpClassItem::name, NameGetDatum(), NameStr, namestrcpy(), NIL, OpFamilyMember::number, CreateOpClassItem::number, ObjectWithArgs::objargs, OpFamilyMember::object, object_aclcheck(), OBJECT_FUNCTION, OBJECT_OPERATOR, object_ownercheck(), OBJECT_SCHEMA, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, ObjectWithArgs::objname, OidIsValid, OPCLASS_ITEM_FUNCTION, OPCLASS_ITEM_OPERATOR, OPCLASS_ITEM_STORAGETYPE, OPFAMILYAMNAMENSP, CreateOpFamilyStmt::opfamilyname, CreateOpClassItem::order_family, palloc0(), PointerGetDatum(), processTypesSpec(), QualifiedNameGetCreationNamespace(), RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, OpFamilyMember::refobjid, ReleaseSysCache(), OpFamilyMember::righttype, RowExclusiveLock, ScanKeyInit(), SearchSysCache1(), SearchSysCache3(), SearchSysCacheExists3, OpFamilyMember::sortfamily, stmt, CreateOpClassItem::storedtype, storeOperators(), storeProcedures(), superuser(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TypeNameToString(), typenameTypeId(), and values.

Referenced by ProcessUtilitySlow().

DefineOpFamily()

ObjectAddress DefineOpFamily

(

CreateOpFamilyStmt *

stmt

)

Definition at line 772 of file opclasscmds.c.

{
    char       *opfname;        /* name of opfamily we're creating */
    Oid         amoid,          /* our AM's oid */
                namespaceoid;   /* namespace to create opfamily in */
    AclResult   aclresult;
 
    /* Convert list of names to a name and namespace */
    namespaceoid = QualifiedNameGetCreationNamespace(stmt->opfamilyname,
                                                     &opfname);
 
    /* Check we have creation rights in target namespace */
    aclresult = object_aclcheck(NamespaceRelationId, namespaceoid, GetUserId(), ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA,
                       get_namespace_name(namespaceoid));
 
    /* Get access method OID, throwing an error if it doesn't exist. */
    amoid = get_index_am_oid(stmt->amname, false);
 
    /* XXX Should we make any privilege check against the AM? */
 
    /*
     * Currently, we require superuser privileges to create an opfamily. See
     * comments in DefineOpClass.
     */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to create an operator family")));
 
    /* Insert pg_opfamily catalog entry */
    return CreateOpFamily(stmt, opfname, namespaceoid, amoid);
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, CreateOpFamily(), ereport, errcode(), errmsg(), ERROR, get_index_am_oid(), get_namespace_name(), GetUserId(), object_aclcheck(), OBJECT_SCHEMA, QualifiedNameGetCreationNamespace(), stmt, and superuser().

Referenced by ProcessUtilitySlow().

dropOperators()

static void dropOperators ( List *  opfamilyname, Oid  amoid, Oid  opfamilyoid, List *  operators  )

static

Definition at line 1628 of file opclasscmds.c.

{
    ListCell   *l;
 
    foreach(l, operators)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(l);
        Oid         amopid;
        ObjectAddress object;
 
        amopid = GetSysCacheOid4(AMOPSTRATEGY, Anum_pg_amop_oid,
                                 ObjectIdGetDatum(opfamilyoid),
                                 ObjectIdGetDatum(op->lefttype),
                                 ObjectIdGetDatum(op->righttype),
                                 Int16GetDatum(op->number));
        if (!OidIsValid(amopid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("operator %d(%s,%s) does not exist in operator family \"%s\"",
                            op->number,
                            format_type_be(op->lefttype),
                            format_type_be(op->righttype),
                            NameListToString(opfamilyname))));
 
        object.classId = AccessMethodOperatorRelationId;
        object.objectId = amopid;
        object.objectSubId = 0;
 
        performDeletion(&object, DROP_RESTRICT, 0);
    }
}

References AMOPSTRATEGY, DROP_RESTRICT, ereport, errcode(), errmsg(), ERROR, format_type_be(), GetSysCacheOid4, Int16GetDatum(), OpFamilyMember::lefttype, lfirst, NameListToString(), OpFamilyMember::number, ObjectIdGetDatum(), OidIsValid, performDeletion(), and OpFamilyMember::righttype.

Referenced by AlterOpFamilyDrop().

dropProcedures()

static void dropProcedures ( List *  opfamilyname, Oid  amoid, Oid  opfamilyoid, List *  procedures  )

static

Definition at line 1668 of file opclasscmds.c.

{
    ListCell   *l;
 
    foreach(l, procedures)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(l);
        Oid         amprocid;
        ObjectAddress object;
 
        amprocid = GetSysCacheOid4(AMPROCNUM, Anum_pg_amproc_oid,
                                   ObjectIdGetDatum(opfamilyoid),
                                   ObjectIdGetDatum(op->lefttype),
                                   ObjectIdGetDatum(op->righttype),
                                   Int16GetDatum(op->number));
        if (!OidIsValid(amprocid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("function %d(%s,%s) does not exist in operator family \"%s\"",
                            op->number,
                            format_type_be(op->lefttype),
                            format_type_be(op->righttype),
                            NameListToString(opfamilyname))));
 
        object.classId = AccessMethodProcedureRelationId;
        object.objectId = amprocid;
        object.objectSubId = 0;
 
        performDeletion(&object, DROP_RESTRICT, 0);
    }
}

References AMPROCNUM, DROP_RESTRICT, ereport, errcode(), errmsg(), ERROR, format_type_be(), GetSysCacheOid4, Int16GetDatum(), OpFamilyMember::lefttype, lfirst, NameListToString(), OpFamilyMember::number, ObjectIdGetDatum(), OidIsValid, performDeletion(), and OpFamilyMember::righttype.

Referenced by AlterOpFamilyDrop().

get_opclass_oid()

Oid get_opclass_oid	(	Oid	amID,
		List *	opclassname,
		bool	missing_ok
	)

Definition at line 220 of file opclasscmds.c.

{
    HeapTuple   htup;
    Form_pg_opclass opcform;
    Oid         opcID;
 
    htup = OpClassCacheLookup(amID, opclassname, missing_ok);
    if (!HeapTupleIsValid(htup))
        return InvalidOid;
    opcform = (Form_pg_opclass) GETSTRUCT(htup);
    opcID = opcform->oid;
    ReleaseSysCache(htup);
 
    return opcID;
}

References GETSTRUCT, HeapTupleIsValid, InvalidOid, OpClassCacheLookup(), and ReleaseSysCache().

Referenced by findRangeSubOpclass(), get_object_address_opcf(), and resolve_unique_index_expr().

get_opfamily_oid()

Oid get_opfamily_oid	(	Oid	amID,
		List *	opfamilyname,
		bool	missing_ok
	)

Definition at line 139 of file opclasscmds.c.

{
    HeapTuple   htup;
    Form_pg_opfamily opfamform;
    Oid         opfID;
 
    htup = OpFamilyCacheLookup(amID, opfamilyname, missing_ok);
    if (!HeapTupleIsValid(htup))
        return InvalidOid;
    opfamform = (Form_pg_opfamily) GETSTRUCT(htup);
    opfID = opfamform->oid;
    ReleaseSysCache(htup);
 
    return opfID;
}

References GETSTRUCT, HeapTupleIsValid, InvalidOid, OpFamilyCacheLookup(), and ReleaseSysCache().

Referenced by AlterOpFamily(), AlterOpFamilyAdd(), DefineOpClass(), and get_object_address_opcf().

IsThereOpClassInNamespace()

void IsThereOpClassInNamespace	(	const char *	opcname,
		Oid	opcmethod,
		Oid	opcnamespace
	)

Definition at line 1708 of file opclasscmds.c.

{
    /* make sure the new name doesn't exist */
    if (SearchSysCacheExists3(CLAAMNAMENSP,
                              ObjectIdGetDatum(opcmethod),
                              CStringGetDatum(opcname),
                              ObjectIdGetDatum(opcnamespace)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("operator class \"%s\" for access method \"%s\" already exists in schema \"%s\"",
                        opcname,
                        get_am_name(opcmethod),
                        get_namespace_name(opcnamespace))));
}

References CLAAMNAMENSP, CStringGetDatum(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, get_am_name(), get_namespace_name(), ObjectIdGetDatum(), and SearchSysCacheExists3.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

IsThereOpFamilyInNamespace()

void IsThereOpFamilyInNamespace	(	const char *	opfname,
		Oid	opfmethod,
		Oid	opfnamespace
	)

Definition at line 1731 of file opclasscmds.c.

{
    /* make sure the new name doesn't exist */
    if (SearchSysCacheExists3(OPFAMILYAMNAMENSP,
                              ObjectIdGetDatum(opfmethod),
                              CStringGetDatum(opfname),
                              ObjectIdGetDatum(opfnamespace)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("operator family \"%s\" for access method \"%s\" already exists in schema \"%s\"",
                        opfname,
                        get_am_name(opfmethod),
                        get_namespace_name(opfnamespace))));
}

References CStringGetDatum(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, get_am_name(), get_namespace_name(), ObjectIdGetDatum(), OPFAMILYAMNAMENSP, and SearchSysCacheExists3.

Referenced by AlterObjectNamespace_internal(), and AlterObjectRename_internal().

OpClassCacheLookup()

static HeapTuple OpClassCacheLookup ( Oid  amID, List *  opclassname, bool  missing_ok  )

static

Definition at line 162 of file opclasscmds.c.

{
    char       *schemaname;
    char       *opcname;
    HeapTuple   htup;
 
    /* deconstruct the name list */
    DeconstructQualifiedName(opclassname, &schemaname, &opcname);
 
    if (schemaname)
    {
        /* Look in specific schema only */
        Oid         namespaceId;
 
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (!OidIsValid(namespaceId))
            htup = NULL;
        else
            htup = SearchSysCache3(CLAAMNAMENSP,
                                   ObjectIdGetDatum(amID),
                                   PointerGetDatum(opcname),
                                   ObjectIdGetDatum(namespaceId));
    }
    else
    {
        /* Unqualified opclass name, so search the search path */
        Oid         opcID = OpclassnameGetOpcid(amID, opcname);
 
        if (!OidIsValid(opcID))
            htup = NULL;
        else
            htup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opcID));
    }
 
    if (!HeapTupleIsValid(htup) && !missing_ok)
    {
        HeapTuple   amtup;
 
        amtup = SearchSysCache1(AMOID, ObjectIdGetDatum(amID));
        if (!HeapTupleIsValid(amtup))
            elog(ERROR, "cache lookup failed for access method %u", amID);
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("operator class \"%s\" does not exist for access method \"%s\"",
                        NameListToString(opclassname),
                        NameStr(((Form_pg_am) GETSTRUCT(amtup))->amname))));
    }
 
    return htup;
}

References AMOID, CLAAMNAMENSP, CLAOID, DeconstructQualifiedName(), elog(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, LookupExplicitNamespace(), NameListToString(), NameStr, ObjectIdGetDatum(), OidIsValid, OpclassnameGetOpcid(), PointerGetDatum(), SearchSysCache1(), and SearchSysCache3().

Referenced by get_opclass_oid().

OpFamilyCacheLookup()

static HeapTuple OpFamilyCacheLookup ( Oid  amID, List *  opfamilyname, bool  missing_ok  )

static

Definition at line 81 of file opclasscmds.c.

{
    char       *schemaname;
    char       *opfname;
    HeapTuple   htup;
 
    /* deconstruct the name list */
    DeconstructQualifiedName(opfamilyname, &schemaname, &opfname);
 
    if (schemaname)
    {
        /* Look in specific schema only */
        Oid         namespaceId;
 
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (!OidIsValid(namespaceId))
            htup = NULL;
        else
            htup = SearchSysCache3(OPFAMILYAMNAMENSP,
                                   ObjectIdGetDatum(amID),
                                   PointerGetDatum(opfname),
                                   ObjectIdGetDatum(namespaceId));
    }
    else
    {
        /* Unqualified opfamily name, so search the search path */
        Oid         opfID = OpfamilynameGetOpfid(amID, opfname);
 
        if (!OidIsValid(opfID))
            htup = NULL;
        else
            htup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfID));
    }
 
    if (!HeapTupleIsValid(htup) && !missing_ok)
    {
        HeapTuple   amtup;
 
        amtup = SearchSysCache1(AMOID, ObjectIdGetDatum(amID));
        if (!HeapTupleIsValid(amtup))
            elog(ERROR, "cache lookup failed for access method %u", amID);
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("operator family \"%s\" does not exist for access method \"%s\"",
                        NameListToString(opfamilyname),
                        NameStr(((Form_pg_am) GETSTRUCT(amtup))->amname))));
    }
 
    return htup;
}

References AMOID, DeconstructQualifiedName(), elog(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, LookupExplicitNamespace(), NameListToString(), NameStr, ObjectIdGetDatum(), OidIsValid, OPFAMILYAMNAMENSP, OpfamilynameGetOpfid(), OPFAMILYOID, PointerGetDatum(), SearchSysCache1(), and SearchSysCache3().

Referenced by get_opfamily_oid().

processTypesSpec()

static void processTypesSpec ( List *  args, Oid *  lefttype, Oid *  righttype  )

static

Definition at line 1108 of file opclasscmds.c.

{
    TypeName   *typeName;
 
    Assert(args != NIL);
 
    typeName = (TypeName *) linitial(args);
    *lefttype = typenameTypeId(NULL, typeName);
 
    if (list_length(args) > 1)
    {
        typeName = (TypeName *) lsecond(args);
        *righttype = typenameTypeId(NULL, typeName);
    }
    else
        *righttype = *lefttype;
 
    if (list_length(args) > 2)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("one or two argument types must be specified")));
}

References generate_unaccent_rules::args, Assert(), ereport, errcode(), errmsg(), ERROR, linitial, list_length(), lsecond, NIL, and typenameTypeId().

Referenced by AlterOpFamilyAdd(), AlterOpFamilyDrop(), and DefineOpClass().

storeOperators()

static void storeOperators ( List *  opfamilyname, Oid  amoid, Oid  opfamilyoid, List *  operators, bool  isAdd  )

static

Definition at line 1429 of file opclasscmds.c.

{
    Relation    rel;
    Datum       values[Natts_pg_amop];
    bool        nulls[Natts_pg_amop];
    HeapTuple   tup;
    Oid         entryoid;
    ObjectAddress myself,
                referenced;
    ListCell   *l;
 
    rel = table_open(AccessMethodOperatorRelationId, RowExclusiveLock);
 
    foreach(l, operators)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(l);
        char        oppurpose;
 
        /*
         * If adding to an existing family, check for conflict with an
         * existing pg_amop entry (just to give a nicer error message)
         */
        if (isAdd &&
            SearchSysCacheExists4(AMOPSTRATEGY,
                                  ObjectIdGetDatum(opfamilyoid),
                                  ObjectIdGetDatum(op->lefttype),
                                  ObjectIdGetDatum(op->righttype),
                                  Int16GetDatum(op->number)))
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("operator %d(%s,%s) already exists in operator family \"%s\"",
                            op->number,
                            format_type_be(op->lefttype),
                            format_type_be(op->righttype),
                            NameListToString(opfamilyname))));
 
        oppurpose = OidIsValid(op->sortfamily) ? AMOP_ORDER : AMOP_SEARCH;
 
        /* Create the pg_amop entry */
        memset(values, 0, sizeof(values));
        memset(nulls, false, sizeof(nulls));
 
        entryoid = GetNewOidWithIndex(rel, AccessMethodOperatorOidIndexId,
                                      Anum_pg_amop_oid);
        values[Anum_pg_amop_oid - 1] = ObjectIdGetDatum(entryoid);
        values[Anum_pg_amop_amopfamily - 1] = ObjectIdGetDatum(opfamilyoid);
        values[Anum_pg_amop_amoplefttype - 1] = ObjectIdGetDatum(op->lefttype);
        values[Anum_pg_amop_amoprighttype - 1] = ObjectIdGetDatum(op->righttype);
        values[Anum_pg_amop_amopstrategy - 1] = Int16GetDatum(op->number);
        values[Anum_pg_amop_amoppurpose - 1] = CharGetDatum(oppurpose);
        values[Anum_pg_amop_amopopr - 1] = ObjectIdGetDatum(op->object);
        values[Anum_pg_amop_amopmethod - 1] = ObjectIdGetDatum(amoid);
        values[Anum_pg_amop_amopsortfamily - 1] = ObjectIdGetDatum(op->sortfamily);
 
        tup = heap_form_tuple(rel->rd_att, values, nulls);
 
        CatalogTupleInsert(rel, tup);
 
        heap_freetuple(tup);
 
        /* Make its dependencies */
        myself.classId = AccessMethodOperatorRelationId;
        myself.objectId = entryoid;
        myself.objectSubId = 0;
 
        referenced.classId = OperatorRelationId;
        referenced.objectId = op->object;
        referenced.objectSubId = 0;
 
        /* see comments in amapi.h about dependency strength */
        recordDependencyOn(&myself, &referenced,
                           op->ref_is_hard ? DEPENDENCY_NORMAL : DEPENDENCY_AUTO);
 
        referenced.classId = op->ref_is_family ? OperatorFamilyRelationId :
            OperatorClassRelationId;
        referenced.objectId = op->refobjid;
        referenced.objectSubId = 0;
 
        recordDependencyOn(&myself, &referenced,
                           op->ref_is_hard ? DEPENDENCY_INTERNAL : DEPENDENCY_AUTO);
 
        /* A search operator also needs a dep on the referenced opfamily */
        if (OidIsValid(op->sortfamily))
        {
            referenced.classId = OperatorFamilyRelationId;
            referenced.objectId = op->sortfamily;
            referenced.objectSubId = 0;
 
            recordDependencyOn(&myself, &referenced,
                               op->ref_is_hard ? DEPENDENCY_NORMAL : DEPENDENCY_AUTO);
        }
 
        /* Post create hook of this access method operator */
        InvokeObjectPostCreateHook(AccessMethodOperatorRelationId,
                                   entryoid, 0);
    }
 
    table_close(rel, RowExclusiveLock);
}

References AMOPSTRATEGY, CatalogTupleInsert(), CharGetDatum(), ObjectAddress::classId, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, DEPENDENCY_NORMAL, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, format_type_be(), GetNewOidWithIndex(), heap_form_tuple(), heap_freetuple(), Int16GetDatum(), InvokeObjectPostCreateHook, OpFamilyMember::lefttype, lfirst, NameListToString(), OpFamilyMember::number, OpFamilyMember::object, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, RelationData::rd_att, recordDependencyOn(), OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, OpFamilyMember::refobjid, OpFamilyMember::righttype, RowExclusiveLock, SearchSysCacheExists4, OpFamilyMember::sortfamily, table_close(), table_open(), and values.

Referenced by AlterOpFamilyAdd(), and DefineOpClass().

storeProcedures()

static void storeProcedures ( List *  opfamilyname, Oid  amoid, Oid  opfamilyoid, List *  procedures, bool  isAdd  )

static

Definition at line 1536 of file opclasscmds.c.

{
    Relation    rel;
    Datum       values[Natts_pg_amproc];
    bool        nulls[Natts_pg_amproc];
    HeapTuple   tup;
    Oid         entryoid;
    ObjectAddress myself,
                referenced;
    ListCell   *l;
 
    rel = table_open(AccessMethodProcedureRelationId, RowExclusiveLock);
 
    foreach(l, procedures)
    {
        OpFamilyMember *proc = (OpFamilyMember *) lfirst(l);
 
        /*
         * If adding to an existing family, check for conflict with an
         * existing pg_amproc entry (just to give a nicer error message)
         */
        if (isAdd &&
            SearchSysCacheExists4(AMPROCNUM,
                                  ObjectIdGetDatum(opfamilyoid),
                                  ObjectIdGetDatum(proc->lefttype),
                                  ObjectIdGetDatum(proc->righttype),
                                  Int16GetDatum(proc->number)))
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("function %d(%s,%s) already exists in operator family \"%s\"",
                            proc->number,
                            format_type_be(proc->lefttype),
                            format_type_be(proc->righttype),
                            NameListToString(opfamilyname))));
 
        /* Create the pg_amproc entry */
        memset(values, 0, sizeof(values));
        memset(nulls, false, sizeof(nulls));
 
        entryoid = GetNewOidWithIndex(rel, AccessMethodProcedureOidIndexId,
                                      Anum_pg_amproc_oid);
        values[Anum_pg_amproc_oid - 1] = ObjectIdGetDatum(entryoid);
        values[Anum_pg_amproc_amprocfamily - 1] = ObjectIdGetDatum(opfamilyoid);
        values[Anum_pg_amproc_amproclefttype - 1] = ObjectIdGetDatum(proc->lefttype);
        values[Anum_pg_amproc_amprocrighttype - 1] = ObjectIdGetDatum(proc->righttype);
        values[Anum_pg_amproc_amprocnum - 1] = Int16GetDatum(proc->number);
        values[Anum_pg_amproc_amproc - 1] = ObjectIdGetDatum(proc->object);
 
        tup = heap_form_tuple(rel->rd_att, values, nulls);
 
        CatalogTupleInsert(rel, tup);
 
        heap_freetuple(tup);
 
        /* Make its dependencies */
        myself.classId = AccessMethodProcedureRelationId;
        myself.objectId = entryoid;
        myself.objectSubId = 0;
 
        referenced.classId = ProcedureRelationId;
        referenced.objectId = proc->object;
        referenced.objectSubId = 0;
 
        /* see comments in amapi.h about dependency strength */
        recordDependencyOn(&myself, &referenced,
                           proc->ref_is_hard ? DEPENDENCY_NORMAL : DEPENDENCY_AUTO);
 
        referenced.classId = proc->ref_is_family ? OperatorFamilyRelationId :
            OperatorClassRelationId;
        referenced.objectId = proc->refobjid;
        referenced.objectSubId = 0;
 
        recordDependencyOn(&myself, &referenced,
                           proc->ref_is_hard ? DEPENDENCY_INTERNAL : DEPENDENCY_AUTO);
 
        /* Post create hook of access method procedure */
        InvokeObjectPostCreateHook(AccessMethodProcedureRelationId,
                                   entryoid, 0);
    }
 
    table_close(rel, RowExclusiveLock);
}

References AMPROCNUM, CatalogTupleInsert(), ObjectAddress::classId, DEPENDENCY_AUTO, DEPENDENCY_INTERNAL, DEPENDENCY_NORMAL, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, format_type_be(), GetNewOidWithIndex(), heap_form_tuple(), heap_freetuple(), Int16GetDatum(), InvokeObjectPostCreateHook, OpFamilyMember::lefttype, lfirst, NameListToString(), OpFamilyMember::number, OpFamilyMember::object, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, RelationData::rd_att, recordDependencyOn(), OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, OpFamilyMember::refobjid, OpFamilyMember::righttype, RowExclusiveLock, SearchSysCacheExists4, table_close(), table_open(), and values.

Referenced by AlterOpFamilyAdd(), and DefineOpClass().