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

 *

 * proclang.c

 *    PostgreSQL LANGUAGE support code.

 *

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

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

 *

 * IDENTIFICATION

 *    src/backend/commands/proclang.c

 *

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

 */

#include "postgres.h"

#include "access/htup_details.h"

#include "access/table.h"

#include "catalog/catalog.h"

#include "catalog/dependency.h"

#include "catalog/indexing.h"

#include "catalog/objectaccess.h"

#include "catalog/pg_language.h"

#include "catalog/pg_proc.h"

#include "catalog/pg_type.h"

#include "commands/proclang.h"

#include "miscadmin.h"

#include "parser/parse_func.h"

#include "utils/builtins.h"

#include "utils/lsyscache.h"

#include "utils/rel.h"

#include "utils/syscache.h"

/*

 * CREATE LANGUAGE

 */

ObjectAddress

CreateProceduralLanguage(CreatePLangStmt *stmt)

{

  const char *languageName = stmt->plname;

  Oid     languageOwner = GetUserId();

  Oid     handlerOid,

        inlineOid,

        valOid;

  Oid     funcrettype;

  Oid     funcargtypes[1];

  Relation  rel;

  TupleDesc tupDesc;

  Datum   values[Natts_pg_language];

  bool    nulls[Natts_pg_language];

  bool    replaces[Natts_pg_language];

  NameData  langname;

  HeapTuple oldtup;

  HeapTuple tup;

  Oid     langoid;

  bool    is_update;

  ObjectAddress myself,

        referenced;

  ObjectAddresses *addrs;

  /*

   * Check permission

   */

  if (!superuser())

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("must be superuser to create custom procedural language")));

  /*

   * Lookup the PL handler function and check that it is of the expected

   * return type

   */

  Assert(stmt->plhandler);

  handlerOid = LookupFuncName(stmt->plhandler, 0, NULL, false);

  funcrettype = get_func_rettype(handlerOid);

  if (funcrettype != LANGUAGE_HANDLEROID)

    ereport(ERROR,

        (errcode(ERRCODE_WRONG_OBJECT_TYPE),

         errmsg("function %s must return type %s",

            NameListToString(stmt->plhandler), "language_handler")));

  /* validate the inline function */

  if (stmt->plinline)

  {

    funcargtypes[0] = INTERNALOID;

    inlineOid = LookupFuncName(stmt->plinline, 1, funcargtypes, false);

    /* return value is ignored, so we don't check the type */

  }

  else

    inlineOid = InvalidOid;

  /* validate the validator function */

  if (stmt->plvalidator)

  {

    funcargtypes[0] = OIDOID;

    valOid = LookupFuncName(stmt->plvalidator, 1, funcargtypes, false);

    /* return value is ignored, so we don't check the type */

  }

  else

    valOid = InvalidOid;

  /* ok to create it */

  rel = table_open(LanguageRelationId, RowExclusiveLock);

  tupDesc = RelationGetDescr(rel);

  /* Prepare data to be inserted */

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

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

  memset(replaces, true, sizeof(replaces));

  namestrcpy(&langname, languageName);

  values[Anum_pg_language_lanname - 1] = NameGetDatum(&langname);

  values[Anum_pg_language_lanowner - 1] = ObjectIdGetDatum(languageOwner);

  values[Anum_pg_language_lanispl - 1] = BoolGetDatum(true);

  values[Anum_pg_language_lanpltrusted - 1] = BoolGetDatum(stmt->pltrusted);

  values[Anum_pg_language_lanplcallfoid - 1] = ObjectIdGetDatum(handlerOid);

  values[Anum_pg_language_laninline - 1] = ObjectIdGetDatum(inlineOid);

  values[Anum_pg_language_lanvalidator - 1] = ObjectIdGetDatum(valOid);

  nulls[Anum_pg_language_lanacl - 1] = true;

  /* Check for pre-existing definition */

  oldtup = SearchSysCache1(LANGNAME, PointerGetDatum(languageName));

  if (HeapTupleIsValid(oldtup))

  {

    Form_pg_language oldform = (Form_pg_language) GETSTRUCT(oldtup);

    /* There is one; okay to replace it? */

    if (!stmt->replace)

      ereport(ERROR,

          (errcode(ERRCODE_DUPLICATE_OBJECT),

           errmsg("language \"%s\" already exists", languageName)));

    /* This is currently pointless, since we already checked superuser */

#ifdef NOT_USED

    if (!object_ownercheck(LanguageRelationId, oldform->oid, languageOwner))

      aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_LANGUAGE,

               languageName);

#endif

    /*

     * Do not change existing oid, ownership or permissions.  Note

     * dependency-update code below has to agree with this decision.

     */

    replaces[Anum_pg_language_oid - 1] = false;

    replaces[Anum_pg_language_lanowner - 1] = false;

    replaces[Anum_pg_language_lanacl - 1] = false;

    /* Okay, do it... */

    tup = heap_modify_tuple(oldtup, tupDesc, values, nulls, replaces);

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

    langoid = oldform->oid;

    ReleaseSysCache(oldtup);

    is_update = true;

  }

  else

  {

    /* Creating a new language */

    langoid = GetNewOidWithIndex(rel, LanguageOidIndexId,

                   Anum_pg_language_oid);

    values[Anum_pg_language_oid - 1] = ObjectIdGetDatum(langoid);

    tup = heap_form_tuple(tupDesc, values, nulls);

    CatalogTupleInsert(rel, tup);

    is_update = false;

  }

  /*

   * Create dependencies for the new language.  If we are updating an

   * existing language, first delete any existing pg_depend entries.

   * (However, since we are not changing ownership or permissions, the

   * shared dependencies do *not* need to change, and we leave them alone.)

   */

  myself.classId = LanguageRelationId;

  myself.objectId = langoid;

  myself.objectSubId = 0;

  if (is_update)

    deleteDependencyRecordsFor(myself.classId, myself.objectId, true);

  /* dependency on owner of language */

  if (!is_update)

    recordDependencyOnOwner(myself.classId, myself.objectId,

                languageOwner);

  /* dependency on extension */

  recordDependencyOnCurrentExtension(&myself, is_update);

  addrs = new_object_addresses();

  /* dependency on the PL handler function */

  ObjectAddressSet(referenced, ProcedureRelationId, handlerOid);

  add_exact_object_address(&referenced, addrs);

  /* dependency on the inline handler function, if any */

  if (OidIsValid(inlineOid))

  {

    ObjectAddressSet(referenced, ProcedureRelationId, inlineOid);

    add_exact_object_address(&referenced, addrs);

  }

  /* dependency on the validator function, if any */

  if (OidIsValid(valOid))

  {

    ObjectAddressSet(referenced, ProcedureRelationId, valOid);

    add_exact_object_address(&referenced, addrs);

  }

  record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);

  free_object_addresses(addrs);

  /* Post creation hook for new procedural language */

  InvokeObjectPostCreateHook(LanguageRelationId, myself.objectId, 0);

  table_close(rel, RowExclusiveLock);

  return myself;

}

/*

 * get_language_oid - given a language name, look up the OID

 *

 * If missing_ok is false, throw an error if language name not found.  If

 * true, just return InvalidOid.

 */

Oid

get_language_oid(const char *langname, bool missing_ok)

{

  Oid     oid;

  oid = GetSysCacheOid1(LANGNAME, Anum_pg_language_oid,

              CStringGetDatum(langname));

  if (!OidIsValid(oid) && !missing_ok)

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("language \"%s\" does not exist", langname)));

  return oid;

}