/*-------------------------------------------------------------------------
 *
 * operatorcmds.c
 *
 *   Routines for operator manipulation commands
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/commands/operatorcmds.c
 *
 * DESCRIPTION
 *   The "DefineFoo" routines take the parse tree and pick out the
 *   appropriate arguments/flags, passing the results to the
 *   corresponding "FooCreate" routines (in src/backend/catalog) that do
 *   the actual catalog-munging.  These routines also verify permission
 *   of the user to execute the command.
 *
 * NOTES
 *   These things must be defined and committed in the following order:
 *  "create function":
 *    input/output, recv/send functions
 *  "create type":
 *    type
 *  "create operator":
 *    operators
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/indexing.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 "commands/defrem.h"
#include "miscadmin.h"
#include "parser/parse_func.h"
#include "parser/parse_oper.h"
#include "parser/parse_type.h"
#include "utils/acl.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"

static Oid ValidateRestrictionEstimator(List *restrictionName);
static Oid ValidateJoinEstimator(List *joinName);
static Oid ValidateOperatorReference(List *name,
           Oid leftTypeId,
           Oid rightTypeId);

/*
 * DefineOperator
 *  this function extracts all the information from the
 *  parameter list generated by the parser and then has
 *  OperatorCreate() do all the actual work.
 *
 * 'parameters' is a list of DefElem
 */
ObjectAddress
DefineOperator(List *names, List *parameters)
{
 char    *oprName;
 Oid   oprNamespace;
 AclResult aclresult;
 bool  canMerge = false; /* operator merges */
 bool  canHash = false; /* operator hashes */
 List    *functionName = NIL; /* function for operator */
 TypeName   *typeName1 = NULL; /* first type name */
 TypeName   *typeName2 = NULL; /* second type name */
 Oid   typeId1 = InvalidOid; /* types converted to OID */
 Oid   typeId2 = InvalidOid;
 Oid   rettype;
 List    *commutatorName = NIL; /* optional commutator operator name */
 List    *negatorName = NIL; /* optional negator operator name */
 List    *restrictionName = NIL; /* optional restrict. sel. function */
 List    *joinName = NIL; /* optional join sel. function */
 Oid   functionOid; /* functions converted to OID */
 Oid   restrictionOid;
 Oid   joinOid;
 Oid   typeId[2];  /* to hold left and right arg */
 int   nargs;
 ListCell   *pl;

 /* Convert list of names to a name and namespace */
 oprNamespace = QualifiedNameGetCreationNamespace(names, &oprName);

 /* Check we have creation rights in target namespace */
 aclresult = object_aclcheck(NamespaceRelationId, oprNamespace, GetUserId(), ACL_CREATE);
 if (aclresult != ACLCHECK_OK)
  aclcheck_error(aclresult, OBJECT_SCHEMA,
        get_namespace_name(oprNamespace));

 /*
  * loop over the definition list and extract the information we need.
 */
 foreach(pl, parameters)
 {
  DefElem    *defel = (DefElem *) lfirst(pl);

  if (strcmp(defel->defname, "leftarg") == 0)
  {
   typeName1 = defGetTypeName(defel);
   if (typeName1->setof)
    ereport(ERROR,
      (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
       errmsg("SETOF type not allowed for operator argument")));
  }
  else if (strcmp(defel->defname, "rightarg") == 0)
  {
   typeName2 = defGetTypeName(defel);
   if (typeName2->setof)
    ereport(ERROR,
      (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
       errmsg("SETOF type not allowed for operator argument")));
  }
  /* "function" and "procedure" are equivalent here */
  else if (strcmp(defel->defname, "function") == 0)
   functionName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "procedure") == 0)
   functionName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "commutator") == 0)
   commutatorName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "negator") == 0)
   negatorName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "restrict") == 0)
   restrictionName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "join") == 0)
   joinName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "hashes") == 0)
   canHash = defGetBoolean(defel);
  else if (strcmp(defel->defname, "merges") == 0)
   canMerge = defGetBoolean(defel);
  /* These obsolete options are taken as meaning canMerge */
  else if (strcmp(defel->defname, "sort1") == 0)
   canMerge = true;
  else if (strcmp(defel->defname, "sort2") == 0)
   canMerge = true;
  else if (strcmp(defel->defname, "ltcmp") == 0)
   canMerge = true;
  else if (strcmp(defel->defname, "gtcmp") == 0)
   canMerge = true;
  else
  {
   /* WARNING, not ERROR, for historical backwards-compatibility */
   ereport(WARNING,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("operator attribute \"%s\" not recognized",
       defel->defname)));
  }
 }

 /*
  * make sure we have our required definitions
 */
 if (functionName == NIL)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("operator function must be specified")));

 /* Transform type names to type OIDs */
 if (typeName1)
  typeId1 = typenameTypeId(NULL, typeName1);
 if (typeName2)
  typeId2 = typenameTypeId(NULL, typeName2);

 /*
  * If only the right argument is missing, the user is likely trying to
  * create a postfix operator, so give them a hint about why that does not
  * work.  But if both arguments are missing, do not mention postfix
  * operators, as the user most likely simply neglected to mention the
  * arguments.
 */
 if (!OidIsValid(typeId1) && !OidIsValid(typeId2))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("operator argument types must be specified")));
 if (!OidIsValid(typeId2))
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("operator right argument type must be specified"),
     errdetail("Postfix operators are not supported.")));

 if (typeName1)
 {
  aclresult = object_aclcheck(TypeRelationId, typeId1, GetUserId(), ACL_USAGE);
  if (aclresult != ACLCHECK_OK)
   aclcheck_error_type(aclresult, typeId1);
 }

 if (typeName2)
 {
  aclresult = object_aclcheck(TypeRelationId, typeId2, GetUserId(), ACL_USAGE);
  if (aclresult != ACLCHECK_OK)
   aclcheck_error_type(aclresult, typeId2);
 }

 /*
  * Look up the operator's underlying function.
 */
 if (!OidIsValid(typeId1))
 {
  typeId[0] = typeId2;
  nargs = 1;
 }
 else if (!OidIsValid(typeId2))
 {
  typeId[0] = typeId1;
  nargs = 1;
 }
 else
 {
  typeId[0] = typeId1;
  typeId[1] = typeId2;
  nargs = 2;
 }
 functionOid = LookupFuncName(functionName, nargs, typeId, false);

 /*
  * We require EXECUTE rights for the function.  This isn't strictly
  * necessary, since EXECUTE will be checked at any attempted use of the
  * operator, but it seems like a good idea anyway.
 */
 aclresult = object_aclcheck(ProcedureRelationId, functionOid, GetUserId(), ACL_EXECUTE);
 if (aclresult != ACLCHECK_OK)
  aclcheck_error(aclresult, OBJECT_FUNCTION,
        NameListToString(functionName));

 rettype = get_func_rettype(functionOid);
 aclresult = object_aclcheck(TypeRelationId, rettype, GetUserId(), ACL_USAGE);
 if (aclresult != ACLCHECK_OK)
  aclcheck_error_type(aclresult, rettype);

 /*
  * Look up restriction and join estimators if specified
 */
 if (restrictionName)
  restrictionOid = ValidateRestrictionEstimator(restrictionName);
 else
  restrictionOid = InvalidOid;
 if (joinName)
  joinOid = ValidateJoinEstimator(joinName);
 else
  joinOid = InvalidOid;

 /*
  * now have OperatorCreate do all the work..
 */
 return
  OperatorCreate(oprName, /* operator name */
        oprNamespace, /* namespace */
        typeId1, /* left type id */
        typeId2, /* right type id */
        functionOid, /* function for operator */
        commutatorName, /* optional commutator operator name */
        negatorName, /* optional negator operator name */
        restrictionOid, /* optional restrict. sel. function */
        joinOid, /* optional join sel. function name */
        canMerge, /* operator merges */
        canHash); /* operator hashes */
}

/*
 * Look up a restriction estimator function by name, and verify that it has
 * the correct signature and we have the permissions to attach it to an
 * operator.
 */
static Oid
ValidateRestrictionEstimator(List *restrictionName)
{
 Oid   typeId[4];
 Oid   restrictionOid;

 typeId[0] = INTERNALOID; /* PlannerInfo */
 typeId[1] = OIDOID;   /* operator OID */
 typeId[2] = INTERNALOID; /* args list */
 typeId[3] = INT4OID;  /* varRelid */

 restrictionOid = LookupFuncName(restrictionName, 4, typeId, false);

 /* estimators must return float8 */
 if (get_func_rettype(restrictionOid) != FLOAT8OID)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("restriction estimator function %s must return type %s",
      NameListToString(restrictionName), "float8")));

 /*
  * If the estimator is not a built-in function, require superuser
  * privilege to install it.  This protects against using something that is
  * not a restriction estimator or has hard-wired assumptions about what
  * data types it is working with.  (Built-in estimators are required to
  * defend themselves adequately against unexpected data type choices, but
  * it seems impractical to expect that of extensions' estimators.)
  *
  * If it is built-in, only require EXECUTE rights.
 */
 if (restrictionOid >= FirstGenbkiObjectId)
 {
  if (!superuser())
   ereport(ERROR,
     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
      errmsg("must be superuser to specify a non-built-in restriction estimator function")));
 }
 else
 {
  AclResult aclresult;

  aclresult = object_aclcheck(ProcedureRelationId, restrictionOid,
         GetUserId(), ACL_EXECUTE);
  if (aclresult != ACLCHECK_OK)
   aclcheck_error(aclresult, OBJECT_FUNCTION,
         NameListToString(restrictionName));
 }

 return restrictionOid;
}

/*
 * Look up a join estimator function by name, and verify that it has the
 * correct signature and we have the permissions to attach it to an
 * operator.
 */
static Oid
ValidateJoinEstimator(List *joinName)
{
 Oid   typeId[5];
 Oid   joinOid;
 Oid   joinOid2;

 typeId[0] = INTERNALOID; /* PlannerInfo */
 typeId[1] = OIDOID;   /* operator OID */
 typeId[2] = INTERNALOID; /* args list */
 typeId[3] = INT2OID;  /* jointype */
 typeId[4] = INTERNALOID; /* SpecialJoinInfo */

 /*
  * As of Postgres 8.4, the preferred signature for join estimators has 5
  * arguments, but we still allow the old 4-argument form.  Whine about
  * ambiguity if both forms exist.
 */
 joinOid = LookupFuncName(joinName, 5, typeId, true);
 joinOid2 = LookupFuncName(joinName, 4, typeId, true);
 if (OidIsValid(joinOid))
 {
  if (OidIsValid(joinOid2))
   ereport(ERROR,
     (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
      errmsg("join estimator function %s has multiple matches",
       NameListToString(joinName))));
 }
 else
 {
  joinOid = joinOid2;
  /* If not found, reference the 5-argument signature in error msg */
  if (!OidIsValid(joinOid))
   joinOid = LookupFuncName(joinName, 5, typeId, false);
 }

 /* estimators must return float8 */
 if (get_func_rettype(joinOid) != FLOAT8OID)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
     errmsg("join estimator function %s must return type %s",
      NameListToString(joinName), "float8")));

 /* privilege checks are the same as in ValidateRestrictionEstimator */
 if (joinOid >= FirstGenbkiObjectId)
 {
  if (!superuser())
   ereport(ERROR,
     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
      errmsg("must be superuser to specify a non-built-in join estimator function")));
 }
 else
 {
  AclResult aclresult;

  aclresult = object_aclcheck(ProcedureRelationId, joinOid,
         GetUserId(), ACL_EXECUTE);
  if (aclresult != ACLCHECK_OK)
   aclcheck_error(aclresult, OBJECT_FUNCTION,
         NameListToString(joinName));
 }

 return joinOid;
}

/*
 * Look up and return the OID of an operator,
 * given a possibly-qualified name and left and right type IDs.
 *
 * Verifies that the operator is defined (not a shell) and owned by
 * the current user, so that we have permission to associate it with
 * the operator being altered.  Rejecting shell operators is a policy
 * choice to help catch mistakes, rather than something essential.
 */
static Oid
ValidateOperatorReference(List *name,
        Oid leftTypeId,
        Oid rightTypeId)
{
 Oid   oid;
 bool  defined;

 oid = OperatorLookup(name,
       leftTypeId,
       rightTypeId,
       &defined);

 /* These message strings are chosen to match parse_oper.c */
 if (!OidIsValid(oid))
  ereport(ERROR,
    (errcode(ERRCODE_UNDEFINED_FUNCTION),
     errmsg("operator does not exist: %s",
      op_signature_string(name,
           leftTypeId,
           rightTypeId))));

 if (!defined)
  ereport(ERROR,
    (errcode(ERRCODE_UNDEFINED_FUNCTION),
     errmsg("operator is only a shell: %s",
      op_signature_string(name,
           leftTypeId,
           rightTypeId))));

 if (!object_ownercheck(OperatorRelationId, oid, GetUserId()))
  aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
        NameListToString(name));

 return oid;
}


/*
 * Guts of operator deletion.
 */
void
RemoveOperatorById(Oid operOid)
{
 Relation relation;
 HeapTuple tup;
 Form_pg_operator op;

 relation = table_open(OperatorRelationId, RowExclusiveLock);

 tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
 if (!HeapTupleIsValid(tup)) /* should not happen */
  elog(ERROR, "cache lookup failed for operator %u", operOid);
 op = (Form_pg_operator) GETSTRUCT(tup);

 /*
  * Reset links from commutator and negator, if any.  In case of a
  * self-commutator or self-negator, this means we have to re-fetch the
  * updated tuple.  (We could optimize away updates on the tuple we're
  * about to drop, but it doesn't seem worth convoluting the logic for.)
 */
 if (OidIsValid(op->oprcom) || OidIsValid(op->oprnegate))
 {
  OperatorUpd(operOid, op->oprcom, op->oprnegate, true);
  if (operOid == op->oprcom || operOid == op->oprnegate)
  {
   ReleaseSysCache(tup);
   tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
   if (!HeapTupleIsValid(tup)) /* should not happen */
    elog(ERROR, "cache lookup failed for operator %u", operOid);
  }
 }

 CatalogTupleDelete(relation, &tup->t_self);

 ReleaseSysCache(tup);

 table_close(relation, RowExclusiveLock);
}

/*
 * AlterOperator
 *  routine implementing ALTER OPERATOR <operator> SET (option = ...).
 *
 * Currently, only RESTRICT and JOIN estimator functions can be changed.
 * COMMUTATOR, NEGATOR, MERGES, and HASHES attributes can be set if they
 * have not been set previously.  (Changing or removing one of these
 * attributes could invalidate existing plans, which seems more trouble
 * than it's worth.)
 */
ObjectAddress
AlterOperator(AlterOperatorStmt *stmt)
{
 ObjectAddress address;
 Oid   oprId;
 Relation catalog;
 HeapTuple tup;
 Form_pg_operator oprForm;
 int   i;
 ListCell   *pl;
 Datum  values[Natts_pg_operator];
 bool  nulls[Natts_pg_operator];
 bool  replaces[Natts_pg_operator];
 List    *restrictionName = NIL; /* optional restrict. sel. function */
 bool  updateRestriction = false;
 Oid   restrictionOid;
 List    *joinName = NIL; /* optional join sel. function */
 bool  updateJoin = false;
 Oid   joinOid;
 List    *commutatorName = NIL; /* optional commutator operator name */
 Oid   commutatorOid;
 List    *negatorName = NIL; /* optional negator operator name */
 Oid   negatorOid;
 bool  canMerge = false;
 bool  updateMerges = false;
 bool  canHash = false;
 bool  updateHashes = false;

 /* Look up the operator */
 oprId = LookupOperWithArgs(stmt->opername, false);
 catalog = table_open(OperatorRelationId, RowExclusiveLock);
 tup = SearchSysCacheCopy1(OPEROID, ObjectIdGetDatum(oprId));
 if (!HeapTupleIsValid(tup))
  elog(ERROR, "cache lookup failed for operator %u", oprId);
 oprForm = (Form_pg_operator) GETSTRUCT(tup);

 /* Process options */
 foreach(pl, stmt->options)
 {
  DefElem    *defel = (DefElem *) lfirst(pl);
  List    *param;

  if (defel->arg == NULL)
   param = NIL;  /* NONE, removes the function */
  else
   param = defGetQualifiedName(defel);

  if (strcmp(defel->defname, "restrict") == 0)
  {
   restrictionName = param;
   updateRestriction = true;
  }
  else if (strcmp(defel->defname, "join") == 0)
  {
   joinName = param;
   updateJoin = true;
  }
  else if (strcmp(defel->defname, "commutator") == 0)
  {
   commutatorName = defGetQualifiedName(defel);
  }
  else if (strcmp(defel->defname, "negator") == 0)
  {
   negatorName = defGetQualifiedName(defel);
  }
  else if (strcmp(defel->defname, "merges") == 0)
  {
   canMerge = defGetBoolean(defel);
   updateMerges = true;
  }
  else if (strcmp(defel->defname, "hashes") == 0)
  {
   canHash = defGetBoolean(defel);
   updateHashes = true;
  }

  /*
   * The rest of the options that CREATE accepts cannot be changed.
   * Check for them so that we can give a meaningful error message.
 */
  else if (strcmp(defel->defname, "leftarg") == 0 ||
     strcmp(defel->defname, "rightarg") == 0 ||
     strcmp(defel->defname, "function") == 0 ||
     strcmp(defel->defname, "procedure") == 0)
  {
   ereport(ERROR,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("operator attribute \"%s\" cannot be changed",
       defel->defname)));
  }
  else
   ereport(ERROR,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("operator attribute \"%s\" not recognized",
       defel->defname)));
 }

 /* Check permissions. Must be owner. */
 if (!object_ownercheck(OperatorRelationId, oprId, GetUserId()))
  aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
        NameStr(oprForm->oprname));

 /*
  * Look up OIDs for any parameters specified
 */
 if (restrictionName)
  restrictionOid = ValidateRestrictionEstimator(restrictionName);
 else
  restrictionOid = InvalidOid;
 if (joinName)
  joinOid = ValidateJoinEstimator(joinName);
 else
  joinOid = InvalidOid;

 if (commutatorName)
 {
  /* commutator has reversed arg types */
  commutatorOid = ValidateOperatorReference(commutatorName,
              oprForm->oprright,
              oprForm->oprleft);

  /*
   * We don't need to do anything extra for a self commutator as in
   * OperatorCreate, since the operator surely exists already.
 */
 }
 else
  commutatorOid = InvalidOid;

 if (negatorName)
 {
  negatorOid = ValidateOperatorReference(negatorName,
              oprForm->oprleft,
              oprForm->oprright);

  /* Must reject self-negation */
  if (negatorOid == oprForm->oid)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("operator cannot be its own negator")));
 }
 else
 {
  negatorOid = InvalidOid;
 }

 /*
  * Check that we're not changing any attributes that might be depended on
  * by plans, while allowing no-op updates.
 */
 if (OidIsValid(commutatorOid) && OidIsValid(oprForm->oprcom) &&
  commutatorOid != oprForm->oprcom)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("operator attribute \"%s\" cannot be changed if it has already been set",
      "commutator")));

 if (OidIsValid(negatorOid) && OidIsValid(oprForm->oprnegate) &&
  negatorOid != oprForm->oprnegate)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("operator attribute \"%s\" cannot be changed if it has already been set",
      "negator")));

 if (updateMerges && oprForm->oprcanmerge && !canMerge)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("operator attribute \"%s\" cannot be changed if it has already been set",
      "merges")));

 if (updateHashes && oprForm->oprcanhash && !canHash)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("operator attribute \"%s\" cannot be changed if it has already been set",
      "hashes")));

 /* Perform additional checks, like OperatorCreate does */
 OperatorValidateParams(oprForm->oprleft,
         oprForm->oprright,
         oprForm->oprresult,
         OidIsValid(commutatorOid),
         OidIsValid(negatorOid),
         OidIsValid(restrictionOid),
         OidIsValid(joinOid),
         canMerge,
         canHash);

 /* Update the tuple */
 for (i = 0; i < Natts_pg_operator; ++i)
 {
  values[i] = (Datum) 0;
  replaces[i] = false;
  nulls[i] = false;
 }
 if (updateRestriction)
 {
  replaces[Anum_pg_operator_oprrest - 1] = true;
  values[Anum_pg_operator_oprrest - 1] = ObjectIdGetDatum(restrictionOid);
 }
 if (updateJoin)
 {
  replaces[Anum_pg_operator_oprjoin - 1] = true;
  values[Anum_pg_operator_oprjoin - 1] = ObjectIdGetDatum(joinOid);
 }
 if (OidIsValid(commutatorOid))
 {
  replaces[Anum_pg_operator_oprcom - 1] = true;
  values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(commutatorOid);
 }
 if (OidIsValid(negatorOid))
 {
  replaces[Anum_pg_operator_oprnegate - 1] = true;
  values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(negatorOid);
 }
 if (updateMerges)
 {
  replaces[Anum_pg_operator_oprcanmerge - 1] = true;
  values[Anum_pg_operator_oprcanmerge - 1] = BoolGetDatum(canMerge);
 }
 if (updateHashes)
 {
  replaces[Anum_pg_operator_oprcanhash - 1] = true;
  values[Anum_pg_operator_oprcanhash - 1] = BoolGetDatum(canHash);
 }

 tup = heap_modify_tuple(tup, RelationGetDescr(catalog),
       values, nulls, replaces);

 CatalogTupleUpdate(catalog, &tup->t_self, tup);

 address = makeOperatorDependencies(tup, false, true);

 if (OidIsValid(commutatorOid) || OidIsValid(negatorOid))
  OperatorUpd(oprId, commutatorOid, negatorOid, false);

 InvokeObjectPostAlterHook(OperatorRelationId, oprId, 0);

 table_close(catalog, NoLock);

 return address;
}