event_trigger.c File Reference

#include "postgres.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_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_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 dependency graph for event_trigger.c:

Go to the source code of this file.

Data Structures
struct	EventTriggerQueryState
struct	SQLDropObject

Typedefs
typedef struct EventTriggerQueryState	EventTriggerQueryState
typedef struct SQLDropObject	SQLDropObject

Functions
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 const char *	stringify_grant_objtype (ObjectType objtype)
static const char *	stringify_adefprivs_objtype (ObjectType objtype)
static void	SetDatabaseHasLoginEventTriggers (void)
Oid	CreateEventTrigger (CreateEventTrigStmt *stmt)
Oid	AlterEventTrigger (AlterEventTrigStmt *stmt)
ObjectAddress	AlterEventTriggerOwner (const char *name, Oid newOwnerId)
void	AlterEventTriggerOwner_oid (Oid trigOid, Oid newOwnerId)
Oid	get_event_trigger_oid (const char *trigname, bool missing_ok)
static bool	filter_event_trigger (CommandTag tag, EventTriggerCacheItem *item)
static CommandTag	EventTriggerGetTag (Node *parsetree, EventTriggerEvent event)
static List *	EventTriggerCommonSetup (Node *parsetree, EventTriggerEvent event, const char *eventstr, EventTriggerData *trigdata, bool unfiltered)
void	EventTriggerDDLCommandStart (Node *parsetree)
void	EventTriggerDDLCommandEnd (Node *parsetree)
void	EventTriggerSQLDrop (Node *parsetree)
void	EventTriggerOnLogin (void)
void	EventTriggerTableRewrite (Node *parsetree, Oid tableOid, int reason)
bool	EventTriggerSupportsObjectType (ObjectType obtype)
bool	EventTriggerSupportsObject (const ObjectAddress *object)
bool	EventTriggerBeginCompleteQuery (void)
void	EventTriggerEndCompleteQuery (void)
bool	trackDroppedObjectsNeeded (void)
void	EventTriggerSQLDropAddObject (const ObjectAddress *object, bool original, bool normal)
Datum	pg_event_trigger_dropped_objects (PG_FUNCTION_ARGS)
Datum	pg_event_trigger_table_rewrite_oid (PG_FUNCTION_ARGS)
Datum	pg_event_trigger_table_rewrite_reason (PG_FUNCTION_ARGS)
void	EventTriggerInhibitCommandCollection (void)
void	EventTriggerUndoInhibitCommandCollection (void)
void	EventTriggerCollectSimpleCommand (ObjectAddress address, ObjectAddress secondaryObject, Node *parsetree)
void	EventTriggerAlterTableStart (Node *parsetree)
void	EventTriggerAlterTableRelid (Oid objectId)
void	EventTriggerCollectAlterTableSubcmd (Node *subcmd, ObjectAddress address)
void	EventTriggerAlterTableEnd (void)
void	EventTriggerCollectGrant (InternalGrant *istmt)
void	EventTriggerCollectAlterOpFam (AlterOpFamilyStmt *stmt, Oid opfamoid, List *operators, List *procedures)
void	EventTriggerCollectCreateOpClass (CreateOpClassStmt *stmt, Oid opcoid, List *operators, List *procedures)
void	EventTriggerCollectAlterTSConfig (AlterTSConfigurationStmt *stmt, Oid cfgId, Oid *dictIds, int ndicts)
void	EventTriggerCollectAlterDefPrivs (AlterDefaultPrivilegesStmt *stmt)
Datum	pg_event_trigger_ddl_commands (PG_FUNCTION_ARGS)

Variables
static EventTriggerQueryState *	currentEventTriggerState = NULL
bool	event_triggers = true

Typedef Documentation

EventTriggerQueryState

typedef struct EventTriggerQueryState EventTriggerQueryState

SQLDropObject

typedef struct SQLDropObject SQLDropObject

Function Documentation

AlterEventTrigger()

Oid AlterEventTrigger

(

AlterEventTrigStmt *

stmt

)

Definition at line 423 of file event_trigger.c.

{
    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;
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, CatalogTupleUpdate(), CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, GetUserId(), heap_freetuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, namestrcmp(), OBJECT_EVENT_TRIGGER, object_ownercheck(), RowExclusiveLock, SearchSysCacheCopy1, SetDatabaseHasLoginEventTriggers(), stmt, HeapTupleData::t_self, table_close(), table_open(), and TRIGGER_DISABLED.

Referenced by standard_ProcessUtility().

AlterEventTriggerOwner()

ObjectAddress AlterEventTriggerOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 475 of file event_trigger.c.

{
    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;
}

References AlterEventTriggerOwner_internal(), CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, name, ObjectAddressSet, RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by ExecAlterOwnerStmt().

AlterEventTriggerOwner_internal()

static void AlterEventTriggerOwner_internal ( Relation  rel, HeapTuple  tup, Oid  newOwnerId  )

static

Definition at line 535 of file event_trigger.c.

{
    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);
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, CatalogTupleUpdate(), changeDependencyOnOwner(), ereport, errcode(), errhint(), errmsg(), ERROR, GETSTRUCT, GetUserId(), InvokeObjectPostAlterHook, NameStr, OBJECT_EVENT_TRIGGER, object_ownercheck(), superuser_arg(), and HeapTupleData::t_self.

Referenced by AlterEventTriggerOwner(), and AlterEventTriggerOwner_oid().

AlterEventTriggerOwner_oid()

void AlterEventTriggerOwner_oid	(	Oid	trigOid,
		Oid	newOwnerId
	)

Definition at line 510 of file event_trigger.c.

{
    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);
}

References AlterEventTriggerOwner_internal(), ereport, errcode(), errmsg(), ERROR, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by shdepReassignOwned_Owner().

CreateEventTrigger()

Oid CreateEventTrigger

(

CreateEventTrigStmt *

stmt

)

Definition at line 120 of file event_trigger.c.

{
    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);
}

References DefElem::arg, CStringGetDatum(), DefElem::defname, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, error_duplicate_filter_variable(), get_func_rettype(), GetUserId(), HeapTupleIsValid, insert_event_trigger_tuple(), lfirst, LookupFuncName(), NameListToString(), SearchSysCache1(), stmt, superuser(), validate_ddl_tags(), and validate_table_rewrite_tags().

Referenced by standard_ProcessUtility().

error_duplicate_filter_variable()

static void error_duplicate_filter_variable ( const char *  defname )

static

Definition at line 261 of file event_trigger.c.

{
    ereport(ERROR,
            (errcode(ERRCODE_SYNTAX_ERROR),
             errmsg("filter variable \"%s\" specified more than once",
                    defname)));
}

References ereport, errcode(), errmsg(), and ERROR.

Referenced by CreateEventTrigger().

EventTriggerAlterTableEnd()

void EventTriggerAlterTableEnd

(

void

)

Definition at line 1713 of file event_trigger.c.

{
    CollectedCommand *parent;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    parent = currentEventTriggerState->currentCommand->parent;
 
    /* If no subcommands, don't collect */
    if (currentEventTriggerState->currentCommand->d.alterTable.subcmds != NIL)
    {
        MemoryContext oldcxt;
 
        oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
        currentEventTriggerState->commandList =
            lappend(currentEventTriggerState->commandList,
                    currentEventTriggerState->currentCommand);
 
        MemoryContextSwitchTo(oldcxt);
    }
    else
        pfree(currentEventTriggerState->currentCommand);
 
    currentEventTriggerState->currentCommand = parent;
}

References CollectedCommand::alterTable, EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, EventTriggerQueryState::currentCommand, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, lappend(), MemoryContextSwitchTo(), NIL, CollectedCommand::parent, and pfree().

Referenced by AlterTableMoveAll(), ProcessUtilityForAlterTable(), and ProcessUtilitySlow().

EventTriggerAlterTableRelid()

void EventTriggerAlterTableRelid

(

Oid

objectId

)

Definition at line 1660 of file event_trigger.c.

{
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    currentEventTriggerState->currentCommand->d.alterTable.objectId = objectId;
}

References CollectedCommand::alterTable, EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::currentCommand, currentEventTriggerState, and CollectedCommand::d.

Referenced by AlterTableInternal(), ProcessUtilityForAlterTable(), and ProcessUtilitySlow().

EventTriggerAlterTableStart()

void EventTriggerAlterTableStart

(

Node *

parsetree

)

Definition at line 1626 of file event_trigger.c.

{
    MemoryContext oldcxt;
    CollectedCommand *command;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    command = palloc(sizeof(CollectedCommand));
 
    command->type = SCT_AlterTable;
    command->in_extension = creating_extension;
 
    command->d.alterTable.classId = RelationRelationId;
    command->d.alterTable.objectId = InvalidOid;
    command->d.alterTable.subcmds = NIL;
    command->parsetree = copyObject(parsetree);
 
    command->parent = currentEventTriggerState->currentCommand;
    currentEventTriggerState->currentCommand = command;
 
    MemoryContextSwitchTo(oldcxt);
}

References CollectedCommand::alterTable, EventTriggerQueryState::commandCollectionInhibited, copyObject, creating_extension, EventTriggerQueryState::currentCommand, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, CollectedCommand::in_extension, InvalidOid, MemoryContextSwitchTo(), NIL, palloc(), CollectedCommand::parent, CollectedCommand::parsetree, SCT_AlterTable, and CollectedCommand::type.

Referenced by AlterTableMoveAll(), ProcessUtilityForAlterTable(), and ProcessUtilitySlow().

EventTriggerBeginCompleteQuery()

bool EventTriggerBeginCompleteQuery

(

void

)

Definition at line 1184 of file event_trigger.c.

{
    EventTriggerQueryState *state;
    MemoryContext cxt;
 
    /*
     * Currently, sql_drop, table_rewrite, ddl_command_end events are the only
     * reason to have event trigger state at all; so if there are none, don't
     * install one.
     */
    if (!trackDroppedObjectsNeeded())
        return false;
 
    cxt = AllocSetContextCreate(TopMemoryContext,
                                "event trigger state",
                                ALLOCSET_DEFAULT_SIZES);
    state = MemoryContextAlloc(cxt, sizeof(EventTriggerQueryState));
    state->cxt = cxt;
    slist_init(&(state->SQLDropList));
    state->in_sql_drop = false;
    state->table_rewrite_oid = InvalidOid;
 
    state->commandCollectionInhibited = currentEventTriggerState ?
        currentEventTriggerState->commandCollectionInhibited : false;
    state->currentCommand = NULL;
    state->commandList = NIL;
    state->previous = currentEventTriggerState;
    currentEventTriggerState = state;
 
    return true;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, EventTriggerQueryState::commandCollectionInhibited, currentEventTriggerState, InvalidOid, MemoryContextAlloc(), NIL, slist_init(), TopMemoryContext, and trackDroppedObjectsNeeded().

Referenced by ProcessUtilitySlow().

EventTriggerCollectAlterDefPrivs()

void EventTriggerCollectAlterDefPrivs

(

AlterDefaultPrivilegesStmt *

stmt

)

Definition at line 1897 of file event_trigger.c.

{
    MemoryContext oldcxt;
    CollectedCommand *command;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    command = palloc0(sizeof(CollectedCommand));
    command->type = SCT_AlterDefaultPrivileges;
    command->d.defprivs.objtype = stmt->action->objtype;
    command->in_extension = creating_extension;
    command->parsetree = (Node *) copyObject(stmt);
 
    currentEventTriggerState->commandList =
        lappend(currentEventTriggerState->commandList, command);
    MemoryContextSwitchTo(oldcxt);
}

References EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, CollectedCommand::defprivs, CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), palloc0(), CollectedCommand::parsetree, SCT_AlterDefaultPrivileges, stmt, and CollectedCommand::type.

Referenced by ProcessUtilitySlow().

EventTriggerCollectAlterOpFam()

void EventTriggerCollectAlterOpFam	(	AlterOpFamilyStmt *	stmt,
		Oid	opfamoid,
		List *	operators,
		List *	procedures
	)

Definition at line 1795 of file event_trigger.c.

{
    MemoryContext oldcxt;
    CollectedCommand *command;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    command = palloc(sizeof(CollectedCommand));
    command->type = SCT_AlterOpFamily;
    command->in_extension = creating_extension;
    ObjectAddressSet(command->d.opfam.address,
                     OperatorFamilyRelationId, opfamoid);
    command->d.opfam.operators = operators;
    command->d.opfam.procedures = procedures;
    command->parsetree = (Node *) copyObject(stmt);
 
    currentEventTriggerState->commandList =
        lappend(currentEventTriggerState->commandList, command);
 
    MemoryContextSwitchTo(oldcxt);
}

References EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), ObjectAddressSet, CollectedCommand::opfam, palloc(), CollectedCommand::parsetree, SCT_AlterOpFamily, stmt, and CollectedCommand::type.

Referenced by AlterOpFamilyAdd(), and AlterOpFamilyDrop().

EventTriggerCollectAlterTableSubcmd()

void EventTriggerCollectAlterTableSubcmd	(	Node *	subcmd,
		ObjectAddress	address
	)

Definition at line 1678 of file event_trigger.c.

{
    MemoryContext oldcxt;
    CollectedATSubcmd *newsub;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    Assert(IsA(subcmd, AlterTableCmd));
    Assert(currentEventTriggerState->currentCommand != NULL);
    Assert(OidIsValid(currentEventTriggerState->currentCommand->d.alterTable.objectId));
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    newsub = palloc(sizeof(CollectedATSubcmd));
    newsub->address = address;
    newsub->parsetree = copyObject(subcmd);
 
    currentEventTriggerState->currentCommand->d.alterTable.subcmds =
        lappend(currentEventTriggerState->currentCommand->d.alterTable.subcmds, newsub);
 
    MemoryContextSwitchTo(oldcxt);
}

References CollectedCommand::alterTable, Assert, EventTriggerQueryState::commandCollectionInhibited, copyObject, EventTriggerQueryState::currentCommand, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, IsA, lappend(), MemoryContextSwitchTo(), newsub(), OidIsValid, and palloc().

Referenced by ATExecCmd().

EventTriggerCollectAlterTSConfig()

void EventTriggerCollectAlterTSConfig	(	AlterTSConfigurationStmt *	stmt,
		Oid	cfgId,
		Oid *	dictIds,
		int	ndicts
	)

Definition at line 1862 of file event_trigger.c.

{
    MemoryContext oldcxt;
    CollectedCommand *command;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    command = palloc0(sizeof(CollectedCommand));
    command->type = SCT_AlterTSConfig;
    command->in_extension = creating_extension;
    ObjectAddressSet(command->d.atscfg.address,
                     TSConfigRelationId, cfgId);
    command->d.atscfg.dictIds = palloc(sizeof(Oid) * ndicts);
    memcpy(command->d.atscfg.dictIds, dictIds, sizeof(Oid) * ndicts);
    command->d.atscfg.ndicts = ndicts;
    command->parsetree = (Node *) copyObject(stmt);
 
    currentEventTriggerState->commandList =
        lappend(currentEventTriggerState->commandList, command);
 
    MemoryContextSwitchTo(oldcxt);
}

References CollectedCommand::atscfg, EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), ObjectAddressSet, palloc(), palloc0(), CollectedCommand::parsetree, SCT_AlterTSConfig, stmt, and CollectedCommand::type.

Referenced by DropConfigurationMapping(), and MakeConfigurationMapping().

EventTriggerCollectCreateOpClass()

void EventTriggerCollectCreateOpClass	(	CreateOpClassStmt *	stmt,
		Oid	opcoid,
		List *	operators,
		List *	procedures
	)

Definition at line 1828 of file event_trigger.c.

{
    MemoryContext oldcxt;
    CollectedCommand *command;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    command = palloc0(sizeof(CollectedCommand));
    command->type = SCT_CreateOpClass;
    command->in_extension = creating_extension;
    ObjectAddressSet(command->d.createopc.address,
                     OperatorClassRelationId, opcoid);
    command->d.createopc.operators = operators;
    command->d.createopc.procedures = procedures;
    command->parsetree = (Node *) copyObject(stmt);
 
    currentEventTriggerState->commandList =
        lappend(currentEventTriggerState->commandList, command);
 
    MemoryContextSwitchTo(oldcxt);
}

References EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, CollectedCommand::createopc, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), ObjectAddressSet, palloc0(), CollectedCommand::parsetree, SCT_CreateOpClass, stmt, and CollectedCommand::type.

Referenced by DefineOpClass().

EventTriggerCollectGrant()

void EventTriggerCollectGrant

(

InternalGrant *

istmt

)

Definition at line 1751 of file event_trigger.c.

{
    MemoryContext oldcxt;
    CollectedCommand *command;
    InternalGrant *icopy;
    ListCell   *cell;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    /*
     * This is tedious, but necessary.
     */
    icopy = palloc(sizeof(InternalGrant));
    memcpy(icopy, istmt, sizeof(InternalGrant));
    icopy->objects = list_copy(istmt->objects);
    icopy->grantees = list_copy(istmt->grantees);
    icopy->col_privs = NIL;
    foreach(cell, istmt->col_privs)
        icopy->col_privs = lappend(icopy->col_privs, copyObject(lfirst(cell)));
 
    /* Now collect it, using the copied InternalGrant */
    command = palloc(sizeof(CollectedCommand));
    command->type = SCT_Grant;
    command->in_extension = creating_extension;
    command->d.grant.istmt = icopy;
    command->parsetree = NULL;
 
    currentEventTriggerState->commandList =
        lappend(currentEventTriggerState->commandList, command);
 
    MemoryContextSwitchTo(oldcxt);
}

References InternalGrant::col_privs, EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, CollectedCommand::grant, InternalGrant::grantees, CollectedCommand::in_extension, lappend(), lfirst, list_copy(), MemoryContextSwitchTo(), NIL, InternalGrant::objects, palloc(), CollectedCommand::parsetree, SCT_Grant, and CollectedCommand::type.

Referenced by ExecGrantStmt_oids().

EventTriggerCollectSimpleCommand()

void EventTriggerCollectSimpleCommand	(	ObjectAddress	address,
		ObjectAddress	secondaryObject,
		Node *	parsetree
	)

Definition at line 1588 of file event_trigger.c.

{
    MemoryContext oldcxt;
    CollectedCommand *command;
 
    /* ignore if event trigger context not set, or collection disabled */
    if (!currentEventTriggerState ||
        currentEventTriggerState->commandCollectionInhibited)
        return;
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    command = palloc(sizeof(CollectedCommand));
 
    command->type = SCT_Simple;
    command->in_extension = creating_extension;
 
    command->d.simple.address = address;
    command->d.simple.secondaryObject = secondaryObject;
    command->parsetree = copyObject(parsetree);
 
    currentEventTriggerState->commandList = lappend(currentEventTriggerState->commandList,
                                                    command);
 
    MemoryContextSwitchTo(oldcxt);
}

References EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), palloc(), CollectedCommand::parsetree, SCT_Simple, CollectedCommand::simple, and CollectedCommand::type.

Referenced by AlterPublicationOptions(), CreateOpFamily(), CreateSchemaCommand(), ProcessUtilitySlow(), PublicationAddSchemas(), PublicationAddTables(), reindex_index(), and ReindexRelationConcurrently().

EventTriggerCommonSetup()

static List* EventTriggerCommonSetup ( Node *  parsetree, EventTriggerEvent  event, const char *  eventstr, EventTriggerData *  trigdata, bool  unfiltered  )

static

Definition at line 634 of file event_trigger.c.

{
    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;
}

References command_tag_event_trigger_ok(), command_tag_table_rewrite_ok(), elog, ERROR, EventTriggerData::event, EventCacheLookup(), EventTriggerGetTag(), EVT_DDLCommandEnd, EVT_DDLCommandStart, EVT_Login, EVT_SQLDrop, EVT_TableRewrite, filter_event_trigger(), EventTriggerCacheItem::fnoid, GetCommandTagName(), lappend_oid(), lfirst, NIL, EventTriggerData::parsetree, EventTriggerData::tag, and EventTriggerData::type.

Referenced by EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerOnLogin(), EventTriggerSQLDrop(), and EventTriggerTableRewrite().

EventTriggerDDLCommandEnd()

void EventTriggerDDLCommandEnd

(

Node *

parsetree

)

Definition at line 772 of file event_trigger.c.

{
    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);
}

References CommandCounterIncrement(), currentEventTriggerState, event_triggers, EventTriggerCommonSetup(), EventTriggerInvoke(), EVT_DDLCommandEnd, IsUnderPostmaster, list_free(), and NIL.

Referenced by ProcessUtilitySlow().

EventTriggerDDLCommandStart()

void EventTriggerDDLCommandStart

(

Node *

parsetree

)

Definition at line 721 of file event_trigger.c.

{
    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();
}

References CommandCounterIncrement(), event_triggers, EventTriggerCommonSetup(), EventTriggerInvoke(), EVT_DDLCommandStart, IsUnderPostmaster, list_free(), and NIL.

Referenced by ProcessUtilitySlow().

EventTriggerEndCompleteQuery()

void EventTriggerEndCompleteQuery

(

void

)

Definition at line 1228 of file event_trigger.c.

{
    EventTriggerQueryState *prevstate;
 
    prevstate = currentEventTriggerState->previous;
 
    /* this avoids the need for retail pfree of SQLDropList items: */
    MemoryContextDelete(currentEventTriggerState->cxt);
 
    currentEventTriggerState = prevstate;
}

References currentEventTriggerState, EventTriggerQueryState::cxt, MemoryContextDelete(), and EventTriggerQueryState::previous.

Referenced by ProcessUtilitySlow().

EventTriggerGetTag()

static CommandTag EventTriggerGetTag ( Node *  parsetree, EventTriggerEvent  event  )

static

Definition at line 620 of file event_trigger.c.

{
    if (event == EVT_Login)
        return CMDTAG_LOGIN;
    else
        return CreateCommandTag(parsetree);
}

References CreateCommandTag(), and EVT_Login.

Referenced by EventTriggerCommonSetup().

EventTriggerInhibitCommandCollection()

void EventTriggerInhibitCommandCollection

(

void

)

Definition at line 1554 of file event_trigger.c.

{
    if (!currentEventTriggerState)
        return;
 
    currentEventTriggerState->commandCollectionInhibited = true;
}

References EventTriggerQueryState::commandCollectionInhibited, and currentEventTriggerState.

Referenced by ProcessUtilitySlow().

EventTriggerInvoke()

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

static

Definition at line 1069 of file event_trigger.c.

{
    MemoryContext context;
    MemoryContext oldcontext;
    ListCell   *lc;
    bool        first = true;
 
    /* Guard against stack overflow due to recursive event trigger */
    check_stack_depth();
 
    /*
     * Let's evaluate event triggers in their own memory context, so that any
     * leaks get cleaned up promptly.
     */
    context = AllocSetContextCreate(CurrentMemoryContext,
                                    "event trigger context",
                                    ALLOCSET_DEFAULT_SIZES);
    oldcontext = MemoryContextSwitchTo(context);
 
    /* Call each event trigger. */
    foreach(lc, fn_oid_list)
    {
        LOCAL_FCINFO(fcinfo, 0);
        Oid         fnoid = lfirst_oid(lc);
        FmgrInfo    flinfo;
        PgStat_FunctionCallUsage fcusage;
 
        elog(DEBUG1, "EventTriggerInvoke %u", fnoid);
 
        /*
         * We want each event trigger to be able to see the results of the
         * previous event trigger's action.  Caller is responsible for any
         * command-counter increment that is needed between the event trigger
         * and anything else in the transaction.
         */
        if (first)
            first = false;
        else
            CommandCounterIncrement();
 
        /* Look up the function */
        fmgr_info(fnoid, &flinfo);
 
        /* Call the function, passing no arguments but setting a context. */
        InitFunctionCallInfoData(*fcinfo, &flinfo, 0,
                                 InvalidOid, (Node *) trigdata, NULL);
        pgstat_init_function_usage(fcinfo, &fcusage);
        FunctionCallInvoke(fcinfo);
        pgstat_end_function_usage(&fcusage, true);
 
        /* Reclaim memory. */
        MemoryContextReset(context);
    }
 
    /* Restore old memory context and delete the temporary one. */
    MemoryContextSwitchTo(oldcontext);
    MemoryContextDelete(context);
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, check_stack_depth(), CommandCounterIncrement(), context, CurrentMemoryContext, DEBUG1, elog, fmgr_info(), FunctionCallInvoke, InitFunctionCallInfoData, InvalidOid, lfirst_oid, LOCAL_FCINFO, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), pgstat_end_function_usage(), and pgstat_init_function_usage().

Referenced by EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerOnLogin(), EventTriggerSQLDrop(), and EventTriggerTableRewrite().

EventTriggerOnLogin()

void EventTriggerOnLogin

(

void

)

Definition at line 893 of file event_trigger.c.

{
    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.
     */
    else if (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*.
         */
        runlist = EventTriggerCommonSetup(NULL,
                                          EVT_Login, "login",
                                          &trigdata, true);
 
        if (runlist == NIL)
        {
            Relation    pg_db = table_open(DatabaseRelationId, RowExclusiveLock);
            HeapTuple   tuple;
            void       *state;
            Form_pg_database db;
            ScanKeyData key[1];
 
            /* Fetch a copy of the tuple to scribble on */
            ScanKeyInit(&key[0],
                        Anum_pg_database_oid,
                        BTEqualStrategyNumber, F_OIDEQ,
                        ObjectIdGetDatum(MyDatabaseId));
 
            systable_inplace_update_begin(pg_db, DatabaseOidIndexId, true,
                                          NULL, 1, key, &tuple, &state);
 
            if (!HeapTupleIsValid(tuple))
                elog(ERROR, "could not find tuple for database %u", MyDatabaseId);
 
            db = (Form_pg_database) GETSTRUCT(tuple);
            if (db->dathasloginevt)
            {
                db->dathasloginevt = false;
 
                /*
                 * Do an "in place" update of the pg_database tuple.  Doing
                 * this instead of regular updates serves two purposes. First,
                 * that avoids possible waiting on the row-level lock. Second,
                 * that avoids dealing with TOAST.
                 *
                 * Changes made by inplace update may be lost due to
                 * concurrent normal updates; see inplace-inval.spec. However,
                 * we are OK with that.  The subsequent connections will still
                 * have a chance to set "dathasloginevt" to false.
                 */
                systable_inplace_update_finish(state, tuple);
            }
            else
                systable_inplace_update_cancel(state);
            table_close(pg_db, RowExclusiveLock);
            heap_freetuple(tuple);
        }
        else
        {
            list_free(runlist);
        }
    }
    CommitTransactionCommand();
}

References AccessExclusiveLock, BTEqualStrategyNumber, CommitTransactionCommand(), ConditionalLockSharedObject(), elog, ERROR, event_triggers, EventTriggerCommonSetup(), EventTriggerInvoke(), EVT_Login, GETSTRUCT, GetTransactionSnapshot(), heap_freetuple(), HeapTupleIsValid, IsUnderPostmaster, sort-test::key, list_free(), MyDatabaseHasLoginEventTriggers, MyDatabaseId, NIL, ObjectIdGetDatum(), OidIsValid, PopActiveSnapshot(), PushActiveSnapshot(), RowExclusiveLock, ScanKeyInit(), StartTransactionCommand(), systable_inplace_update_begin(), systable_inplace_update_cancel(), systable_inplace_update_finish(), table_close(), and table_open().

Referenced by PostgresMain().

EventTriggerSQLDrop()

void EventTriggerSQLDrop

(

Node *

parsetree

)

Definition at line 820 of file event_trigger.c.

{
    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);
}

References CommandCounterIncrement(), currentEventTriggerState, event_triggers, EventTriggerCommonSetup(), EventTriggerInvoke(), EVT_SQLDrop, EventTriggerQueryState::in_sql_drop, IsUnderPostmaster, list_free(), NIL, PG_END_TRY, PG_FINALLY, PG_TRY, slist_is_empty(), and EventTriggerQueryState::SQLDropList.

Referenced by ProcessUtilitySlow().

EventTriggerSQLDropAddObject()

void EventTriggerSQLDropAddObject	(	const ObjectAddress *	object,
		bool	original,
		bool	normal
	)

Definition at line 1278 of file event_trigger.c.

{
    SQLDropObject *obj;
    MemoryContext oldcxt;
 
    if (!currentEventTriggerState)
        return;
 
    Assert(EventTriggerSupportsObject(object));
 
    /* don't report temp schemas except my own */
    if (object->classId == NamespaceRelationId &&
        (isAnyTempNamespace(object->objectId) &&
         !isTempNamespace(object->objectId)))
        return;
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    obj = palloc0(sizeof(SQLDropObject));
    obj->address = *object;
    obj->original = original;
    obj->normal = normal;
 
    /*
     * Obtain schema names from the object's catalog tuple, if one exists;
     * this lets us skip objects in temp schemas.  We trust that
     * ObjectProperty contains all object classes that can be
     * schema-qualified.
     */
    if (is_objectclass_supported(object->classId))
    {
        Relation    catalog;
        HeapTuple   tuple;
 
        catalog = table_open(obj->address.classId, AccessShareLock);
        tuple = get_catalog_object_by_oid(catalog,
                                          get_object_attnum_oid(object->classId),
                                          obj->address.objectId);
 
        if (tuple)
        {
            AttrNumber  attnum;
            Datum       datum;
            bool        isnull;
 
            attnum = get_object_attnum_namespace(obj->address.classId);
            if (attnum != InvalidAttrNumber)
            {
                datum = heap_getattr(tuple, attnum,
                                     RelationGetDescr(catalog), &isnull);
                if (!isnull)
                {
                    Oid         namespaceId;
 
                    namespaceId = DatumGetObjectId(datum);
                    /* temp objects are only reported if they are my own */
                    if (isTempNamespace(namespaceId))
                    {
                        obj->schemaname = "pg_temp";
                        obj->istemp = true;
                    }
                    else if (isAnyTempNamespace(namespaceId))
                    {
                        pfree(obj);
                        table_close(catalog, AccessShareLock);
                        MemoryContextSwitchTo(oldcxt);
                        return;
                    }
                    else
                    {
                        obj->schemaname = get_namespace_name(namespaceId);
                        obj->istemp = false;
                    }
                }
            }
 
            if (get_object_namensp_unique(obj->address.classId) &&
                obj->address.objectSubId == 0)
            {
                attnum = get_object_attnum_name(obj->address.classId);
                if (attnum != InvalidAttrNumber)
                {
                    datum = heap_getattr(tuple, attnum,
                                         RelationGetDescr(catalog), &isnull);
                    if (!isnull)
                        obj->objname = pstrdup(NameStr(*DatumGetName(datum)));
                }
            }
        }
 
        table_close(catalog, AccessShareLock);
    }
    else
    {
        if (object->classId == NamespaceRelationId &&
            isTempNamespace(object->objectId))
            obj->istemp = true;
    }
 
    /* object identity, objname and objargs */
    obj->objidentity =
        getObjectIdentityParts(&obj->address, &obj->addrnames, &obj->addrargs,
                               false);
 
    /* object type */
    obj->objecttype = getObjectTypeDescription(&obj->address, false);
 
    slist_push_head(&(currentEventTriggerState->SQLDropList), &obj->next);
 
    MemoryContextSwitchTo(oldcxt);
}

References AccessShareLock, SQLDropObject::addrargs, SQLDropObject::address, SQLDropObject::addrnames, Assert, attnum, ObjectAddress::classId, currentEventTriggerState, EventTriggerQueryState::cxt, DatumGetName(), DatumGetObjectId(), EventTriggerSupportsObject(), get_catalog_object_by_oid(), get_namespace_name(), get_object_attnum_name(), get_object_attnum_namespace(), get_object_attnum_oid(), get_object_namensp_unique(), getObjectIdentityParts(), getObjectTypeDescription(), heap_getattr(), InvalidAttrNumber, is_objectclass_supported(), isAnyTempNamespace(), SQLDropObject::istemp, isTempNamespace(), MemoryContextSwitchTo(), NameStr, SQLDropObject::next, SQLDropObject::normal, ObjectAddress::objectId, ObjectAddress::objectSubId, SQLDropObject::objecttype, SQLDropObject::objidentity, SQLDropObject::objname, SQLDropObject::original, palloc0(), pfree(), pstrdup(), RelationGetDescr, SQLDropObject::schemaname, slist_push_head(), EventTriggerQueryState::SQLDropList, table_close(), and table_open().

Referenced by deleteObjectsInList(), and DropSubscription().

EventTriggerSupportsObject()

bool EventTriggerSupportsObject

(

const ObjectAddress *

object

)

Definition at line 1158 of file event_trigger.c.

{
    switch (object->classId)
    {
        case DatabaseRelationId:
        case TableSpaceRelationId:
        case AuthIdRelationId:
        case AuthMemRelationId:
        case ParameterAclRelationId:
            /* no support for global objects (except subscriptions) */
            return false;
        case EventTriggerRelationId:
            /* no support for event triggers on event triggers */
            return false;
        default:
            return true;
    }
}

References ObjectAddress::classId.

Referenced by deleteObjectsInList(), and EventTriggerSQLDropAddObject().

EventTriggerSupportsObjectType()

bool EventTriggerSupportsObjectType

(

ObjectType

obtype

)

Definition at line 1134 of file event_trigger.c.

{
    switch (obtype)
    {
        case OBJECT_DATABASE:
        case OBJECT_TABLESPACE:
        case OBJECT_ROLE:
        case OBJECT_PARAMETER_ACL:
            /* no support for global objects (except subscriptions) */
            return false;
        case OBJECT_EVENT_TRIGGER:
            /* no support for event triggers on event triggers */
            return false;
        default:
            return true;
    }
}

References OBJECT_DATABASE, OBJECT_EVENT_TRIGGER, OBJECT_PARAMETER_ACL, OBJECT_ROLE, and OBJECT_TABLESPACE.

Referenced by ExecGrantStmt_oids(), and standard_ProcessUtility().

EventTriggerTableRewrite()

void EventTriggerTableRewrite	(	Node *	parsetree,
		Oid	tableOid,
		int	reason
	)

Definition at line 1004 of file event_trigger.c.

{
    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;
 
    /*
     * 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
     * *necessary*, because EventTriggerCommonSetup might find triggers that
     * didn't exist at the time the command started.
     */
    if (!currentEventTriggerState)
        return;
 
    runlist = EventTriggerCommonSetup(parsetree,
                                      EVT_TableRewrite,
                                      "table_rewrite",
                                      &trigdata, false);
    if (runlist == NIL)
        return;
 
    /*
     * Make sure pg_event_trigger_table_rewrite_oid only works when running
     * these triggers. Use PG_TRY to ensure table_rewrite_oid 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->table_rewrite_oid = tableOid;
    currentEventTriggerState->table_rewrite_reason = reason;
 
    /* Run the triggers. */
    PG_TRY();
    {
        EventTriggerInvoke(runlist, &trigdata);
    }
    PG_FINALLY();
    {
        currentEventTriggerState->table_rewrite_oid = InvalidOid;
        currentEventTriggerState->table_rewrite_reason = 0;
    }
    PG_END_TRY();
 
    /* Cleanup. */
    list_free(runlist);
 
    /*
     * Make sure anything the event triggers did will be visible to the main
     * command.
     */
    CommandCounterIncrement();
}

References CommandCounterIncrement(), currentEventTriggerState, event_triggers, EventTriggerCommonSetup(), EventTriggerInvoke(), EVT_TableRewrite, InvalidOid, IsUnderPostmaster, list_free(), NIL, PG_END_TRY, PG_FINALLY, PG_TRY, EventTriggerQueryState::table_rewrite_oid, and EventTriggerQueryState::table_rewrite_reason.

Referenced by ATRewriteTables().

EventTriggerUndoInhibitCommandCollection()

void EventTriggerUndoInhibitCommandCollection

(

void

)

Definition at line 1566 of file event_trigger.c.

{
    if (!currentEventTriggerState)
        return;
 
    currentEventTriggerState->commandCollectionInhibited = false;
}

References EventTriggerQueryState::commandCollectionInhibited, and currentEventTriggerState.

Referenced by ProcessUtilitySlow().

filter_event_trigger()

static bool filter_event_trigger ( CommandTag  tag, EventTriggerCacheItem *  item  )

static

Definition at line 594 of file event_trigger.c.

{
    /*
     * 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;
}

References bms_is_empty, bms_is_member(), EventTriggerCacheItem::enabled, SESSION_REPLICATION_ROLE_REPLICA, SessionReplicationRole, EventTriggerCacheItem::tagset, TRIGGER_FIRES_ON_ORIGIN, and TRIGGER_FIRES_ON_REPLICA.

Referenced by EventTriggerCommonSetup().

filter_list_to_array()

static Datum filter_list_to_array ( List *  filterlist )

static

Definition at line 356 of file event_trigger.c.

{
    ListCell   *lc;
    Datum      *data;
    int         i = 0,
                l = list_length(filterlist);
 
    data = (Datum *) palloc(l * sizeof(Datum));
 
    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));
}

References construct_array_builtin(), cstring_to_text(), data, i, lfirst, list_length(), palloc(), pfree(), pg_ascii_toupper(), PointerGetDatum(), pstrdup(), strVal, and value.

Referenced by insert_event_trigger_tuple().

get_event_trigger_oid()

Oid get_event_trigger_oid	(	const char *	trigname,
		bool	missing_ok
	)

Definition at line 575 of file event_trigger.c.

{
    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;
}

References CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid1, and OidIsValid.

Referenced by get_object_address_unqualified().

insert_event_trigger_tuple()

static Oid insert_event_trigger_tuple ( const char *  trigname, const char *  eventname, Oid  evtOwner, Oid  funcoid, List *  taglist  )

static

Definition at line 273 of file event_trigger.c.

{
    Relation    tgrel;
    Oid         trigoid;
    HeapTuple   tuple;
    Datum       values[Natts_pg_trigger];
    bool        nulls[Natts_pg_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;
}

References CatalogTupleInsert(), CharGetDatum(), ObjectAddress::classId, DEPENDENCY_NORMAL, filter_list_to_array(), GetNewOidWithIndex(), heap_form_tuple(), heap_freetuple(), InvokeObjectPostCreateHook, NameGetDatum(), namestrcpy(), NIL, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), RowExclusiveLock, SetDatabaseHasLoginEventTriggers(), table_close(), table_open(), TRIGGER_FIRES_ON_ORIGIN, and values.

Referenced by CreateEventTrigger().

pg_event_trigger_ddl_commands()

Datum pg_event_trigger_ddl_commands

(

PG_FUNCTION_ARGS

)

Definition at line 1925 of file event_trigger.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    ListCell   *lc;
 
    /*
     * Protect this function from being called out of context
     */
    if (!currentEventTriggerState)
        ereport(ERROR,
                (errcode(ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),
                 errmsg("%s can only be called in an event trigger function",
                        "pg_event_trigger_ddl_commands()")));
 
    /* Build tuplestore to hold the result rows */
    InitMaterializedSRF(fcinfo, 0);
 
    foreach(lc, currentEventTriggerState->commandList)
    {
        CollectedCommand *cmd = lfirst(lc);
        Datum       values[9];
        bool        nulls[9] = {0};
        ObjectAddress addr;
        int         i = 0;
 
        /*
         * For IF NOT EXISTS commands that attempt to create an existing
         * object, the returned OID is Invalid.  Don't return anything.
         *
         * One might think that a viable alternative would be to look up the
         * Oid of the existing object and run the deparse with that.  But
         * since the parse tree might be different from the one that created
         * the object in the first place, we might not end up in a consistent
         * state anyway.
         */
        if (cmd->type == SCT_Simple &&
            !OidIsValid(cmd->d.simple.address.objectId))
            continue;
 
        switch (cmd->type)
        {
            case SCT_Simple:
            case SCT_AlterTable:
            case SCT_AlterOpFamily:
            case SCT_CreateOpClass:
            case SCT_AlterTSConfig:
                {
                    char       *identity;
                    char       *type;
                    char       *schema = NULL;
 
                    if (cmd->type == SCT_Simple)
                        addr = cmd->d.simple.address;
                    else if (cmd->type == SCT_AlterTable)
                        ObjectAddressSet(addr,
                                         cmd->d.alterTable.classId,
                                         cmd->d.alterTable.objectId);
                    else if (cmd->type == SCT_AlterOpFamily)
                        addr = cmd->d.opfam.address;
                    else if (cmd->type == SCT_CreateOpClass)
                        addr = cmd->d.createopc.address;
                    else if (cmd->type == SCT_AlterTSConfig)
                        addr = cmd->d.atscfg.address;
 
                    /*
                     * If an object was dropped in the same command we may end
                     * up in a situation where we generated a message but can
                     * no longer look for the object information, so skip it
                     * rather than failing.  This can happen for example with
                     * some subcommand combinations of ALTER TABLE.
                     */
                    identity = getObjectIdentity(&addr, true);
                    if (identity == NULL)
                        continue;
 
                    /* The type can never be NULL. */
                    type = getObjectTypeDescription(&addr, true);
 
                    /*
                     * Obtain schema name, if any ("pg_temp" if a temp
                     * object). If the object class is not in the supported
                     * list here, we assume it's a schema-less object type,
                     * and thus "schema" remains set to NULL.
                     */
                    if (is_objectclass_supported(addr.classId))
                    {
                        AttrNumber  nspAttnum;
 
                        nspAttnum = get_object_attnum_namespace(addr.classId);
                        if (nspAttnum != InvalidAttrNumber)
                        {
                            Relation    catalog;
                            HeapTuple   objtup;
                            Oid         schema_oid;
                            bool        isnull;
 
                            catalog = table_open(addr.classId, AccessShareLock);
                            objtup = get_catalog_object_by_oid(catalog,
                                                               get_object_attnum_oid(addr.classId),
                                                               addr.objectId);
                            if (!HeapTupleIsValid(objtup))
                                elog(ERROR, "cache lookup failed for object %u/%u",
                                     addr.classId, addr.objectId);
                            schema_oid =
                                heap_getattr(objtup, nspAttnum,
                                             RelationGetDescr(catalog), &isnull);
                            if (isnull)
                                elog(ERROR,
                                     "invalid null namespace in object %u/%u/%d",
                                     addr.classId, addr.objectId, addr.objectSubId);
                            schema = get_namespace_name_or_temp(schema_oid);
 
                            table_close(catalog, AccessShareLock);
                        }
                    }
 
                    /* classid */
                    values[i++] = ObjectIdGetDatum(addr.classId);
                    /* objid */
                    values[i++] = ObjectIdGetDatum(addr.objectId);
                    /* objsubid */
                    values[i++] = Int32GetDatum(addr.objectSubId);
                    /* command tag */
                    values[i++] = CStringGetTextDatum(CreateCommandName(cmd->parsetree));
                    /* object_type */
                    values[i++] = CStringGetTextDatum(type);
                    /* schema */
                    if (schema == NULL)
                        nulls[i++] = true;
                    else
                        values[i++] = CStringGetTextDatum(schema);
                    /* identity */
                    values[i++] = CStringGetTextDatum(identity);
                    /* in_extension */
                    values[i++] = BoolGetDatum(cmd->in_extension);
                    /* command */
                    values[i++] = PointerGetDatum(cmd);
                }
                break;
 
            case SCT_AlterDefaultPrivileges:
                /* classid */
                nulls[i++] = true;
                /* objid */
                nulls[i++] = true;
                /* objsubid */
                nulls[i++] = true;
                /* command tag */
                values[i++] = CStringGetTextDatum(CreateCommandName(cmd->parsetree));
                /* object_type */
                values[i++] = CStringGetTextDatum(stringify_adefprivs_objtype(cmd->d.defprivs.objtype));
                /* schema */
                nulls[i++] = true;
                /* identity */
                nulls[i++] = true;
                /* in_extension */
                values[i++] = BoolGetDatum(cmd->in_extension);
                /* command */
                values[i++] = PointerGetDatum(cmd);
                break;
 
            case SCT_Grant:
                /* classid */
                nulls[i++] = true;
                /* objid */
                nulls[i++] = true;
                /* objsubid */
                nulls[i++] = true;
                /* command tag */
                values[i++] = CStringGetTextDatum(cmd->d.grant.istmt->is_grant ?
                                                  "GRANT" : "REVOKE");
                /* object_type */
                values[i++] = CStringGetTextDatum(stringify_grant_objtype(cmd->d.grant.istmt->objtype));
                /* schema */
                nulls[i++] = true;
                /* identity */
                nulls[i++] = true;
                /* in_extension */
                values[i++] = BoolGetDatum(cmd->in_extension);
                /* command */
                values[i++] = PointerGetDatum(cmd);
                break;
        }
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                             values, nulls);
    }
 
    PG_RETURN_VOID();
}

References AccessShareLock, CollectedCommand::alterTable, CollectedCommand::atscfg, BoolGetDatum(), ObjectAddress::classId, EventTriggerQueryState::commandList, CreateCommandName(), CollectedCommand::createopc, CStringGetTextDatum, currentEventTriggerState, CollectedCommand::d, CollectedCommand::defprivs, elog, ereport, errcode(), errmsg(), ERROR, get_catalog_object_by_oid(), get_namespace_name_or_temp(), get_object_attnum_namespace(), get_object_attnum_oid(), getObjectIdentity(), getObjectTypeDescription(), CollectedCommand::grant, heap_getattr(), HeapTupleIsValid, i, if(), CollectedCommand::in_extension, InitMaterializedSRF(), Int32GetDatum(), InvalidAttrNumber, is_objectclass_supported(), lfirst, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, CollectedCommand::opfam, CollectedCommand::parsetree, PG_RETURN_VOID, PointerGetDatum(), RelationGetDescr, SCT_AlterDefaultPrivileges, SCT_AlterOpFamily, SCT_AlterTable, SCT_AlterTSConfig, SCT_CreateOpClass, SCT_Grant, SCT_Simple, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, CollectedCommand::simple, stringify_adefprivs_objtype(), stringify_grant_objtype(), table_close(), table_open(), tuplestore_putvalues(), type, CollectedCommand::type, and values.

pg_event_trigger_dropped_objects()

Datum pg_event_trigger_dropped_objects

(

PG_FUNCTION_ARGS

)

Definition at line 1397 of file event_trigger.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    slist_iter  iter;
 
    /*
     * Protect this function from being called out of context
     */
    if (!currentEventTriggerState ||
        !currentEventTriggerState->in_sql_drop)
        ereport(ERROR,
                (errcode(ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),
                 errmsg("%s can only be called in a sql_drop event trigger function",
                        "pg_event_trigger_dropped_objects()")));
 
    /* Build tuplestore to hold the result rows */
    InitMaterializedSRF(fcinfo, 0);
 
    slist_foreach(iter, &(currentEventTriggerState->SQLDropList))
    {
        SQLDropObject *obj;
        int         i = 0;
        Datum       values[12] = {0};
        bool        nulls[12] = {0};
 
        obj = slist_container(SQLDropObject, next, iter.cur);
 
        /* classid */
        values[i++] = ObjectIdGetDatum(obj->address.classId);
 
        /* objid */
        values[i++] = ObjectIdGetDatum(obj->address.objectId);
 
        /* objsubid */
        values[i++] = Int32GetDatum(obj->address.objectSubId);
 
        /* original */
        values[i++] = BoolGetDatum(obj->original);
 
        /* normal */
        values[i++] = BoolGetDatum(obj->normal);
 
        /* is_temporary */
        values[i++] = BoolGetDatum(obj->istemp);
 
        /* object_type */
        values[i++] = CStringGetTextDatum(obj->objecttype);
 
        /* schema_name */
        if (obj->schemaname)
            values[i++] = CStringGetTextDatum(obj->schemaname);
        else
            nulls[i++] = true;
 
        /* object_name */
        if (obj->objname)
            values[i++] = CStringGetTextDatum(obj->objname);
        else
            nulls[i++] = true;
 
        /* object_identity */
        if (obj->objidentity)
            values[i++] = CStringGetTextDatum(obj->objidentity);
        else
            nulls[i++] = true;
 
        /* address_names and address_args */
        if (obj->addrnames)
        {
            values[i++] = PointerGetDatum(strlist_to_textarray(obj->addrnames));
 
            if (obj->addrargs)
                values[i++] = PointerGetDatum(strlist_to_textarray(obj->addrargs));
            else
                values[i++] = PointerGetDatum(construct_empty_array(TEXTOID));
        }
        else
        {
            nulls[i++] = true;
            nulls[i++] = true;
        }
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                             values, nulls);
    }
 
    return (Datum) 0;
}

References SQLDropObject::addrargs, SQLDropObject::address, SQLDropObject::addrnames, BoolGetDatum(), ObjectAddress::classId, construct_empty_array(), CStringGetTextDatum, currentEventTriggerState, ereport, errcode(), errmsg(), ERROR, i, if(), EventTriggerQueryState::in_sql_drop, InitMaterializedSRF(), Int32GetDatum(), SQLDropObject::istemp, next, SQLDropObject::normal, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, SQLDropObject::objecttype, SQLDropObject::objidentity, SQLDropObject::objname, SQLDropObject::original, PointerGetDatum(), SQLDropObject::schemaname, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, slist_container, slist_foreach, EventTriggerQueryState::SQLDropList, strlist_to_textarray(), tuplestore_putvalues(), and values.

pg_event_trigger_table_rewrite_oid()

Datum pg_event_trigger_table_rewrite_oid

(

PG_FUNCTION_ARGS

)

Definition at line 1493 of file event_trigger.c.

{
    /*
     * Protect this function from being called out of context
     */
    if (!currentEventTriggerState ||
        currentEventTriggerState->table_rewrite_oid == InvalidOid)
        ereport(ERROR,
                (errcode(ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),
                 errmsg("%s can only be called in a table_rewrite event trigger function",
                        "pg_event_trigger_table_rewrite_oid()")));
 
    PG_RETURN_OID(currentEventTriggerState->table_rewrite_oid);
}

References currentEventTriggerState, ereport, errcode(), errmsg(), ERROR, InvalidOid, PG_RETURN_OID, and EventTriggerQueryState::table_rewrite_oid.

pg_event_trigger_table_rewrite_reason()

Datum pg_event_trigger_table_rewrite_reason

(

PG_FUNCTION_ARGS

)

Definition at line 1514 of file event_trigger.c.

{
    /*
     * Protect this function from being called out of context
     */
    if (!currentEventTriggerState ||
        currentEventTriggerState->table_rewrite_reason == 0)
        ereport(ERROR,
                (errcode(ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED),
                 errmsg("%s can only be called in a table_rewrite event trigger function",
                        "pg_event_trigger_table_rewrite_reason()")));
 
    PG_RETURN_INT32(currentEventTriggerState->table_rewrite_reason);
}

References currentEventTriggerState, ereport, errcode(), errmsg(), ERROR, PG_RETURN_INT32, and EventTriggerQueryState::table_rewrite_reason.

SetDatabaseHasLoginEventTriggers()

void SetDatabaseHasLoginEventTriggers ( void  )

static

Definition at line 386 of file event_trigger.c.

{
    /* 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);
}

References AccessExclusiveLock, CatalogTupleUpdate(), CommandCounterIncrement(), elog, ERROR, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, InplaceUpdateTupleLock, LockSharedObject(), MyDatabaseId, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheLockedCopy1(), HeapTupleData::t_self, table_close(), table_open(), and UnlockTuple().

Referenced by AlterEventTrigger(), and insert_event_trigger_tuple().

stringify_adefprivs_objtype()

static const char * stringify_adefprivs_objtype ( ObjectType  objtype )

static

Definition at line 2206 of file event_trigger.c.

{
    switch (objtype)
    {
        case OBJECT_COLUMN:
            return "COLUMNS";
        case OBJECT_TABLE:
            return "TABLES";
        case OBJECT_SEQUENCE:
            return "SEQUENCES";
        case OBJECT_DATABASE:
            return "DATABASES";
        case OBJECT_DOMAIN:
            return "DOMAINS";
        case OBJECT_FDW:
            return "FOREIGN DATA WRAPPERS";
        case OBJECT_FOREIGN_SERVER:
            return "FOREIGN SERVERS";
        case OBJECT_FUNCTION:
            return "FUNCTIONS";
        case OBJECT_LANGUAGE:
            return "LANGUAGES";
        case OBJECT_LARGEOBJECT:
            return "LARGE OBJECTS";
        case OBJECT_SCHEMA:
            return "SCHEMAS";
        case OBJECT_PROCEDURE:
            return "PROCEDURES";
        case OBJECT_ROUTINE:
            return "ROUTINES";
        case OBJECT_TABLESPACE:
            return "TABLESPACES";
        case OBJECT_TYPE:
            return "TYPES";
            /* these currently aren't used */
        case OBJECT_ACCESS_METHOD:
        case OBJECT_AGGREGATE:
        case OBJECT_AMOP:
        case OBJECT_AMPROC:
        case OBJECT_ATTRIBUTE:
        case OBJECT_CAST:
        case OBJECT_COLLATION:
        case OBJECT_CONVERSION:
        case OBJECT_DEFAULT:
        case OBJECT_DEFACL:
        case OBJECT_DOMCONSTRAINT:
        case OBJECT_EVENT_TRIGGER:
        case OBJECT_EXTENSION:
        case OBJECT_FOREIGN_TABLE:
        case OBJECT_INDEX:
        case OBJECT_MATVIEW:
        case OBJECT_OPCLASS:
        case OBJECT_OPERATOR:
        case OBJECT_OPFAMILY:
        case OBJECT_PARAMETER_ACL:
        case OBJECT_POLICY:
        case OBJECT_PUBLICATION:
        case OBJECT_PUBLICATION_NAMESPACE:
        case OBJECT_PUBLICATION_REL:
        case OBJECT_ROLE:
        case OBJECT_RULE:
        case OBJECT_STATISTIC_EXT:
        case OBJECT_SUBSCRIPTION:
        case OBJECT_TABCONSTRAINT:
        case OBJECT_TRANSFORM:
        case OBJECT_TRIGGER:
        case OBJECT_TSCONFIGURATION:
        case OBJECT_TSDICTIONARY:
        case OBJECT_TSPARSER:
        case OBJECT_TSTEMPLATE:
        case OBJECT_USER_MAPPING:
        case OBJECT_VIEW:
            elog(ERROR, "unsupported object type: %d", (int) objtype);
    }
 
    return "???";               /* keep compiler quiet */
}

References elog, ERROR, OBJECT_ACCESS_METHOD, OBJECT_AGGREGATE, OBJECT_AMOP, OBJECT_AMPROC, OBJECT_ATTRIBUTE, OBJECT_CAST, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DATABASE, OBJECT_DEFACL, OBJECT_DEFAULT, OBJECT_DOMAIN, OBJECT_DOMCONSTRAINT, OBJECT_EVENT_TRIGGER, OBJECT_EXTENSION, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_INDEX, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, OBJECT_PARAMETER_ACL, OBJECT_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, OBJECT_PUBLICATION_NAMESPACE, OBJECT_PUBLICATION_REL, OBJECT_ROLE, OBJECT_ROUTINE, OBJECT_RULE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABCONSTRAINT, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TRANSFORM, OBJECT_TRIGGER, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, OBJECT_USER_MAPPING, and OBJECT_VIEW.

Referenced by pg_event_trigger_ddl_commands().

stringify_grant_objtype()

static const char * stringify_grant_objtype ( ObjectType  objtype )

static

Definition at line 2121 of file event_trigger.c.

{
    switch (objtype)
    {
        case OBJECT_COLUMN:
            return "COLUMN";
        case OBJECT_TABLE:
            return "TABLE";
        case OBJECT_SEQUENCE:
            return "SEQUENCE";
        case OBJECT_DATABASE:
            return "DATABASE";
        case OBJECT_DOMAIN:
            return "DOMAIN";
        case OBJECT_FDW:
            return "FOREIGN DATA WRAPPER";
        case OBJECT_FOREIGN_SERVER:
            return "FOREIGN SERVER";
        case OBJECT_FUNCTION:
            return "FUNCTION";
        case OBJECT_LANGUAGE:
            return "LANGUAGE";
        case OBJECT_LARGEOBJECT:
            return "LARGE OBJECT";
        case OBJECT_SCHEMA:
            return "SCHEMA";
        case OBJECT_PARAMETER_ACL:
            return "PARAMETER";
        case OBJECT_PROCEDURE:
            return "PROCEDURE";
        case OBJECT_ROUTINE:
            return "ROUTINE";
        case OBJECT_TABLESPACE:
            return "TABLESPACE";
        case OBJECT_TYPE:
            return "TYPE";
            /* these currently aren't used */
        case OBJECT_ACCESS_METHOD:
        case OBJECT_AGGREGATE:
        case OBJECT_AMOP:
        case OBJECT_AMPROC:
        case OBJECT_ATTRIBUTE:
        case OBJECT_CAST:
        case OBJECT_COLLATION:
        case OBJECT_CONVERSION:
        case OBJECT_DEFAULT:
        case OBJECT_DEFACL:
        case OBJECT_DOMCONSTRAINT:
        case OBJECT_EVENT_TRIGGER:
        case OBJECT_EXTENSION:
        case OBJECT_FOREIGN_TABLE:
        case OBJECT_INDEX:
        case OBJECT_MATVIEW:
        case OBJECT_OPCLASS:
        case OBJECT_OPERATOR:
        case OBJECT_OPFAMILY:
        case OBJECT_POLICY:
        case OBJECT_PUBLICATION:
        case OBJECT_PUBLICATION_NAMESPACE:
        case OBJECT_PUBLICATION_REL:
        case OBJECT_ROLE:
        case OBJECT_RULE:
        case OBJECT_STATISTIC_EXT:
        case OBJECT_SUBSCRIPTION:
        case OBJECT_TABCONSTRAINT:
        case OBJECT_TRANSFORM:
        case OBJECT_TRIGGER:
        case OBJECT_TSCONFIGURATION:
        case OBJECT_TSDICTIONARY:
        case OBJECT_TSPARSER:
        case OBJECT_TSTEMPLATE:
        case OBJECT_USER_MAPPING:
        case OBJECT_VIEW:
            elog(ERROR, "unsupported object type: %d", (int) objtype);
    }
 
    return "???";               /* keep compiler quiet */
}

References elog, ERROR, OBJECT_ACCESS_METHOD, OBJECT_AGGREGATE, OBJECT_AMOP, OBJECT_AMPROC, OBJECT_ATTRIBUTE, OBJECT_CAST, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DATABASE, OBJECT_DEFACL, OBJECT_DEFAULT, OBJECT_DOMAIN, OBJECT_DOMCONSTRAINT, OBJECT_EVENT_TRIGGER, OBJECT_EXTENSION, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_INDEX, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, OBJECT_PARAMETER_ACL, OBJECT_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, OBJECT_PUBLICATION_NAMESPACE, OBJECT_PUBLICATION_REL, OBJECT_ROLE, OBJECT_ROUTINE, OBJECT_RULE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABCONSTRAINT, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TRANSFORM, OBJECT_TRIGGER, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, OBJECT_USER_MAPPING, and OBJECT_VIEW.

Referenced by pg_event_trigger_ddl_commands().

trackDroppedObjectsNeeded()

bool trackDroppedObjectsNeeded

(

void

)

Definition at line 1246 of file event_trigger.c.

{
    /*
     * true if any sql_drop, table_rewrite, ddl_command_end event trigger
     * exists
     */
    return (EventCacheLookup(EVT_SQLDrop) != NIL) ||
        (EventCacheLookup(EVT_TableRewrite) != NIL) ||
        (EventCacheLookup(EVT_DDLCommandEnd) != NIL);
}

References EventCacheLookup(), EVT_DDLCommandEnd, EVT_SQLDrop, EVT_TableRewrite, and NIL.

Referenced by deleteObjectsInList(), and EventTriggerBeginCompleteQuery().

validate_ddl_tags()

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

static

Definition at line 212 of file event_trigger.c.

{
    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)));
    }
}

References command_tag_event_trigger_ok(), ereport, errcode(), errmsg(), ERROR, GetCommandTagEnum(), lfirst, and strVal.

Referenced by CreateEventTrigger().

validate_table_rewrite_tags()

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

static

Definition at line 239 of file event_trigger.c.

{
    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)));
    }
}

References command_tag_table_rewrite_ok(), ereport, errcode(), errmsg(), ERROR, GetCommandTagEnum(), lfirst, and strVal.

Referenced by CreateEventTrigger().

Variable Documentation

currentEventTriggerState

EventTriggerQueryState* currentEventTriggerState = NULL

static

Definition at line 81 of file event_trigger.c.

Referenced by EventTriggerAlterTableEnd(), EventTriggerAlterTableRelid(), EventTriggerAlterTableStart(), EventTriggerBeginCompleteQuery(), EventTriggerCollectAlterDefPrivs(), EventTriggerCollectAlterOpFam(), EventTriggerCollectAlterTableSubcmd(), EventTriggerCollectAlterTSConfig(), EventTriggerCollectCreateOpClass(), EventTriggerCollectGrant(), EventTriggerCollectSimpleCommand(), EventTriggerDDLCommandEnd(), EventTriggerEndCompleteQuery(), EventTriggerInhibitCommandCollection(), EventTriggerSQLDrop(), EventTriggerSQLDropAddObject(), EventTriggerTableRewrite(), EventTriggerUndoInhibitCommandCollection(), pg_event_trigger_ddl_commands(), pg_event_trigger_dropped_objects(), pg_event_trigger_table_rewrite_oid(), and pg_event_trigger_table_rewrite_reason().

event_triggers

bool event_triggers = true

Definition at line 84 of file event_trigger.c.

Referenced by EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerOnLogin(), EventTriggerSQLDrop(), and EventTriggerTableRewrite().