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

 *

 * event_trigger.c

 *    PostgreSQL EVENT TRIGGER 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/event_trigger.c

 *

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

 */

#include "postgres.h"

#include "access/genam.h"

#include "access/heapam.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/objectaccess.h"

#include "catalog/pg_attrdef.h"

#include "catalog/pg_authid.h"

#include "catalog/pg_auth_members.h"

#include "catalog/pg_database.h"

#include "catalog/pg_event_trigger.h"

#include "catalog/pg_namespace.h"

#include "catalog/pg_opclass.h"

#include "catalog/pg_opfamily.h"

#include "catalog/pg_parameter_acl.h"

#include "catalog/pg_policy.h"

#include "catalog/pg_proc.h"

#include "catalog/pg_tablespace.h"

#include "catalog/pg_trigger.h"

#include "catalog/pg_ts_config.h"

#include "catalog/pg_type.h"

#include "commands/event_trigger.h"

#include "commands/extension.h"

#include "commands/trigger.h"

#include "funcapi.h"

#include "lib/ilist.h"

#include "miscadmin.h"

#include "parser/parse_func.h"

#include "pgstat.h"

#include "storage/lmgr.h"

#include "tcop/deparse_utility.h"

#include "tcop/utility.h"

#include "utils/acl.h"

#include "utils/builtins.h"

#include "utils/evtcache.h"

#include "utils/fmgroids.h"

#include "utils/fmgrprotos.h"

#include "utils/lsyscache.h"

#include "utils/memutils.h"

#include "utils/rel.h"

#include "utils/snapmgr.h"

#include "utils/syscache.h"

#include "utils/tuplestore.h"

typedef struct EventTriggerQueryState

{

  /* memory context for this state's objects */

  MemoryContext cxt;

  /* sql_drop */

  slist_head  SQLDropList;

  bool    in_sql_drop;

  /* table_rewrite */

  Oid     table_rewrite_oid;  /* InvalidOid, or set for table_rewrite

                   * event */

  int     table_rewrite_reason; /* AT_REWRITE reason */

  /* Support for command collection */

  bool    commandCollectionInhibited;

  CollectedCommand *currentCommand;

  List     *commandList;  /* list of CollectedCommand; see

                 * deparse_utility.h */

  struct EventTriggerQueryState *previous;

} EventTriggerQueryState;

static EventTriggerQueryState *currentEventTriggerState = NULL;

/* GUC parameter */

bool    event_triggers = true;

/* Support for dropped objects */

typedef struct SQLDropObject

{

  ObjectAddress address;

  const char *schemaname;

  const char *objname;

  const char *objidentity;

  const char *objecttype;

  List     *addrnames;

  List     *addrargs;

  bool    original;

  bool    normal;

  bool    istemp;

  slist_node  next;

} SQLDropObject;

static void AlterEventTriggerOwner_internal(Relation rel,

                      HeapTuple tup,

                      Oid newOwnerId);

static void error_duplicate_filter_variable(const char *defname);

static Datum filter_list_to_array(List *filterlist);

static Oid  insert_event_trigger_tuple(const char *trigname, const char *eventname,

                     Oid evtOwner, Oid funcoid, List *taglist);

static void validate_ddl_tags(const char *filtervar, List *taglist);

static void validate_table_rewrite_tags(const char *filtervar, List *taglist);

static void EventTriggerInvoke(List *fn_oid_list, EventTriggerData *trigdata);

static bool obtain_object_name_namespace(const ObjectAddress *object,

                     SQLDropObject *obj);

static const char *stringify_grant_objtype(ObjectType objtype);

static const char *stringify_adefprivs_objtype(ObjectType objtype);

static void SetDatabaseHasLoginEventTriggers(void);

/*

 * Create an event trigger.

 */

Oid

CreateEventTrigger(CreateEventTrigStmt *stmt)

{

  HeapTuple tuple;

  Oid     funcoid;

  Oid     funcrettype;

  Oid     evtowner = GetUserId();

  ListCell   *lc;

  List     *tags = NULL;

  /*

   * It would be nice to allow database owners or even regular users to do

   * this, but there are obvious privilege escalation risks which would have

   * to somehow be plugged first.

   */

  if (!superuser())

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("permission denied to create event trigger \"%s\"",

            stmt->trigname),

         errhint("Must be superuser to create an event trigger.")));

  /* Validate event name. */

  if (strcmp(stmt->eventname, "ddl_command_start") != 0 &&

    strcmp(stmt->eventname, "ddl_command_end") != 0 &&

    strcmp(stmt->eventname, "sql_drop") != 0 &&

    strcmp(stmt->eventname, "login") != 0 &&

    strcmp(stmt->eventname, "table_rewrite") != 0)

    ereport(ERROR,

        (errcode(ERRCODE_SYNTAX_ERROR),

         errmsg("unrecognized event name \"%s\"",

            stmt->eventname)));

  /* Validate filter conditions. */

  foreach(lc, stmt->whenclause)

  {

    DefElem    *def = (DefElem *) lfirst(lc);

    if (strcmp(def->defname, "tag") == 0)

    {

      if (tags != NULL)

        error_duplicate_filter_variable(def->defname);

      tags = (List *) def->arg;

    }

    else

      ereport(ERROR,

          (errcode(ERRCODE_SYNTAX_ERROR),

           errmsg("unrecognized filter variable \"%s\"", def->defname)));

  }

  /* Validate tag list, if any. */

  if ((strcmp(stmt->eventname, "ddl_command_start") == 0 ||

     strcmp(stmt->eventname, "ddl_command_end") == 0 ||

     strcmp(stmt->eventname, "sql_drop") == 0)

    && tags != NULL)

    validate_ddl_tags("tag", tags);

  else if (strcmp(stmt->eventname, "table_rewrite") == 0

       && tags != NULL)

    validate_table_rewrite_tags("tag", tags);

  else if (strcmp(stmt->eventname, "login") == 0 && tags != NULL)

    ereport(ERROR,

        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

         errmsg("tag filtering is not supported for login event triggers")));

  /*

   * Give user a nice error message if an event trigger of the same name

   * already exists.

   */

  tuple = SearchSysCache1(EVENTTRIGGERNAME, CStringGetDatum(stmt->trigname));

  if (HeapTupleIsValid(tuple))

    ereport(ERROR,

        (errcode(ERRCODE_DUPLICATE_OBJECT),

         errmsg("event trigger \"%s\" already exists",

            stmt->trigname)));

  /* Find and validate the trigger function. */

  funcoid = LookupFuncName(stmt->funcname, 0, NULL, false);

  funcrettype = get_func_rettype(funcoid);

  if (funcrettype != EVENT_TRIGGEROID)

    ereport(ERROR,

        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),

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

            NameListToString(stmt->funcname), "event_trigger")));

  /* Insert catalog entries. */

  return insert_event_trigger_tuple(stmt->trigname, stmt->eventname,

                    evtowner, funcoid, tags);

}

/*

 * Validate DDL command tags.

 */

static void

validate_ddl_tags(const char *filtervar, List *taglist)

{

  ListCell   *lc;

  foreach(lc, taglist)

  {

    const char *tagstr = strVal(lfirst(lc));

    CommandTag  commandTag = GetCommandTagEnum(tagstr);

    if (commandTag == CMDTAG_UNKNOWN)

      ereport(ERROR,

          (errcode(ERRCODE_SYNTAX_ERROR),

           errmsg("filter value \"%s\" not recognized for filter variable \"%s\"",

              tagstr, filtervar)));

    if (!command_tag_event_trigger_ok(commandTag))

      ereport(ERROR,

          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

      /* translator: %s represents an SQL statement name */

           errmsg("event triggers are not supported for %s",

              tagstr)));

  }

}

/*

 * Validate DDL command tags for event table_rewrite.

 */

static void

validate_table_rewrite_tags(const char *filtervar, List *taglist)

{

  ListCell   *lc;

  foreach(lc, taglist)

  {

    const char *tagstr = strVal(lfirst(lc));

    CommandTag  commandTag = GetCommandTagEnum(tagstr);

    if (!command_tag_table_rewrite_ok(commandTag))

      ereport(ERROR,

          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

      /* translator: %s represents an SQL statement name */

           errmsg("event triggers are not supported for %s",

              tagstr)));

  }

}

/*

 * Complain about a duplicate filter variable.

 */

static void

error_duplicate_filter_variable(const char *defname)

{

  ereport(ERROR,

      (errcode(ERRCODE_SYNTAX_ERROR),

       errmsg("filter variable \"%s\" specified more than once",

          defname)));

}

/*

 * Insert the new pg_event_trigger row and record dependencies.

 */

static Oid

insert_event_trigger_tuple(const char *trigname, const char *eventname, Oid evtOwner,

               Oid funcoid, List *taglist)

{

  Relation  tgrel;

  Oid     trigoid;

  HeapTuple tuple;

  Datum   values[Natts_pg_event_trigger];

  bool    nulls[Natts_pg_event_trigger];

  NameData  evtnamedata,

        evteventdata;

  ObjectAddress myself,

        referenced;

  /* Open pg_event_trigger. */

  tgrel = table_open(EventTriggerRelationId, RowExclusiveLock);

  /* Build the new pg_trigger tuple. */

  trigoid = GetNewOidWithIndex(tgrel, EventTriggerOidIndexId,

                 Anum_pg_event_trigger_oid);

  values[Anum_pg_event_trigger_oid - 1] = ObjectIdGetDatum(trigoid);

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

  namestrcpy(&evtnamedata, trigname);

  values[Anum_pg_event_trigger_evtname - 1] = NameGetDatum(&evtnamedata);

  namestrcpy(&evteventdata, eventname);

  values[Anum_pg_event_trigger_evtevent - 1] = NameGetDatum(&evteventdata);

  values[Anum_pg_event_trigger_evtowner - 1] = ObjectIdGetDatum(evtOwner);

  values[Anum_pg_event_trigger_evtfoid - 1] = ObjectIdGetDatum(funcoid);

  values[Anum_pg_event_trigger_evtenabled - 1] =

    CharGetDatum(TRIGGER_FIRES_ON_ORIGIN);

  if (taglist == NIL)

    nulls[Anum_pg_event_trigger_evttags - 1] = true;

  else

    values[Anum_pg_event_trigger_evttags - 1] =

      filter_list_to_array(taglist);

  /* Insert heap tuple. */

  tuple = heap_form_tuple(tgrel->rd_att, values, nulls);

  CatalogTupleInsert(tgrel, tuple);

  heap_freetuple(tuple);

  /*

   * Login event triggers have an additional flag in pg_database to enable

   * faster lookups in hot codepaths. Set the flag unless already True.

   */

  if (strcmp(eventname, "login") == 0)

    SetDatabaseHasLoginEventTriggers();

  /* Depend on owner. */

  recordDependencyOnOwner(EventTriggerRelationId, trigoid, evtOwner);

  /* Depend on event trigger function. */

  myself.classId = EventTriggerRelationId;

  myself.objectId = trigoid;

  myself.objectSubId = 0;

  referenced.classId = ProcedureRelationId;

  referenced.objectId = funcoid;

  referenced.objectSubId = 0;

  recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

  /* Depend on extension, if any. */

  recordDependencyOnCurrentExtension(&myself, false);

  /* Post creation hook for new event trigger */

  InvokeObjectPostCreateHook(EventTriggerRelationId, trigoid, 0);

  /* Close pg_event_trigger. */

  table_close(tgrel, RowExclusiveLock);

  return trigoid;

}

/*

 * In the parser, a clause like WHEN tag IN ('cmd1', 'cmd2') is represented

 * by a DefElem whose value is a List of String nodes; in the catalog, we

 * store the list of strings as a text array.  This function transforms the

 * former representation into the latter one.

 *

 * For cleanliness, we store command tags in the catalog as text.  It's

 * possible (although not currently anticipated) that we might have

 * a case-sensitive filter variable in the future, in which case this would

 * need some further adjustment.

 */

static Datum

filter_list_to_array(List *filterlist)

{

  ListCell   *lc;

  Datum    *data;

  int     i = 0,

        l = list_length(filterlist);

  data = palloc_array(Datum, l);

  foreach(lc, filterlist)

  {

    const char *value = strVal(lfirst(lc));

    char     *result,

           *p;

    result = pstrdup(value);

    for (p = result; *p; p++)

      *p = pg_ascii_toupper((unsigned char) *p);

    data[i++] = PointerGetDatum(cstring_to_text(result));

    pfree(result);

  }

  return PointerGetDatum(construct_array_builtin(data, l, TEXTOID));

}

/*

 * Set pg_database.dathasloginevt flag for current database indicating that

 * current database has on login event triggers.

 */

void

SetDatabaseHasLoginEventTriggers(void)

{

  /* Set dathasloginevt flag in pg_database */

  Form_pg_database db;

  Relation  pg_db = table_open(DatabaseRelationId, RowExclusiveLock);

  ItemPointerData otid;

  HeapTuple tuple;

  /*

   * Use shared lock to prevent a conflict with EventTriggerOnLogin() trying

   * to reset pg_database.dathasloginevt flag.  Note, this lock doesn't

   * effectively blocks database or other objection.  It's just custom lock

   * tag used to prevent multiple backends changing

   * pg_database.dathasloginevt flag.

   */

  LockSharedObject(DatabaseRelationId, MyDatabaseId, 0, AccessExclusiveLock);

  tuple = SearchSysCacheLockedCopy1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));

  if (!HeapTupleIsValid(tuple))

    elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);

  otid = tuple->t_self;

  db = (Form_pg_database) GETSTRUCT(tuple);

  if (!db->dathasloginevt)

  {

    db->dathasloginevt = true;

    CatalogTupleUpdate(pg_db, &otid, tuple);

    CommandCounterIncrement();

  }

  UnlockTuple(pg_db, &otid, InplaceUpdateTupleLock);

  table_close(pg_db, RowExclusiveLock);

  heap_freetuple(tuple);

}

/*

 * ALTER EVENT TRIGGER foo ENABLE|DISABLE|ENABLE ALWAYS|REPLICA

 */

Oid

AlterEventTrigger(AlterEventTrigStmt *stmt)

{

  Relation  tgrel;

  HeapTuple tup;

  Oid     trigoid;

  Form_pg_event_trigger evtForm;

  char    tgenabled = stmt->tgenabled;

  tgrel = table_open(EventTriggerRelationId, RowExclusiveLock);

  tup = SearchSysCacheCopy1(EVENTTRIGGERNAME,

                CStringGetDatum(stmt->trigname));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("event trigger \"%s\" does not exist",

            stmt->trigname)));

  evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);

  trigoid = evtForm->oid;

  if (!object_ownercheck(EventTriggerRelationId, trigoid, GetUserId()))

    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EVENT_TRIGGER,

             stmt->trigname);

  /* tuple is a copy, so we can modify it below */

  evtForm->evtenabled = tgenabled;

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

  /*

   * Login event triggers have an additional flag in pg_database to enable

   * faster lookups in hot codepaths. Set the flag unless already True.

   */

  if (namestrcmp(&evtForm->evtevent, "login") == 0 &&

    tgenabled != TRIGGER_DISABLED)

    SetDatabaseHasLoginEventTriggers();

  InvokeObjectPostAlterHook(EventTriggerRelationId,

                trigoid, 0);

  /* clean up */

  heap_freetuple(tup);

  table_close(tgrel, RowExclusiveLock);

  return trigoid;

}

/*

 * Change event trigger's owner -- by name

 */

ObjectAddress

AlterEventTriggerOwner(const char *name, Oid newOwnerId)

{

  Oid     evtOid;

  HeapTuple tup;

  Form_pg_event_trigger evtForm;

  Relation  rel;

  ObjectAddress address;

  rel = table_open(EventTriggerRelationId, RowExclusiveLock);

  tup = SearchSysCacheCopy1(EVENTTRIGGERNAME, CStringGetDatum(name));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("event trigger \"%s\" does not exist", name)));

  evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);

  evtOid = evtForm->oid;

  AlterEventTriggerOwner_internal(rel, tup, newOwnerId);

  ObjectAddressSet(address, EventTriggerRelationId, evtOid);

  heap_freetuple(tup);

  table_close(rel, RowExclusiveLock);

  return address;

}

/*

 * Change event trigger owner, by OID

 */

void

AlterEventTriggerOwner_oid(Oid trigOid, Oid newOwnerId)

{

  HeapTuple tup;

  Relation  rel;

  rel = table_open(EventTriggerRelationId, RowExclusiveLock);

  tup = SearchSysCacheCopy1(EVENTTRIGGEROID, ObjectIdGetDatum(trigOid));

  if (!HeapTupleIsValid(tup))

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("event trigger with OID %u does not exist", trigOid)));

  AlterEventTriggerOwner_internal(rel, tup, newOwnerId);

  heap_freetuple(tup);

  table_close(rel, RowExclusiveLock);

}

/*

 * Internal workhorse for changing an event trigger's owner

 */

static void

AlterEventTriggerOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)

{

  Form_pg_event_trigger form;

  form = (Form_pg_event_trigger) GETSTRUCT(tup);

  if (form->evtowner == newOwnerId)

    return;

  if (!object_ownercheck(EventTriggerRelationId, form->oid, GetUserId()))

    aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EVENT_TRIGGER,

             NameStr(form->evtname));

  /* New owner must be a superuser */

  if (!superuser_arg(newOwnerId))

    ereport(ERROR,

        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),

         errmsg("permission denied to change owner of event trigger \"%s\"",

            NameStr(form->evtname)),

         errhint("The owner of an event trigger must be a superuser.")));

  form->evtowner = newOwnerId;

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

  /* Update owner dependency reference */

  changeDependencyOnOwner(EventTriggerRelationId,

              form->oid,

              newOwnerId);

  InvokeObjectPostAlterHook(EventTriggerRelationId,

                form->oid, 0);

}

/*

 * get_event_trigger_oid - Look up an event trigger by name to find its OID.

 *

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

 * true, just return InvalidOid.

 */

Oid

get_event_trigger_oid(const char *trigname, bool missing_ok)

{

  Oid     oid;

  oid = GetSysCacheOid1(EVENTTRIGGERNAME, Anum_pg_event_trigger_oid,

              CStringGetDatum(trigname));

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

    ereport(ERROR,

        (errcode(ERRCODE_UNDEFINED_OBJECT),

         errmsg("event trigger \"%s\" does not exist", trigname)));

  return oid;

}

/*

 * Return true when we want to fire given Event Trigger and false otherwise,

 * filtering on the session replication role and the event trigger registered

 * tags matching.

 */

static bool

filter_event_trigger(CommandTag tag, EventTriggerCacheItem *item)

{

  /*

   * Filter by session replication role, knowing that we never see disabled

   * items down here.

   */

  if (SessionReplicationRole == SESSION_REPLICATION_ROLE_REPLICA)

  {

    if (item->enabled == TRIGGER_FIRES_ON_ORIGIN)

      return false;

  }

  else

  {

    if (item->enabled == TRIGGER_FIRES_ON_REPLICA)

      return false;

  }

  /* Filter by tags, if any were specified. */

  if (!bms_is_empty(item->tagset) && !bms_is_member(tag, item->tagset))

    return false;

  /* if we reach that point, we're not filtering out this item */

  return true;

}

static CommandTag

EventTriggerGetTag(Node *parsetree, EventTriggerEvent event)

{

  if (event == EVT_Login)

    return CMDTAG_LOGIN;

  else

    return CreateCommandTag(parsetree);

}

/*

 * Setup for running triggers for the given event.  Return value is an OID list

 * of functions to run; if there are any, trigdata is filled with an

 * appropriate EventTriggerData for them to receive.

 */

static List *

EventTriggerCommonSetup(Node *parsetree,

            EventTriggerEvent event, const char *eventstr,

            EventTriggerData *trigdata, bool unfiltered)

{

  CommandTag  tag;

  List     *cachelist;

  ListCell   *lc;

  List     *runlist = NIL;

  /*

   * We want the list of command tags for which this procedure is actually

   * invoked to match up exactly with the list that CREATE EVENT TRIGGER

   * accepts.  This debugging cross-check will throw an error if this

   * function is invoked for a command tag that CREATE EVENT TRIGGER won't

   * accept.  (Unfortunately, there doesn't seem to be any simple, automated

   * way to verify that CREATE EVENT TRIGGER doesn't accept extra stuff that

   * never reaches this control point.)

   *

   * If this cross-check fails for you, you probably need to either adjust

   * standard_ProcessUtility() not to invoke event triggers for the command

   * type in question, or you need to adjust event_trigger_ok to accept the

   * relevant command tag.

   */

#ifdef USE_ASSERT_CHECKING

  {

    CommandTag  dbgtag;

    dbgtag = EventTriggerGetTag(parsetree, event);

    if (event == EVT_DDLCommandStart ||

      event == EVT_DDLCommandEnd ||

      event == EVT_SQLDrop ||

      event == EVT_Login)

    {

      if (!command_tag_event_trigger_ok(dbgtag))

        elog(ERROR, "unexpected command tag \"%s\"", GetCommandTagName(dbgtag));

    }

    else if (event == EVT_TableRewrite)

    {

      if (!command_tag_table_rewrite_ok(dbgtag))

        elog(ERROR, "unexpected command tag \"%s\"", GetCommandTagName(dbgtag));

    }

  }

#endif

  /* Use cache to find triggers for this event; fast exit if none. */

  cachelist = EventCacheLookup(event);

  if (cachelist == NIL)

    return NIL;

  /* Get the command tag. */

  tag = EventTriggerGetTag(parsetree, event);

  /*

   * Filter list of event triggers by command tag, and copy them into our

   * memory context.  Once we start running the command triggers, or indeed

   * once we do anything at all that touches the catalogs, an invalidation

   * might leave cachelist pointing at garbage, so we must do this before we

   * can do much else.

   */

  foreach(lc, cachelist)

  {

    EventTriggerCacheItem *item = lfirst(lc);

    if (unfiltered || filter_event_trigger(tag, item))

    {

      /* We must plan to fire this trigger. */

      runlist = lappend_oid(runlist, item->fnoid);

    }

  }

  /* Don't spend any more time on this if no functions to run */

  if (runlist == NIL)

    return NIL;

  trigdata->type = T_EventTriggerData;

  trigdata->event = eventstr;

  trigdata->parsetree = parsetree;

  trigdata->tag = tag;

  return runlist;

}

/*

 * Fire ddl_command_start triggers.

 */

void

EventTriggerDDLCommandStart(Node *parsetree)

{

  List     *runlist;

  EventTriggerData trigdata;

  /*

   * Event Triggers are completely disabled in standalone mode.  There are

   * (at least) two reasons for this:

   *

   * 1. A sufficiently broken event trigger might not only render the

   * database unusable, but prevent disabling itself to fix the situation.

   * In this scenario, restarting in standalone mode provides an escape

   * hatch.

   *

   * 2. BuildEventTriggerCache relies on systable_beginscan_ordered, and

   * therefore will malfunction if pg_event_trigger's indexes are damaged.

   * To allow recovery from a damaged index, we need some operating mode

   * wherein event triggers are disabled.  (Or we could implement

   * heapscan-and-sort logic for that case, but having disaster recovery

   * scenarios depend on code that's otherwise untested isn't appetizing.)

   *

   * Additionally, event triggers can be disabled with a superuser-only GUC

   * to make fixing database easier as per 1 above.

   */

  if (!IsUnderPostmaster || !event_triggers)

    return;

  runlist = EventTriggerCommonSetup(parsetree,

                    EVT_DDLCommandStart,

                    "ddl_command_start",

                    &trigdata, false);

  if (runlist == NIL)

    return;

  /* Run the triggers. */

  EventTriggerInvoke(runlist, &trigdata);

  /* Cleanup. */

  list_free(runlist);

  /*

   * Make sure anything the event triggers did will be visible to the main

   * command.

   */

  CommandCounterIncrement();

}

/*

 * Fire ddl_command_end triggers.

 */

void

EventTriggerDDLCommandEnd(Node *parsetree)

{

  List     *runlist;

  EventTriggerData trigdata;

  /*

   * See EventTriggerDDLCommandStart for a discussion about why event

   * triggers are disabled in single user mode or via GUC.

   */

  if (!IsUnderPostmaster || !event_triggers)

    return;

  /*

   * Also do nothing if our state isn't set up, which it won't be if there

   * weren't any relevant event triggers at the start of the current DDL

   * command.  This test might therefore seem optional, but it's important

   * because EventTriggerCommonSetup might find triggers that didn't exist

   * at the time the command started.  Although this function itself

   * wouldn't crash, the event trigger functions would presumably call

   * pg_event_trigger_ddl_commands which would fail.  Better to do nothing

   * until the next command.

   */

  if (!currentEventTriggerState)

    return;

  runlist = EventTriggerCommonSetup(parsetree,

                    EVT_DDLCommandEnd, "ddl_command_end",

                    &trigdata, false);

  if (runlist == NIL)

    return;

  /*

   * Make sure anything the main command did will be visible to the event

   * triggers.

   */

  CommandCounterIncrement();

  /* Run the triggers. */

  EventTriggerInvoke(runlist, &trigdata);

  /* Cleanup. */

  list_free(runlist);

}

/*

 * Fire sql_drop triggers.

 */

void

EventTriggerSQLDrop(Node *parsetree)

{

  List     *runlist;

  EventTriggerData trigdata;

  /*

   * See EventTriggerDDLCommandStart for a discussion about why event

   * triggers are disabled in single user mode or via a GUC.

   */

  if (!IsUnderPostmaster || !event_triggers)

    return;

  /*

   * Use current state to determine whether this event fires at all.  If

   * there are no triggers for the sql_drop event, then we don't have

   * anything to do here.  Note that dropped object collection is disabled

   * if this is the case, so even if we were to try to run, the list would

   * be empty.

   */

  if (!currentEventTriggerState ||

    slist_is_empty(&currentEventTriggerState->SQLDropList))

    return;

  runlist = EventTriggerCommonSetup(parsetree,

                    EVT_SQLDrop, "sql_drop",

                    &trigdata, false);

  /*

   * Nothing to do if run list is empty.  Note this typically can't happen,

   * because if there are no sql_drop events, then objects-to-drop wouldn't

   * have been collected in the first place and we would have quit above.

   * But it could occur if event triggers were dropped partway through.

   */

  if (runlist == NIL)

    return;

  /*

   * Make sure anything the main command did will be visible to the event

   * triggers.

   */

  CommandCounterIncrement();

  /*

   * Make sure pg_event_trigger_dropped_objects only works when running

   * these triggers.  Use PG_TRY to ensure in_sql_drop is reset even when

   * one trigger fails.  (This is perhaps not necessary, as the currentState

   * variable will be removed shortly by our caller, but it seems better to

   * play safe.)

   */

  currentEventTriggerState->in_sql_drop = true;

  /* Run the triggers. */

  PG_TRY();

  {

    EventTriggerInvoke(runlist, &trigdata);

  }

  PG_FINALLY();

  {

    currentEventTriggerState->in_sql_drop = false;

  }

  PG_END_TRY();

  /* Cleanup. */

  list_free(runlist);

}

/*

 * Fire login event triggers if any are present.  The dathasloginevt

 * pg_database flag is left unchanged when an event trigger is dropped to avoid

 * complicating the codepath in the case of multiple event triggers.  This

 * function will instead unset the flag if no trigger is defined.

 */

void

EventTriggerOnLogin(void)

{

  List     *runlist;

  EventTriggerData trigdata;

  /*

   * See EventTriggerDDLCommandStart for a discussion about why event

   * triggers are disabled in single user mode or via a GUC.  We also need a

   * database connection (some background workers don't have it).

   */

  if (!IsUnderPostmaster || !event_triggers ||

    !OidIsValid(MyDatabaseId) || !MyDatabaseHasLoginEventTriggers)

    return;

  StartTransactionCommand();

  runlist = EventTriggerCommonSetup(NULL,

                    EVT_Login, "login",

                    &trigdata, false);

  if (runlist != NIL)

  {

    /*

     * Event trigger execution may require an active snapshot.

     */

    PushActiveSnapshot(GetTransactionSnapshot());

    /* Run the triggers. */

    EventTriggerInvoke(runlist, &trigdata);

    /* Cleanup. */

    list_free(runlist);

    PopActiveSnapshot();

  }

  /*

   * There is no active login event trigger, but our

   * pg_database.dathasloginevt is set. Try to unset this flag.  We use the

   * lock to prevent concurrent SetDatabaseHasLoginEventTriggers(), but we

   * don't want to hang the connection waiting on the lock.  Thus, we are

   * just trying to acquire the lock conditionally.

   *

   * Skip this on a hot standby: the conditional AccessExclusiveLock on the

   * database object would fail with "cannot acquire lock mode ... while

   * recovery is in progress", which the caller would surface as a FATAL

   * connection error.  On a standby, we cannot (and must not) clear the

   * pg_database flag ourselves; it will be cleared via WAL replay once the

   * primary's next login event trigger run clears it on the primary.

   */

  else if (!RecoveryInProgress() &&

       ConditionalLockSharedObject(DatabaseRelationId, MyDatabaseId,

                     0, AccessExclusiveLock))

  {

    /*

     * The lock is held.  Now we need to recheck that login event triggers

     * list is still empty.  Once the list is empty, we know that even if

     * there is a backend which concurrently inserts/enables a login event

     * trigger, it will update pg_database.dathasloginevt *afterwards*.