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, pg_operator, btree(oid oid_ops))
	DECLARE_UNIQUE_INDEX (pg_operator_oprname_l_r_n_index, 2689, OperatorNameNspIndexId, pg_operator, btree(oprname name_ops, oprleft oid_ops, oprright oid_ops, oprnamespace oid_ops))
	MAKE_SYSCACHE (OPEROID, pg_operator_oid_index, 32)
	MAKE_SYSCACHE (OPERNAMENSP, pg_operator_oprname_l_r_n_index, 256)
Oid	OperatorLookup (List *operatorName, Oid leftObjectId, Oid rightObjectId, bool *defined)
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	OperatorValidateParams (Oid leftTypeId, Oid rightTypeId, Oid operResultType, bool hasCommutator, bool hasNegator, bool hasRestrictionSelectivity, bool hasJoinSelectivity, bool canMerge, bool canHash)
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	,
		pg_operator	,
		btree(oprname 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	,
		pg_operator	,
		btree(oid oid_ops)
	)

MAKE_SYSCACHE() [1/2]

MAKE_SYSCACHE	(	OPERNAMENSP	,
		pg_operator_oprname_l_r_n_index	,
		256
	)

MAKE_SYSCACHE() [2/2]

MAKE_SYSCACHE	(	OPEROID	,
		pg_operator_oid_index	,
		32
	)

makeOperatorDependencies()

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

Definition at line 853 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 321 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)));
 
    operResultType = get_func_rettype(procedureId);
 
    OperatorValidateParams(leftTypeId,
                           rightTypeId,
                           operResultType,
                           commutatorName != NIL,
                           negatorName != NIL,
                           OidIsValid(restrictionId),
                           OidIsValid(joinId),
                           canMerge,
                           canHash);
 
    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);
 
        /* Permission check: must own other operator */
        if (OidIsValid(commutatorId) &&
            !object_ownercheck(OperatorRelationId, commutatorId, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                           NameListToString(commutatorName));
 
        /*
         * If self-linkage to the new operator is requested, we'll fix it
         * below.  (In case of self-linkage to an existing shell operator, we
         * need do nothing special.)
         */
        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);
 
        /* Permission check: must own other operator */
        if (OidIsValid(negatorId) &&
            !object_ownercheck(OperatorRelationId, negatorId, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                           NameListToString(negatorName));
 
        /*
         * Prevent self negation, as it doesn't make sense.  It's self
         * negation if result is InvalidOid (negator would be the same
         * operator but it doesn't exist yet) or operatorObjectId (we are
         * replacing a shell that would need to be its own negator).
         */
        if (!OidIsValid(negatorId) || negatorId == operatorObjectId)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("operator cannot be its own negator")));
    }
    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);
 
    /*
     * 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);
 
    /* Post creation hook for new operator */
    InvokeObjectPostCreateHook(OperatorRelationId, operatorObjectId, 0);
 
    table_close(pg_operator_desc, RowExclusiveLock);
 
    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(), NIL, OBJECT_OPERATOR, object_ownercheck(), ObjectIdGetDatum(), OidIsValid, OperatorGet(), OperatorUpd(), OperatorValidateParams(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), table_open(), validOperatorName(), and values.

Referenced by DefineOperator().

OperatorLookup()

Oid OperatorLookup	(	List *	operatorName,
		Oid	leftObjectId,
		Oid	rightObjectId,
		bool *	defined
	)

Definition at line 164 of file pg_operator.c.

{
    Oid         operatorObjectId;
    RegProcedure oprcode;
 
    operatorObjectId = LookupOperName(NULL, operatorName,
                                      leftObjectId, rightObjectId,
                                      true, -1);
    if (!OidIsValid(operatorObjectId))
    {
        *defined = false;
        return InvalidOid;
    }
 
    oprcode = get_opcode(operatorObjectId);
    *defined = RegProcedureIsValid(oprcode);
 
    return operatorObjectId;
}

References get_opcode(), InvalidOid, LookupOperName(), OidIsValid, and RegProcedureIsValid.

Referenced by get_other_operator(), and ValidateOperatorReference().

OperatorUpd()

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

Definition at line 684 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;
 
        /*
         * We can skip doing anything if the commutator's oprcom field is
         * already what we want.  While that's not expected in the isDelete
         * case, it's perfectly possible when filling in a shell operator.
         */
        if (isDelete && OidIsValid(t->oprcom))
        {
            t->oprcom = InvalidOid;
            update_commutator = true;
        }
        else if (!isDelete && t->oprcom != baseId)
        {
            /*
             * If commutator's oprcom field is already set to point to some
             * third operator, it's an error.  Changing its link would be
             * unsafe, and letting the inconsistency stand would not be good
             * either.  This might be indicative of catalog corruption, so
             * don't assume t->oprcom is necessarily a valid operator.
             */
            if (OidIsValid(t->oprcom))
            {
                char       *thirdop = get_opname(t->oprcom);
 
                if (thirdop != NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("commutator operator %s is already the commutator of operator %s",
                                    NameStr(t->oprname), thirdop)));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("commutator operator %s is already the commutator of operator %u",
                                    NameStr(t->oprname), 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;
 
        /*
         * We can skip doing anything if the negator's oprnegate field is
         * already what we want.  While that's not expected in the isDelete
         * case, it's perfectly possible when filling in a shell operator.
         */
        if (isDelete && OidIsValid(t->oprnegate))
        {
            t->oprnegate = InvalidOid;
            update_negator = true;
        }
        else if (!isDelete && t->oprnegate != baseId)
        {
            /*
             * If negator's oprnegate field is already set to point to some
             * third operator, it's an error.  Changing its link would be
             * unsafe, and letting the inconsistency stand would not be good
             * either.  This might be indicative of catalog corruption, so
             * don't assume t->oprnegate is necessarily a valid operator.
             */
            if (OidIsValid(t->oprnegate))
            {
                char       *thirdop = get_opname(t->oprnegate);
 
                if (thirdop != NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("negator operator %s is already the negator of operator %s",
                                    NameStr(t->oprname), thirdop)));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                             errmsg("negator operator %s is already the negator of operator %u",
                                    NameStr(t->oprname), 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(), ereport, errcode(), errmsg(), ERROR, get_opname(), GETSTRUCT, HeapTupleIsValid, InvalidOid, NameStr, ObjectIdGetDatum(), OidIsValid, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

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

OperatorValidateParams()

void OperatorValidateParams	(	Oid	leftTypeId,
		Oid	rightTypeId,
		Oid	operResultType,
		bool	hasCommutator,
		bool	hasNegator,
		bool	hasRestrictionSelectivity,
		bool	hasJoinSelectivity,
		bool	canMerge,
		bool	canHash
	)

Definition at line 556 of file pg_operator.c.

{
    if (!(OidIsValid(leftTypeId) && OidIsValid(rightTypeId)))
    {
        /* If it's not a binary op, these things mustn't be set: */
        if (hasCommutator)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only binary operators can have commutators")));
        if (hasJoinSelectivity)
            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")));
    }
 
    if (operResultType != BOOLOID)
    {
        /* If it's not a boolean op, these things mustn't be set: */
        if (hasNegator)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can have negators")));
        if (hasRestrictionSelectivity)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can have restriction selectivity")));
        if (hasJoinSelectivity)
            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")));
    }
}

References ereport, errcode(), errmsg(), ERROR, and OidIsValid.

Referenced by AlterOperator(), and OperatorCreate().

Variable Documentation

FormData_pg_operator

FormData_pg_operator

Definition at line 76 of file pg_operator.h.