pg_operator.h File Reference

#include "catalog/genbki.h"
#include "catalog/objectaddress.h"
#include "catalog/pg_operator_d.h"
#include "nodes/pg_list.h"

Include dependency graph for pg_operator.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef FormData_pg_operator *	Form_pg_operator

Functions
	CATALOG (pg_operator, 2617, OperatorRelationId)
	DECLARE_UNIQUE_INDEX_PKEY (pg_operator_oid_index, 2688, OperatorOidIndexId, on pg_operator using btree(oid oid_ops))
	DECLARE_UNIQUE_INDEX (pg_operator_oprname_l_r_n_index, 2689, OperatorNameNspIndexId, on pg_operator using btree(oprname name_ops, oprleft oid_ops, oprright oid_ops, oprnamespace oid_ops))
ObjectAddress	OperatorCreate (const char *operatorName, Oid operatorNamespace, Oid leftTypeId, Oid rightTypeId, Oid procedureId, List *commutatorName, List *negatorName, Oid restrictionId, Oid joinId, bool canMerge, bool canHash)
ObjectAddress	makeOperatorDependencies (HeapTuple tuple, bool makeExtensionDep, bool isUpdate)
void	OperatorUpd (Oid baseId, Oid commId, Oid negId, bool isDelete)

Variables
	FormData_pg_operator

Typedef Documentation

Form_pg_operator

typedef FormData_pg_operator* Form_pg_operator

Definition at line 83 of file pg_operator.h.

Function Documentation

CATALOG()

CATALOG	(	pg_operator	,
		2617	,
		OperatorRelationId
	)

Definition at line 31 of file pg_operator.h.

{
    Oid         oid;            /* oid */
 
    /* name of operator */
    NameData    oprname;
 
    /* OID of namespace containing this oper */
    Oid         oprnamespace BKI_DEFAULT(pg_catalog) BKI_LOOKUP(pg_namespace);
 
    /* operator owner */
    Oid         oprowner BKI_DEFAULT(POSTGRES) BKI_LOOKUP(pg_authid);
 
    /* 'l' for prefix or 'b' for infix */
    char        oprkind BKI_DEFAULT(b);
 
    /* can be used in merge join? */
    bool        oprcanmerge BKI_DEFAULT(f);
 
    /* can be used in hash join? */
    bool        oprcanhash BKI_DEFAULT(f);
 
    /* left arg type, or 0 if prefix operator */
    Oid         oprleft BKI_LOOKUP_OPT(pg_type);
 
    /* right arg type */
    Oid         oprright BKI_LOOKUP(pg_type);
 
    /* result datatype; can be 0 in a "shell" operator */
    Oid         oprresult BKI_LOOKUP_OPT(pg_type);
 
    /* OID of commutator oper, or 0 if none */
    Oid         oprcom BKI_DEFAULT(0) BKI_LOOKUP_OPT(pg_operator);
 
    /* OID of negator oper, or 0 if none */
    Oid         oprnegate BKI_DEFAULT(0) BKI_LOOKUP_OPT(pg_operator);
 
    /* OID of underlying function; can be 0 in a "shell" operator */
    regproc     oprcode BKI_LOOKUP_OPT(pg_proc);
 
    /* OID of restriction estimator, or 0 */
    regproc     oprrest BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
 
    /* OID of join estimator, or 0 */
    regproc     oprjoin BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
} FormData_pg_operator;

References b, BKI_DEFAULT, BKI_LOOKUP, and BKI_LOOKUP_OPT.

DECLARE_UNIQUE_INDEX()

DECLARE_UNIQUE_INDEX	(	pg_operator_oprname_l_r_n_index	,
		2689	,
		OperatorNameNspIndexId	,
		on pg_operator using	btreeoprname name_ops, oprleft oid_ops, oprright oid_ops, oprnamespace oid_ops
	)

DECLARE_UNIQUE_INDEX_PKEY()

DECLARE_UNIQUE_INDEX_PKEY	(	pg_operator_oid_index	,
		2688	,
		OperatorOidIndexId	,
		on pg_operator using	btreeoid oid_ops
	)

makeOperatorDependencies()

ObjectAddress makeOperatorDependencies	(	HeapTuple	tuple,
		bool	makeExtensionDep,
		bool	isUpdate
	)

Definition at line 777 of file pg_operator.c.

{
    Form_pg_operator oper = (Form_pg_operator) GETSTRUCT(tuple);
    ObjectAddress myself,
                referenced;
    ObjectAddresses *addrs;
 
    ObjectAddressSet(myself, OperatorRelationId, oper->oid);
 
    /*
     * If we are updating the operator, delete any existing entries, except
     * for extension membership which should remain the same.
     */
    if (isUpdate)
    {
        deleteDependencyRecordsFor(myself.classId, myself.objectId, true);
        deleteSharedDependencyRecordsFor(myself.classId, myself.objectId, 0);
    }
 
    addrs = new_object_addresses();
 
    /* Dependency on namespace */
    if (OidIsValid(oper->oprnamespace))
    {
        ObjectAddressSet(referenced, NamespaceRelationId, oper->oprnamespace);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Dependency on left type */
    if (OidIsValid(oper->oprleft))
    {
        ObjectAddressSet(referenced, TypeRelationId, oper->oprleft);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Dependency on right type */
    if (OidIsValid(oper->oprright))
    {
        ObjectAddressSet(referenced, TypeRelationId, oper->oprright);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Dependency on result type */
    if (OidIsValid(oper->oprresult))
    {
        ObjectAddressSet(referenced, TypeRelationId, oper->oprresult);
        add_exact_object_address(&referenced, addrs);
    }
 
    /*
     * NOTE: we do not consider the operator to depend on the associated
     * operators oprcom and oprnegate.  We do not want to delete this operator
     * if those go away, but only reset the link fields; which is not a
     * function that the dependency logic can handle.  (It's taken care of
     * manually within RemoveOperatorById, instead.)
     */
 
    /* Dependency on implementation function */
    if (OidIsValid(oper->oprcode))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, oper->oprcode);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Dependency on restriction selectivity function */
    if (OidIsValid(oper->oprrest))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, oper->oprrest);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Dependency on join selectivity function */
    if (OidIsValid(oper->oprjoin))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, oper->oprjoin);
        add_exact_object_address(&referenced, addrs);
    }
 
    record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
    free_object_addresses(addrs);
 
    /* Dependency on owner */
    recordDependencyOnOwner(OperatorRelationId, oper->oid,
                            oper->oprowner);
 
    /* Dependency on extension */
    if (makeExtensionDep)
        recordDependencyOnCurrentExtension(&myself, isUpdate);
 
    return myself;
}

References add_exact_object_address(), ObjectAddress::classId, deleteDependencyRecordsFor(), deleteSharedDependencyRecordsFor(), DEPENDENCY_NORMAL, free_object_addresses(), GETSTRUCT, new_object_addresses(), ObjectAddressSet, ObjectAddress::objectId, OidIsValid, oper(), record_object_address_dependencies(), recordDependencyOnCurrentExtension(), and recordDependencyOnOwner().

Referenced by AlterOperator(), OperatorCreate(), and OperatorShellMake().

OperatorCreate()

ObjectAddress OperatorCreate	(	const char *	operatorName,
		Oid	operatorNamespace,
		Oid	leftTypeId,
		Oid	rightTypeId,
		Oid	procedureId,
		List *	commutatorName,
		List *	negatorName,
		Oid	restrictionId,
		Oid	joinId,
		bool	canMerge,
		bool	canHash
	)

Definition at line 327 of file pg_operator.c.

{
    Relation    pg_operator_desc;
    HeapTuple   tup;
    bool        isUpdate;
    bool        nulls[Natts_pg_operator];
    bool        replaces[Natts_pg_operator];
    Datum       values[Natts_pg_operator];
    Oid         operatorObjectId;
    bool        operatorAlreadyDefined;
    Oid         operResultType;
    Oid         commutatorId,
                negatorId;
    bool        selfCommutator = false;
    NameData    oname;
    int         i;
    ObjectAddress address;
 
    /*
     * Sanity checks
     */
    if (!validOperatorName(operatorName))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("\"%s\" is not a valid operator name",
                        operatorName)));
 
    if (!(OidIsValid(leftTypeId) && OidIsValid(rightTypeId)))
    {
        /* If it's not a binary op, these things mustn't be set: */
        if (commutatorName)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only binary operators can have commutators")));
        if (OidIsValid(joinId))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only binary operators can have join selectivity")));
        if (canMerge)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only binary operators can merge join")));
        if (canHash)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only binary operators can hash")));
    }
 
    operResultType = get_func_rettype(procedureId);
 
    if (operResultType != BOOLOID)
    {
        /* If it's not a boolean op, these things mustn't be set: */
        if (negatorName)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can have negators")));
        if (OidIsValid(restrictionId))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can have restriction selectivity")));
        if (OidIsValid(joinId))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can have join selectivity")));
        if (canMerge)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can merge join")));
        if (canHash)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can hash")));
    }
 
    operatorObjectId = OperatorGet(operatorName,
                                   operatorNamespace,
                                   leftTypeId,
                                   rightTypeId,
                                   &operatorAlreadyDefined);
 
    if (operatorAlreadyDefined)
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_FUNCTION),
                 errmsg("operator %s already exists",
                        operatorName)));
 
    /*
     * At this point, if operatorObjectId is not InvalidOid then we are
     * filling in a previously-created shell.  Insist that the user own any
     * such shell.
     */
    if (OidIsValid(operatorObjectId) &&
        !object_ownercheck(OperatorRelationId, operatorObjectId, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                       operatorName);
 
    /*
     * Set up the other operators.  If they do not currently exist, create
     * shells in order to get ObjectId's.
     */
 
    if (commutatorName)
    {
        /* commutator has reversed arg types */
        commutatorId = get_other_operator(commutatorName,
                                          rightTypeId, leftTypeId,
                                          operatorName, operatorNamespace,
                                          leftTypeId, rightTypeId,
                                          true);
 
        /* Permission check: must own other operator */
        if (OidIsValid(commutatorId) &&
            !object_ownercheck(OperatorRelationId, commutatorId, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                           NameListToString(commutatorName));
 
        /*
         * self-linkage to this operator; will fix below. Note that only
         * self-linkage for commutation makes sense.
         */
        if (!OidIsValid(commutatorId))
            selfCommutator = true;
    }
    else
        commutatorId = InvalidOid;
 
    if (negatorName)
    {
        /* negator has same arg types */
        negatorId = get_other_operator(negatorName,
                                       leftTypeId, rightTypeId,
                                       operatorName, operatorNamespace,
                                       leftTypeId, rightTypeId,
                                       false);
 
        /* Permission check: must own other operator */
        if (OidIsValid(negatorId) &&
            !object_ownercheck(OperatorRelationId, negatorId, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                           NameListToString(negatorName));
    }
    else
        negatorId = InvalidOid;
 
    /*
     * set up values in the operator tuple
     */
 
    for (i = 0; i < Natts_pg_operator; ++i)
    {
        values[i] = (Datum) NULL;
        replaces[i] = true;
        nulls[i] = false;
    }
 
    namestrcpy(&oname, operatorName);
    values[Anum_pg_operator_oprname - 1] = NameGetDatum(&oname);
    values[Anum_pg_operator_oprnamespace - 1] = ObjectIdGetDatum(operatorNamespace);
    values[Anum_pg_operator_oprowner - 1] = ObjectIdGetDatum(GetUserId());
    values[Anum_pg_operator_oprkind - 1] = CharGetDatum(leftTypeId ? 'b' : 'l');
    values[Anum_pg_operator_oprcanmerge - 1] = BoolGetDatum(canMerge);
    values[Anum_pg_operator_oprcanhash - 1] = BoolGetDatum(canHash);
    values[Anum_pg_operator_oprleft - 1] = ObjectIdGetDatum(leftTypeId);
    values[Anum_pg_operator_oprright - 1] = ObjectIdGetDatum(rightTypeId);
    values[Anum_pg_operator_oprresult - 1] = ObjectIdGetDatum(operResultType);
    values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(commutatorId);
    values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(negatorId);
    values[Anum_pg_operator_oprcode - 1] = ObjectIdGetDatum(procedureId);
    values[Anum_pg_operator_oprrest - 1] = ObjectIdGetDatum(restrictionId);
    values[Anum_pg_operator_oprjoin - 1] = ObjectIdGetDatum(joinId);
 
    pg_operator_desc = table_open(OperatorRelationId, RowExclusiveLock);
 
    /*
     * If we are replacing an operator shell, update; else insert
     */
    if (operatorObjectId)
    {
        isUpdate = true;
 
        tup = SearchSysCacheCopy1(OPEROID,
                                  ObjectIdGetDatum(operatorObjectId));
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for operator %u",
                 operatorObjectId);
 
        replaces[Anum_pg_operator_oid - 1] = false;
        tup = heap_modify_tuple(tup,
                                RelationGetDescr(pg_operator_desc),
                                values,
                                nulls,
                                replaces);
 
        CatalogTupleUpdate(pg_operator_desc, &tup->t_self, tup);
    }
    else
    {
        isUpdate = false;
 
        operatorObjectId = GetNewOidWithIndex(pg_operator_desc,
                                              OperatorOidIndexId,
                                              Anum_pg_operator_oid);
        values[Anum_pg_operator_oid - 1] = ObjectIdGetDatum(operatorObjectId);
 
        tup = heap_form_tuple(RelationGetDescr(pg_operator_desc),
                              values, nulls);
 
        CatalogTupleInsert(pg_operator_desc, tup);
    }
 
    /* Add dependencies for the entry */
    address = makeOperatorDependencies(tup, true, isUpdate);
 
    /* Post creation hook for new operator */
    InvokeObjectPostCreateHook(OperatorRelationId, operatorObjectId, 0);
 
    table_close(pg_operator_desc, RowExclusiveLock);
 
    /*
     * If a commutator and/or negator link is provided, update the other
     * operator(s) to point at this one, if they don't already have a link.
     * This supports an alternative style of operator definition wherein the
     * user first defines one operator without giving negator or commutator,
     * then defines the other operator of the pair with the proper commutator
     * or negator attribute.  That style doesn't require creation of a shell,
     * and it's the only style that worked right before Postgres version 6.5.
     * This code also takes care of the situation where the new operator is
     * its own commutator.
     */
    if (selfCommutator)
        commutatorId = operatorObjectId;
 
    if (OidIsValid(commutatorId) || OidIsValid(negatorId))
        OperatorUpd(operatorObjectId, commutatorId, negatorId, false);
 
    return address;
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, BoolGetDatum(), CatalogTupleInsert(), CatalogTupleUpdate(), CharGetDatum(), elog(), ereport, errcode(), errmsg(), ERROR, get_func_rettype(), get_other_operator(), GetNewOidWithIndex(), GetUserId(), heap_form_tuple(), heap_modify_tuple(), HeapTupleIsValid, i, InvalidOid, InvokeObjectPostCreateHook, makeOperatorDependencies(), NameGetDatum(), NameListToString(), namestrcpy(), OBJECT_OPERATOR, object_ownercheck(), ObjectIdGetDatum(), OidIsValid, OperatorGet(), OperatorUpd(), OPEROID, RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), table_open(), validOperatorName(), and values.

Referenced by DefineOperator().

OperatorUpd()

void OperatorUpd	(	Oid	baseId,
		Oid	commId,
		Oid	negId,
		bool	isDelete
	)

Definition at line 654 of file pg_operator.c.

{
    Relation    pg_operator_desc;
    HeapTuple   tup;
 
    /*
     * If we're making an operator into its own commutator, then we need a
     * command-counter increment here, since we've just inserted the tuple
     * we're about to update.  But when we're dropping an operator, we can
     * skip this because we're at the beginning of the command.
     */
    if (!isDelete)
        CommandCounterIncrement();
 
    /* Open the relation. */
    pg_operator_desc = table_open(OperatorRelationId, RowExclusiveLock);
 
    /* Get a writable copy of the commutator's tuple. */
    if (OidIsValid(commId))
        tup = SearchSysCacheCopy1(OPEROID, ObjectIdGetDatum(commId));
    else
        tup = NULL;
 
    /* Update the commutator's tuple if need be. */
    if (HeapTupleIsValid(tup))
    {
        Form_pg_operator t = (Form_pg_operator) GETSTRUCT(tup);
        bool        update_commutator = false;
 
        /*
         * Out of due caution, we only change the commutator's oprcom field if
         * it has the exact value we expected: InvalidOid when creating an
         * operator, or baseId when dropping one.
         */
        if (isDelete && t->oprcom == baseId)
        {
            t->oprcom = InvalidOid;
            update_commutator = true;
        }
        else if (!isDelete && !OidIsValid(t->oprcom))
        {
            t->oprcom = baseId;
            update_commutator = true;
        }
 
        /* If any columns were found to need modification, update tuple. */
        if (update_commutator)
        {
            CatalogTupleUpdate(pg_operator_desc, &tup->t_self, tup);
 
            /*
             * Do CCI to make the updated tuple visible.  We must do this in
             * case the commutator is also the negator.  (Which would be a
             * logic error on the operator definer's part, but that's not a
             * good reason to fail here.)  We would need a CCI anyway in the
             * deletion case for a self-commutator with no negator.
             */
            CommandCounterIncrement();
        }
    }
 
    /*
     * Similarly find and update the negator, if any.
     */
    if (OidIsValid(negId))
        tup = SearchSysCacheCopy1(OPEROID, ObjectIdGetDatum(negId));
    else
        tup = NULL;
 
    if (HeapTupleIsValid(tup))
    {
        Form_pg_operator t = (Form_pg_operator) GETSTRUCT(tup);
        bool        update_negator = false;
 
        /*
         * Out of due caution, we only change the negator's oprnegate field if
         * it has the exact value we expected: InvalidOid when creating an
         * operator, or baseId when dropping one.
         */
        if (isDelete && t->oprnegate == baseId)
        {
            t->oprnegate = InvalidOid;
            update_negator = true;
        }
        else if (!isDelete && !OidIsValid(t->oprnegate))
        {
            t->oprnegate = baseId;
            update_negator = true;
        }
 
        /* If any columns were found to need modification, update tuple. */
        if (update_negator)
        {
            CatalogTupleUpdate(pg_operator_desc, &tup->t_self, tup);
 
            /*
             * In the deletion case, do CCI to make the updated tuple visible.
             * We must do this in case the operator is its own negator. (Which
             * would be a logic error on the operator definer's part, but
             * that's not a good reason to fail here.)
             */
            if (isDelete)
                CommandCounterIncrement();
        }
    }
 
    /* Close relation and release catalog lock. */
    table_close(pg_operator_desc, RowExclusiveLock);
}

References CatalogTupleUpdate(), CommandCounterIncrement(), GETSTRUCT, HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), OidIsValid, OPEROID, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by OperatorCreate(), and RemoveOperatorById().

Variable Documentation

FormData_pg_operator

FormData_pg_operator

Definition at line 76 of file pg_operator.h.