/*-------------------------------------------------------------------------

 *

 * opclasscmds.c

 *

 *    Routines for opclass (and opfamily) manipulation commands

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/commands/opclasscmds.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include <limits.h>

#include "access/genam.h"

#include "access/hash.h"

#include "access/htup_details.h"

#include "access/nbtree.h"

#include "access/table.h"

#include "catalog/catalog.h"

#include "catalog/dependency.h"

#include "catalog/indexing.h"

#include "catalog/objectaccess.h"

#include "catalog/pg_am.h"

#include "catalog/pg_amop.h"

#include "catalog/pg_amproc.h"

#include "catalog/pg_namespace.h"

#include "catalog/pg_opclass.h"

#include "catalog/pg_operator.h"

#include "catalog/pg_opfamily.h"

#include "catalog/pg_proc.h"

#include "catalog/pg_type.h"

#include "commands/defrem.h"

#include "commands/event_trigger.h"

#include "miscadmin.h"

#include "parser/parse_func.h"

#include "parser/parse_oper.h"

#include "parser/parse_type.h"

#include "utils/acl.h"

#include "utils/builtins.h"

#include "utils/fmgroids.h"

#include "utils/lsyscache.h"

#include "utils/rel.h"

#include "utils/syscache.h"

static void AlterOpFamilyAdd(AlterOpFamilyStmt *stmt,

               Oid amoid, Oid opfamilyoid,

               int maxOpNumber, int maxProcNumber,

               int optsProcNumber, List *items);

static void AlterOpFamilyDrop(AlterOpFamilyStmt *stmt,

                Oid amoid, Oid opfamilyoid,

                int maxOpNumber, int maxProcNumber,

                List *items);

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

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

static void assignProcTypes(OpFamilyMember *member, Oid amoid, Oid typeoid,

              int opclassOptsProcNum);

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

static void storeOperators(List *opfamilyname, Oid amoid, Oid opfamilyoid,

               List *operators, bool isAdd);

static void storeProcedures(List *opfamilyname, Oid amoid, Oid opfamilyoid,

              List *procedures, bool isAdd);

static bool typeDepNeeded(Oid typid, OpFamilyMember *member);

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

              List *operators);

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

               List *procedures);

/*

 * OpFamilyCacheLookup

 *    Look up an existing opfamily by name.

 *

 * Returns a syscache tuple reference, or NULL if not found.

 */

static HeapTuple

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

{

  char     *schemaname;

  char     *opfname;

  HeapTuple htup;

  /* deconstruct the name list */

  DeconstructQualifiedName(opfamilyname, &schemaname, &opfname);

  if (schemaname)

  {

    /* Look in specific schema only */

    Oid     namespaceId;

    namespaceId = LookupExplicitNamespace(schemaname, missing_ok);

    if (!OidIsValid(namespaceId))

      htup = NULL;

    else

      htup = SearchSysCache3(OPFAMILYAMNAMENSP,

                   ObjectIdGetDatum(amID),

                   PointerGetDatum(opfname),

                   ObjectIdGetDatum(namespaceId));

  }

  else

  {

    /* Unqualified opfamily name, so search the search path */

    Oid     opfID = OpfamilynameGetOpfid(amID, opfname);

    if (!OidIsValid(opfID))

      htup = NULL;

    else

      htup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfID));

  }

  if (!HeapTupleIsValid(htup) && !missing_ok)

  {

    HeapTuple amtup;

    amtup = SearchSysCache1(AMOID, ObjectIdGetDatum(amID));

    if (!HeapTupleIsValid(amtup))

      elog(ERROR, "cache lookup failed for access method %u", amID);

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("operator family \"%s\" does not exist for access method \"%s\"",

            NameListToString(opfamilyname),

            NameStr(((Form_pg_am) GETSTRUCT(amtup))->amname))));

  }

  return htup;

}

/*

 * get_opfamily_oid

 *    find an opfamily OID by possibly qualified name

 *

 * If not found, returns InvalidOid if missing_ok, else throws error.

 */

Oid

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

{

  HeapTuple htup;

  Form_pg_opfamily opfamform;

  Oid     opfID;

  htup = OpFamilyCacheLookup(amID, opfamilyname, missing_ok);

  if (!HeapTupleIsValid(htup))

    return InvalidOid;

  opfamform = (Form_pg_opfamily) GETSTRUCT(htup);

  opfID = opfamform->oid;

  ReleaseSysCache(htup);

  return opfID;

}

/*

 * OpClassCacheLookup

 *    Look up an existing opclass by name.

 *

 * Returns a syscache tuple reference, or NULL if not found.

 */

static HeapTuple

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

{

  char     *schemaname;

  char     *opcname;

  HeapTuple htup;

  /* deconstruct the name list */

  DeconstructQualifiedName(opclassname, &schemaname, &opcname);

  if (schemaname)

  {

    /* Look in specific schema only */

    Oid     namespaceId;

    namespaceId = LookupExplicitNamespace(schemaname, missing_ok);

    if (!OidIsValid(namespaceId))

      htup = NULL;

    else

      htup = SearchSysCache3(CLAAMNAMENSP,

                   ObjectIdGetDatum(amID),

                   PointerGetDatum(opcname),

                   ObjectIdGetDatum(namespaceId));

  }

  else

  {

    /* Unqualified opclass name, so search the search path */

    Oid     opcID = OpclassnameGetOpcid(amID, opcname);

    if (!OidIsValid(opcID))

      htup = NULL;

    else

      htup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opcID));

  }

  if (!HeapTupleIsValid(htup) && !missing_ok)

  {

    HeapTuple amtup;

    amtup = SearchSysCache1(AMOID, ObjectIdGetDatum(amID));

    if (!HeapTupleIsValid(amtup))

      elog(ERROR, "cache lookup failed for access method %u", amID);

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("operator class \"%s\" does not exist for access method \"%s\"",

            NameListToString(opclassname),

            NameStr(((Form_pg_am) GETSTRUCT(amtup))->amname))));

  }

  return htup;

}

/*

 * get_opclass_oid

 *    find an opclass OID by possibly qualified name

 *

 * If not found, returns InvalidOid if missing_ok, else throws error.

 */

Oid

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

{

  HeapTuple htup;

  Form_pg_opclass opcform;

  Oid     opcID;

  htup = OpClassCacheLookup(amID, opclassname, missing_ok);

  if (!HeapTupleIsValid(htup))

    return InvalidOid;

  opcform = (Form_pg_opclass) GETSTRUCT(htup);

  opcID = opcform->oid;

  ReleaseSysCache(htup);

  return opcID;

}

/*

 * CreateOpFamily

 *    Internal routine to make the catalog entry for a new operator family.

 *

 * Caller must have done permissions checks etc. already.

 */

static ObjectAddress

CreateOpFamily(CreateOpFamilyStmt *stmt, const char *opfname,

         Oid namespaceoid, Oid amoid)

{

  Oid     opfamilyoid;

  Relation  rel;

  HeapTuple tup;

  Datum   values[Natts_pg_opfamily];

  bool    nulls[Natts_pg_opfamily];

  NameData  opfName;

  ObjectAddress myself,

        referenced;

  rel = table_open(OperatorFamilyRelationId, RowExclusiveLock);

  /*

   * Make sure there is no existing opfamily of this name (this is just to

   * give a more friendly error message than "duplicate key").

   */

  if (SearchSysCacheExists3(OPFAMILYAMNAMENSP,

                ObjectIdGetDatum(amoid),

                CStringGetDatum(opfname),

                ObjectIdGetDatum(namespaceoid)))

    ereport(ERROR,

        (errcode(ERRCODE_DUPLICATE_OBJECT),

         errmsg("operator family \"%s\" for access method \"%s\" already exists",

            opfname, stmt->amname)));

  /*

   * Okay, let's create the pg_opfamily entry.

   */

  memset(values, 0, sizeof(values));

  memset(nulls, false, sizeof(nulls));

  opfamilyoid = GetNewOidWithIndex(rel, OpfamilyOidIndexId,

                   Anum_pg_opfamily_oid);

  values[Anum_pg_opfamily_oid - 1] = ObjectIdGetDatum(opfamilyoid);

  values[Anum_pg_opfamily_opfmethod - 1] = ObjectIdGetDatum(amoid);

  namestrcpy(&opfName, opfname);

  values[Anum_pg_opfamily_opfname - 1] = NameGetDatum(&opfName);

  values[Anum_pg_opfamily_opfnamespace - 1] = ObjectIdGetDatum(namespaceoid);

  values[Anum_pg_opfamily_opfowner - 1] = ObjectIdGetDatum(GetUserId());

  tup = heap_form_tuple(rel->rd_att, values, nulls);

  CatalogTupleInsert(rel, tup);

  heap_freetuple(tup);

  /*

   * Create dependencies for the opfamily proper.

   */

  myself.classId = OperatorFamilyRelationId;

  myself.objectId = opfamilyoid;

  myself.objectSubId = 0;

  /* dependency on access method */

  referenced.classId = AccessMethodRelationId;

  referenced.objectId = amoid;

  referenced.objectSubId = 0;

  recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);

  /* dependency on namespace */

  referenced.classId = NamespaceRelationId;

  referenced.objectId = namespaceoid;

  referenced.objectSubId = 0;

  recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

  /* dependency on owner */

  recordDependencyOnOwner(OperatorFamilyRelationId, opfamilyoid, GetUserId());

  /* dependency on extension */

  recordDependencyOnCurrentExtension(&myself, false);

  /* Report the new operator family to possibly interested event triggers */

  EventTriggerCollectSimpleCommand(myself, InvalidObjectAddress,

                   (Node *) stmt);

  /* Post creation hook for new operator family */

  InvokeObjectPostCreateHook(OperatorFamilyRelationId, opfamilyoid, 0);

  table_close(rel, RowExclusiveLock);

  return myself;

}

/*

 * DefineOpClass

 *    Define a new index operator class.

 */

ObjectAddress

DefineOpClass(CreateOpClassStmt *stmt)

{

  char     *opcname;    /* name of opclass we're creating */

  Oid     amoid,      /* our AM's oid */

        typeoid,    /* indexable datatype oid */

        storageoid,   /* storage datatype oid, if any */

        namespaceoid, /* namespace to create opclass in */

        opfamilyoid,  /* oid of containing opfamily */

        opclassoid;   /* oid of opclass we create */

  int     maxOpNumber,  /* amstrategies value */

        optsProcNumber, /* amoptsprocnum value */

        maxProcNumber;  /* amsupport value */

  bool    amstorage;    /* amstorage flag */

  bool    isDefault = stmt->isDefault;

  List     *operators;    /* OpFamilyMember list for operators */

  List     *procedures;   /* OpFamilyMember list for support procs */

  ListCell   *l;

  Relation  rel;

  HeapTuple tup;

  Form_pg_am  amform;

  const IndexAmRoutine *amroutine;

  Datum   values[Natts_pg_opclass];

  bool    nulls[Natts_pg_opclass];

  AclResult aclresult;

  NameData  opcName;

  ObjectAddress myself,

        referenced;

  /* Convert list of names to a name and namespace */

  namespaceoid = QualifiedNameGetCreationNamespace(stmt->opclassname,

                           &opcname);

  /* Check we have creation rights in target namespace */

  aclresult = object_aclcheck(NamespaceRelationId, namespaceoid, GetUserId(), ACL_CREATE);

  if (aclresult != ACLCHECK_OK)

    aclcheck_error(aclresult, OBJECT_SCHEMA,

             get_namespace_name(namespaceoid));

  /* Get necessary info about access method */

  tup = SearchSysCache1(AMNAME, CStringGetDatum(stmt->amname));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("access method \"%s\" does not exist",

            stmt->amname)));

  amform = (Form_pg_am) GETSTRUCT(tup);

  amoid = amform->oid;

  amroutine = GetIndexAmRoutineByAmId(amoid, false);

  ReleaseSysCache(tup);

  maxOpNumber = amroutine->amstrategies;

  /* if amstrategies is zero, just enforce that op numbers fit in int16 */

  if (maxOpNumber <= 0)

    maxOpNumber = SHRT_MAX;

  maxProcNumber = amroutine->amsupport;

  optsProcNumber = amroutine->amoptsprocnum;

  amstorage = amroutine->amstorage;

  /* XXX Should we make any privilege check against the AM? */

  /*

   * The question of appropriate permissions for CREATE OPERATOR CLASS is

   * interesting.  Creating an opclass is tantamount to granting public

   * execute access on the functions involved, since the index machinery

   * generally does not check access permission before using the functions.

   * A minimum expectation therefore is that the caller have execute

   * privilege with grant option.  Since we don't have a way to make the

   * opclass go away if the grant option is revoked, we choose instead to

   * require ownership of the functions.  It's also not entirely clear what

   * permissions should be required on the datatype, but ownership seems

   * like a safe choice.

   *

   * Currently, we require superuser privileges to create an opclass. This

   * seems necessary because we have no way to validate that the offered set

   * of operators and functions are consistent with the AM's expectations.

   * It would be nice to provide such a check someday, if it can be done

   * without solving the halting problem :-(

   *

   * XXX re-enable NOT_USED code sections below if you remove this test.

   */

  if (!superuser())

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("must be superuser to create an operator class")));

  /* Look up the datatype */

  typeoid = typenameTypeId(NULL, stmt->datatype);

#ifdef NOT_USED

  /* XXX this is unnecessary given the superuser check above */

  /* Check we have ownership of the datatype */

  if (!object_ownercheck(TypeRelationId, typeoid, GetUserId()))

    aclcheck_error_type(ACLCHECK_NOT_OWNER, typeoid);

#endif

  /*

   * Look up the containing operator family, or create one if FAMILY option

   * was omitted and there's not a match already.

   */

  if (stmt->opfamilyname)

  {

    opfamilyoid = get_opfamily_oid(amoid, stmt->opfamilyname, false);

  }

  else

  {

    /* Lookup existing family of same name and namespace */

    tup = SearchSysCache3(OPFAMILYAMNAMENSP,

                ObjectIdGetDatum(amoid),

                PointerGetDatum(opcname),

                ObjectIdGetDatum(namespaceoid));

    if (HeapTupleIsValid(tup))

    {

      opfamilyoid = ((Form_pg_opfamily) GETSTRUCT(tup))->oid;

      /*

       * XXX given the superuser check above, there's no need for an

       * ownership check here

       */

      ReleaseSysCache(tup);

    }

    else

    {

      CreateOpFamilyStmt *opfstmt;

      ObjectAddress tmpAddr;

      opfstmt = makeNode(CreateOpFamilyStmt);

      opfstmt->opfamilyname = stmt->opclassname;

      opfstmt->amname = stmt->amname;

      /*

       * Create it ... again no need for more permissions ...

       */

      tmpAddr = CreateOpFamily(opfstmt, opcname, namespaceoid, amoid);

      opfamilyoid = tmpAddr.objectId;

    }

  }

  operators = NIL;

  procedures = NIL;

  /* Storage datatype is optional */

  storageoid = InvalidOid;

  /*

   * Scan the "items" list to obtain additional info.

   */

  foreach(l, stmt->items)

  {

    CreateOpClassItem *item = lfirst_node(CreateOpClassItem, l);

    Oid     operOid;

    Oid     funcOid;

    Oid     sortfamilyOid;

    OpFamilyMember *member;

    switch (item->itemtype)

    {

      case OPCLASS_ITEM_OPERATOR:

        if (item->number <= 0 || item->number > maxOpNumber)

          ereport(ERROR,

              (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

               errmsg("invalid operator number %d,"

                  " must be between 1 and %d",

                  item->number, maxOpNumber)));

        if (item->name->objargs != NIL)

          operOid = LookupOperWithArgs(item->name, false);

        else

        {

          /* Default to binary op on input datatype */

          operOid = LookupOperName(NULL, item->name->objname,

                       typeoid, typeoid,

                       false, -1);

        }

        if (item->order_family)

          sortfamilyOid = get_opfamily_oid(BTREE_AM_OID,

                           item->order_family,

                           false);

        else

          sortfamilyOid = InvalidOid;

#ifdef NOT_USED

        /* XXX this is unnecessary given the superuser check above */

        /* Caller must own operator and its underlying function */

        if (!object_ownercheck(OperatorRelationId, operOid, GetUserId()))

          aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,

                   get_opname(operOid));

        funcOid = get_opcode(operOid);

        if (!object_ownercheck(ProcedureRelationId, funcOid, GetUserId()))

          aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,

                   get_func_name(funcOid));

#endif

        /* Save the info */

        member = palloc0_object(OpFamilyMember);

        member->is_func = false;

        member->object = operOid;

        member->number = item->number;

        member->sortfamily = sortfamilyOid;

        assignOperTypes(member, amoid, typeoid);

        addFamilyMember(&operators, member);

        break;

      case OPCLASS_ITEM_FUNCTION:

        if (item->number <= 0 || item->number > maxProcNumber)

          ereport(ERROR,

              (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

               errmsg("invalid function number %d,"

                  " must be between 1 and %d",

                  item->number, maxProcNumber)));

        funcOid = LookupFuncWithArgs(OBJECT_FUNCTION, item->name, false);

#ifdef NOT_USED

        /* XXX this is unnecessary given the superuser check above */

        /* Caller must own function */

        if (!object_ownercheck(ProcedureRelationId, funcOid, GetUserId()))

          aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,

                   get_func_name(funcOid));

#endif

        /* Save the info */

        member = palloc0_object(OpFamilyMember);

        member->is_func = true;

        member->object = funcOid;

        member->number = item->number;

        /* allow overriding of the function's actual arg types */

        if (item->class_args)

          processTypesSpec(item->class_args,

                   &member->lefttype, &member->righttype);

        assignProcTypes(member, amoid, typeoid, optsProcNumber);

        addFamilyMember(&procedures, member);

        break;

      case OPCLASS_ITEM_STORAGETYPE:

        if (OidIsValid(storageoid))

          ereport(ERROR,

              (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

               errmsg("storage type specified more than once")));

        storageoid = typenameTypeId(NULL, item->storedtype);

#ifdef NOT_USED

        /* XXX this is unnecessary given the superuser check above */

        /* Check we have ownership of the datatype */

        if (!object_ownercheck(TypeRelationId, storageoid, GetUserId()))

          aclcheck_error_type(ACLCHECK_NOT_OWNER, storageoid);

#endif

        break;

      default:

        elog(ERROR, "unrecognized item type: %d", item->itemtype);

        break;

    }

  }

  /*

   * If storagetype is specified, make sure it's legal.

   */

  if (OidIsValid(storageoid))

  {

    /* Just drop the spec if same as column datatype */

    if (storageoid == typeoid)

      storageoid = InvalidOid;

    else if (!amstorage)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

           errmsg("storage type cannot be different from data type for access method \"%s\"",

              stmt->amname)));

  }

  rel = table_open(OperatorClassRelationId, RowExclusiveLock);

  /*

   * Make sure there is no existing opclass of this name (this is just to

   * give a more friendly error message than "duplicate key").

   */

  if (SearchSysCacheExists3(CLAAMNAMENSP,

                ObjectIdGetDatum(amoid),

                CStringGetDatum(opcname),

                ObjectIdGetDatum(namespaceoid)))

    ereport(ERROR,

        (errcode(ERRCODE_DUPLICATE_OBJECT),

         errmsg("operator class \"%s\" for access method \"%s\" already exists",

            opcname, stmt->amname)));

  /*

   * HACK: if we're trying to create btree_gist's gist_inet_ops or

   * gist_cidr_ops during a binary upgrade, avoid failure in the next stanza

   * by silently making the new opclass non-default.  Without this kluge, we

   * would fail to upgrade databases containing pre-1.9 versions of

   * contrib/btree_gist.  We can remove it sometime in the far future when

   * we don't expect any such databases to exist.  (The result of this hack

   * is that the installed version of btree_gist will approximate btree_gist

   * 1.9, how closely depending on whether it's 1.8 or something older.

   * ALTER EXTENSION UPDATE can be used to bring it up to real 1.9.)

   */

  if (isDefault && IsBinaryUpgrade)

  {

    if (amoid == GIST_AM_OID &&

      ((typeoid == INETOID && strcmp(opcname, "gist_inet_ops") == 0) ||

       (typeoid == CIDROID && strcmp(opcname, "gist_cidr_ops") == 0)))

      isDefault = false;

  }

  /*

   * If we are creating a default opclass, check there isn't one already.

   * (Note we do not restrict this test to visible opclasses; this ensures

   * that typcache.c can find unique solutions to its questions.)

   */

  if (isDefault)

  {

    ScanKeyData skey[1];

    SysScanDesc scan;

    ScanKeyInit(&skey[0],

          Anum_pg_opclass_opcmethod,

          BTEqualStrategyNumber, F_OIDEQ,

          ObjectIdGetDatum(amoid));

    scan = systable_beginscan(rel, OpclassAmNameNspIndexId, true,

                  NULL, 1, skey);

    while (HeapTupleIsValid(tup = systable_getnext(scan)))

    {

      Form_pg_opclass opclass = (Form_pg_opclass) GETSTRUCT(tup);

      if (opclass->opcintype == typeoid && opclass->opcdefault)

        ereport(ERROR,

            (errcode(ERRCODE_DUPLICATE_OBJECT),

             errmsg("could not make operator class \"%s\" be default for type %s",

                opcname,

                TypeNameToString(stmt->datatype)),

             errdetail("Operator class \"%s\" already is the default.",

                   NameStr(opclass->opcname))));

    }

    systable_endscan(scan);

  }

  /*

   * Okay, let's create the pg_opclass entry.

   */

  memset(values, 0, sizeof(values));

  memset(nulls, false, sizeof(nulls));

  opclassoid = GetNewOidWithIndex(rel, OpclassOidIndexId,

                  Anum_pg_opclass_oid);

  values[Anum_pg_opclass_oid - 1] = ObjectIdGetDatum(opclassoid);

  values[Anum_pg_opclass_opcmethod - 1] = ObjectIdGetDatum(amoid);

  namestrcpy(&opcName, opcname);

  values[Anum_pg_opclass_opcname - 1] = NameGetDatum(&opcName);

  values[Anum_pg_opclass_opcnamespace - 1] = ObjectIdGetDatum(namespaceoid);

  values[Anum_pg_opclass_opcowner - 1] = ObjectIdGetDatum(GetUserId());

  values[Anum_pg_opclass_opcfamily - 1] = ObjectIdGetDatum(opfamilyoid);

  values[Anum_pg_opclass_opcintype - 1] = ObjectIdGetDatum(typeoid);

  values[Anum_pg_opclass_opcdefault - 1] = BoolGetDatum(isDefault);

  values[Anum_pg_opclass_opckeytype - 1] = ObjectIdGetDatum(storageoid);

  tup = heap_form_tuple(rel->rd_att, values, nulls);

  CatalogTupleInsert(rel, tup);

  heap_freetuple(tup);

  /*

   * Now that we have the opclass OID, set up default dependency info for

   * the pg_amop and pg_amproc entries.  Historically, CREATE OPERATOR CLASS

   * has created hard dependencies on the opclass, so that's what we use.

   */

  foreach(l, operators)

  {

    OpFamilyMember *op = (OpFamilyMember *) lfirst(l);

    op->ref_is_hard = true;

    op->ref_is_family = false;

    op->refobjid = opclassoid;

  }

  foreach(l, procedures)

  {

    OpFamilyMember *proc = (OpFamilyMember *) lfirst(l);

    proc->ref_is_hard = true;

    proc->ref_is_family = false;

    proc->refobjid = opclassoid;

  }

  /*

   * Let the index AM editorialize on the dependency choices.  It could also

   * do further validation on the operators and functions, if it likes.

   */

  if (amroutine->amadjustmembers)

    amroutine->amadjustmembers(opfamilyoid,

                   opclassoid,

                   operators,

                   procedures);

  /*

   * Now add tuples to pg_amop and pg_amproc tying in the operators and

   * functions.  Dependencies on them are inserted, too.

   */

  storeOperators(stmt->opfamilyname, amoid, opfamilyoid,

           operators, false);

  storeProcedures(stmt->opfamilyname, amoid, opfamilyoid,

          procedures, false);

  /* let event triggers know what happened */

  EventTriggerCollectCreateOpClass(stmt, opclassoid, operators, procedures);

  /*

   * Create dependencies for the opclass proper.  Note: we do not need a

   * dependency link to the AM, because that exists through the opfamily.

   */

  myself.classId = OperatorClassRelationId;

  myself.objectId = opclassoid;

  myself.objectSubId = 0;

  /* dependency on namespace */

  referenced.classId = NamespaceRelationId;

  referenced.objectId = namespaceoid;

  referenced.objectSubId = 0;

  recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

  /* dependency on opfamily */

  referenced.classId = OperatorFamilyRelationId;

  referenced.objectId = opfamilyoid;

  referenced.objectSubId = 0;

  recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);

  /* dependency on indexed datatype */

  referenced.classId = TypeRelationId;

  referenced.objectId = typeoid;

  referenced.objectSubId = 0;

  recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

  /* dependency on storage datatype */

  if (OidIsValid(storageoid))

  {

    referenced.classId = TypeRelationId;

    referenced.objectId = storageoid;

    referenced.objectSubId = 0;

    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

  }

  /* dependency on owner */

  recordDependencyOnOwner(OperatorClassRelationId, opclassoid, GetUserId());

  /* dependency on extension */

  recordDependencyOnCurrentExtension(&myself, false);

  /* Post creation hook for new operator class */

  InvokeObjectPostCreateHook(OperatorClassRelationId, opclassoid, 0);

  table_close(rel, RowExclusiveLock);

  return myself;

}

/*

 * DefineOpFamily

 *    Define a new index operator family.

 */

ObjectAddress

DefineOpFamily(CreateOpFamilyStmt *stmt)

{

  char     *opfname;    /* name of opfamily we're creating */

  Oid     amoid,      /* our AM's oid */

        namespaceoid; /* namespace to create opfamily in */

  AclResult aclresult;

  /* Convert list of names to a name and namespace */

  namespaceoid = QualifiedNameGetCreationNamespace(stmt->opfamilyname,

                           &opfname);

  /* Check we have creation rights in target namespace */

  aclresult = object_aclcheck(NamespaceRelationId, namespaceoid, GetUserId(), ACL_CREATE);

  if (aclresult != ACLCHECK_OK)

    aclcheck_error(aclresult, OBJECT_SCHEMA,

             get_namespace_name(namespaceoid));

  /* Get access method OID, throwing an error if it doesn't exist. */

  amoid = get_index_am_oid(stmt->amname, false);

  /* XXX Should we make any privilege check against the AM? */

  /*

   * Currently, we require superuser privileges to create an opfamily. See

   * comments in DefineOpClass.

   */

  if (!superuser())

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("must be superuser to create an operator family")));

  /* Insert pg_opfamily catalog entry */

  return CreateOpFamily(stmt, opfname, namespaceoid, amoid);

}

/*

 * AlterOpFamily

 *    Add or remove operators/procedures within an existing operator family.

 *

 * Note: this implements only ALTER OPERATOR FAMILY ... ADD/DROP.  Some

 * other commands called ALTER OPERATOR FAMILY exist, but go through

 * different code paths.

 */

Oid

AlterOpFamily(AlterOpFamilyStmt *stmt)

{

  Oid     amoid,      /* our AM's oid */

        opfamilyoid;  /* oid of opfamily */

  int     maxOpNumber,  /* amstrategies value */

        optsProcNumber, /* amoptsprocnum value */

        maxProcNumber;  /* amsupport value */

  HeapTuple tup;

  Form_pg_am  amform;

  const IndexAmRoutine *amroutine;

  /* Get necessary info about access method */

  tup = SearchSysCache1(AMNAME, CStringGetDatum(stmt->amname));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("access method \"%s\" does not exist",

            stmt->amname)));

  amform = (Form_pg_am) GETSTRUCT(tup);

  amoid = amform->oid;

  amroutine = GetIndexAmRoutineByAmId(amoid, false);

  ReleaseSysCache(tup);

  maxOpNumber = amroutine->amstrategies;

  /* if amstrategies is zero, just enforce that op numbers fit in int16 */

  if (maxOpNumber <= 0)

    maxOpNumber = SHRT_MAX;

  maxProcNumber = amroutine->amsupport;

  optsProcNumber = amroutine->amoptsprocnum;

  /* XXX Should we make any privilege check against the AM? */

  /* Look up the opfamily */

  opfamilyoid = get_opfamily_oid(amoid, stmt->opfamilyname, false);

  /*

   * Currently, we require superuser privileges to alter an opfamily.

   *

   * XXX re-enable NOT_USED code sections below if you remove this test.

   */

  if (!superuser())

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("must be superuser to alter an operator family")));

  /*

   * ADD and DROP cases need separate code from here on down.

   */

  if (stmt->isDrop)

    AlterOpFamilyDrop(stmt, amoid, opfamilyoid,

              maxOpNumber, maxProcNumber, stmt->items);

  else

    AlterOpFamilyAdd(stmt, amoid, opfamilyoid,

             maxOpNumber, maxProcNumber, optsProcNumber,

             stmt->items);

  return opfamilyoid;

}

/*

 * ADD part of ALTER OP FAMILY

 */

static void

AlterOpFamilyAdd(AlterOpFamilyStmt *stmt, Oid amoid, Oid opfamilyoid,

         int maxOpNumber, int maxProcNumber, int optsProcNumber,

         List *items)

{

  const IndexAmRoutine *amroutine = GetIndexAmRoutineByAmId(amoid, false);

  List     *operators;    /* OpFamilyMember list for operators */

  List     *procedures;   /* OpFamilyMember list for support procs */

  ListCell   *l;

  operators = NIL;

  procedures = NIL;

  /*

   * Scan the "items" list to obtain additional info.

   */

  foreach(l, items)

  {

    CreateOpClassItem *item = lfirst_node(CreateOpClassItem, l);

    Oid     operOid;

    Oid     funcOid;

    Oid     sortfamilyOid;

    OpFamilyMember *member;

    switch (item->itemtype)

    {