pg_operator.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "parser/parse_oper.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for pg_operator.c:

Go to the source code of this file.

Functions
static Oid	OperatorGet (const char *operatorName, Oid operatorNamespace, Oid leftObjectId, Oid rightObjectId, bool *defined)
static Oid	OperatorShellMake (const char *operatorName, Oid operatorNamespace, Oid leftTypeId, Oid rightTypeId)
static Oid	get_other_operator (List *otherOp, Oid otherLeftTypeId, Oid otherRightTypeId, const char *operatorName, Oid operatorNamespace, Oid leftTypeId, Oid rightTypeId)
static bool	validOperatorName (const char *name)
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)
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)
ObjectAddress	makeOperatorDependencies (HeapTuple tuple, bool makeExtensionDep, bool isUpdate)

Function Documentation

get_other_operator()

static Oid get_other_operator ( List *  otherOp, Oid  otherLeftTypeId, Oid  otherRightTypeId, const char *  operatorName, Oid  operatorNamespace, Oid  leftTypeId, Oid  rightTypeId  )

static

Definition at line 622 of file pg_operator.c.

{
    Oid         other_oid;
    bool        otherDefined;
    char       *otherName;
    Oid         otherNamespace;
    AclResult   aclresult;
 
    other_oid = OperatorLookup(otherOp,
                               otherLeftTypeId,
                               otherRightTypeId,
                               &otherDefined);
 
    if (OidIsValid(other_oid))
    {
        /* other op already in catalogs */
        return other_oid;
    }
 
    otherNamespace = QualifiedNameGetCreationNamespace(otherOp,
                                                       &otherName);
 
    if (strcmp(otherName, operatorName) == 0 &&
        otherNamespace == operatorNamespace &&
        otherLeftTypeId == leftTypeId &&
        otherRightTypeId == rightTypeId)
    {
        /* self-linkage to new operator; caller must handle this */
        return InvalidOid;
    }
 
    /* not in catalogs, different from operator, so make shell */
 
    aclresult = object_aclcheck(NamespaceRelationId, otherNamespace, GetUserId(),
                                ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA,
                       get_namespace_name(otherNamespace));
 
    other_oid = OperatorShellMake(otherName,
                                  otherNamespace,
                                  otherLeftTypeId,
                                  otherRightTypeId);
    return other_oid;
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, fb(), get_namespace_name(), GetUserId(), InvalidOid, object_aclcheck(), OBJECT_SCHEMA, OidIsValid, OperatorLookup(), OperatorShellMake(), and QualifiedNameGetCreationNamespace().

Referenced by OperatorCreate().

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(), deleteDependencyRecordsFor(), deleteSharedDependencyRecordsFor(), DEPENDENCY_NORMAL, fb(), free_object_addresses(), GETSTRUCT(), new_object_addresses(), ObjectAddressSet, 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) 0;
        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, fb(), 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, table_close(), table_open(), validOperatorName(), and values.

Referenced by DefineOperator().

OperatorGet()

static Oid OperatorGet ( const char *  operatorName, Oid  operatorNamespace, Oid  leftObjectId, Oid  rightObjectId, bool *  defined  )

static

Definition at line 124 of file pg_operator.c.

{
    HeapTuple   tup;
    Oid         operatorObjectId;
 
    tup = SearchSysCache4(OPERNAMENSP,
                          PointerGetDatum(operatorName),
                          ObjectIdGetDatum(leftObjectId),
                          ObjectIdGetDatum(rightObjectId),
                          ObjectIdGetDatum(operatorNamespace));
    if (HeapTupleIsValid(tup))
    {
        Form_pg_operator oprform = (Form_pg_operator) GETSTRUCT(tup);
 
        operatorObjectId = oprform->oid;
        *defined = RegProcedureIsValid(oprform->oprcode);
        ReleaseSysCache(tup);
    }
    else
    {
        operatorObjectId = InvalidOid;
        *defined = false;
    }
 
    return operatorObjectId;
}

References fb(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), PointerGetDatum(), RegProcedureIsValid, ReleaseSysCache(), and SearchSysCache4().

Referenced by OperatorCreate().

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 fb(), get_opcode(), InvalidOid, LookupOperName(), OidIsValid, and RegProcedureIsValid.

Referenced by get_other_operator(), and ValidateOperatorReference().

OperatorShellMake()

static Oid OperatorShellMake ( const char *  operatorName, Oid  operatorNamespace, Oid  leftTypeId, Oid  rightTypeId  )

static

Definition at line 193 of file pg_operator.c.

{
    Relation    pg_operator_desc;
    Oid         operatorObjectId;
    int         i;
    HeapTuple   tup;
    Datum       values[Natts_pg_operator];
    bool        nulls[Natts_pg_operator];
    NameData    oname;
    TupleDesc   tupDesc;
 
    /*
     * validate operator name
     */
    if (!validOperatorName(operatorName))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("\"%s\" is not a valid operator name",
                        operatorName)));
 
    /*
     * open pg_operator
     */
    pg_operator_desc = table_open(OperatorRelationId, RowExclusiveLock);
    tupDesc = pg_operator_desc->rd_att;
 
    /*
     * initialize our *nulls and *values arrays
     */
    for (i = 0; i < Natts_pg_operator; ++i)
    {
        nulls[i] = false;
        values[i] = (Datum) 0;  /* redundant, but safe */
    }
 
    /*
     * initialize values[] with the operator name and input data types. Note
     * that oprcode is set to InvalidOid, indicating it's a shell.
     */
    operatorObjectId = GetNewOidWithIndex(pg_operator_desc, OperatorOidIndexId,
                                          Anum_pg_operator_oid);
    values[Anum_pg_operator_oid - 1] = ObjectIdGetDatum(operatorObjectId);
    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(false);
    values[Anum_pg_operator_oprcanhash - 1] = BoolGetDatum(false);
    values[Anum_pg_operator_oprleft - 1] = ObjectIdGetDatum(leftTypeId);
    values[Anum_pg_operator_oprright - 1] = ObjectIdGetDatum(rightTypeId);
    values[Anum_pg_operator_oprresult - 1] = ObjectIdGetDatum(InvalidOid);
    values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(InvalidOid);
    values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(InvalidOid);
    values[Anum_pg_operator_oprcode - 1] = ObjectIdGetDatum(InvalidOid);
    values[Anum_pg_operator_oprrest - 1] = ObjectIdGetDatum(InvalidOid);
    values[Anum_pg_operator_oprjoin - 1] = ObjectIdGetDatum(InvalidOid);
 
    /*
     * create a new operator tuple
     */
    tup = heap_form_tuple(tupDesc, values, nulls);
 
    /*
     * insert our "shell" operator tuple
     */
    CatalogTupleInsert(pg_operator_desc, tup);
 
    /* Add dependencies for the entry */
    makeOperatorDependencies(tup, true, false);
 
    heap_freetuple(tup);
 
    /* Post creation hook for new shell operator */
    InvokeObjectPostCreateHook(OperatorRelationId, operatorObjectId, 0);
 
    /*
     * Make sure the tuple is visible for subsequent lookups/updates.
     */
    CommandCounterIncrement();
 
    /*
     * close the operator relation and return the oid.
     */
    table_close(pg_operator_desc, RowExclusiveLock);
 
    return operatorObjectId;
}

References BoolGetDatum(), CatalogTupleInsert(), CharGetDatum(), CommandCounterIncrement(), ereport, errcode(), errmsg(), ERROR, fb(), GetNewOidWithIndex(), GetUserId(), heap_form_tuple(), heap_freetuple(), i, InvalidOid, InvokeObjectPostCreateHook, makeOperatorDependencies(), NameGetDatum(), namestrcpy(), ObjectIdGetDatum(), RowExclusiveLock, table_close(), table_open(), validOperatorName(), and values.

Referenced by get_other_operator().

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, fb(), get_opname(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, NameStr, ObjectIdGetDatum(), OidIsValid, RowExclusiveLock, SearchSysCacheCopy1, 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, fb(), and OidIsValid.

Referenced by AlterOperator(), and OperatorCreate().

validOperatorName()

static bool validOperatorName ( const char *  name )

static

Definition at line 68 of file pg_operator.c.

{
    size_t      len = strlen(name);
 
    /* Can't be empty or too long */
    if (len == 0 || len >= NAMEDATALEN)
        return false;
 
    /* Can't contain any invalid characters */
    /* Test string here should match op_chars in scan.l */
    if (strspn(name, "~!@#^&|`?+-*/%<>=") != len)
        return false;
 
    /* Can't contain slash-star or dash-dash (comment starts) */
    if (strstr(name, "/*") || strstr(name, "--"))
        return false;
 
    /*
     * For SQL standard compatibility, '+' and '-' cannot be the last char of
     * a multi-char operator unless the operator contains chars that are not
     * in SQL operators. The idea is to lex '=-' as two operators, but not to
     * forbid operator names like '?-' that could not be sequences of standard
     * SQL operators.
     */
    if (len > 1 &&
        (name[len - 1] == '+' ||
         name[len - 1] == '-'))
    {
        int         ic;
 
        for (ic = len - 2; ic >= 0; ic--)
        {
            if (strchr("~!@#^&|`?%", name[ic]))
                break;
        }
        if (ic < 0)
            return false;       /* nope, not valid */
    }
 
    /* != isn't valid either, because parser will convert it to <> */
    if (strcmp(name, "!=") == 0)
        return false;
 
    return true;
}

References fb(), len, name, and NAMEDATALEN.

Referenced by OperatorCreate(), and OperatorShellMake().