event_trigger.h File Reference

#include "catalog/dependency.h"
#include "catalog/objectaddress.h"
#include "catalog/pg_event_trigger.h"
#include "nodes/parsenodes.h"
#include "tcop/cmdtag.h"
#include "tcop/deparse_utility.h"
#include "utils/aclchk_internal.h"

Include dependency graph for event_trigger.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	EventTriggerData

Macros
#define	AT_REWRITE_ALTER_PERSISTENCE   0x01
#define	AT_REWRITE_DEFAULT_VAL   0x02
#define	AT_REWRITE_COLUMN_REWRITE   0x04
#define	AT_REWRITE_ACCESS_METHOD   0x08
#define	CALLED_AS_EVENT_TRIGGER(fcinfo)    ((fcinfo)->context != NULL && IsA((fcinfo)->context, EventTriggerData))

Typedefs
typedef struct EventTriggerData	EventTriggerData

Functions
Oid	CreateEventTrigger (CreateEventTrigStmt *stmt)
Oid	get_event_trigger_oid (const char *trigname, bool missing_ok)
Oid	AlterEventTrigger (AlterEventTrigStmt *stmt)
ObjectAddress	AlterEventTriggerOwner (const char *name, Oid newOwnerId)
void	AlterEventTriggerOwner_oid (Oid, Oid newOwnerId)
bool	EventTriggerSupportsObjectType (ObjectType obtype)
bool	EventTriggerSupportsObject (const ObjectAddress *object)
void	EventTriggerDDLCommandStart (Node *parsetree)
void	EventTriggerDDLCommandEnd (Node *parsetree)
void	EventTriggerSQLDrop (Node *parsetree)
void	EventTriggerTableRewrite (Node *parsetree, Oid tableOid, int reason)
void	EventTriggerOnLogin (void)
bool	EventTriggerBeginCompleteQuery (void)
void	EventTriggerEndCompleteQuery (void)
bool	trackDroppedObjectsNeeded (void)
void	EventTriggerSQLDropAddObject (const ObjectAddress *object, bool original, bool normal)
void	EventTriggerInhibitCommandCollection (void)
void	EventTriggerUndoInhibitCommandCollection (void)
void	EventTriggerCollectSimpleCommand (ObjectAddress address, ObjectAddress secondaryObject, const Node *parsetree)
void	EventTriggerAlterTableStart (const Node *parsetree)
void	EventTriggerAlterTableRelid (Oid objectId)
void	EventTriggerCollectAlterTableSubcmd (const Node *subcmd, ObjectAddress address)
void	EventTriggerAlterTableEnd (void)
void	EventTriggerCollectGrant (InternalGrant *istmt)
void	EventTriggerCollectAlterOpFam (const AlterOpFamilyStmt *stmt, Oid opfamoid, List *operators, List *procedures)
void	EventTriggerCollectCreateOpClass (const CreateOpClassStmt *stmt, Oid opcoid, List *operators, List *procedures)
void	EventTriggerCollectAlterTSConfig (const AlterTSConfigurationStmt *stmt, Oid cfgId, Oid *dictIds, int ndicts)
void	EventTriggerCollectAlterDefPrivs (const AlterDefaultPrivilegesStmt *stmt)

Variables
PGDLLIMPORT bool	event_triggers

Macro Definition Documentation

AT_REWRITE_ACCESS_METHOD

#define AT_REWRITE_ACCESS_METHOD   0x08

Definition at line 43 of file event_trigger.h.

AT_REWRITE_ALTER_PERSISTENCE

#define AT_REWRITE_ALTER_PERSISTENCE   0x01

Definition at line 40 of file event_trigger.h.

AT_REWRITE_COLUMN_REWRITE

#define AT_REWRITE_COLUMN_REWRITE   0x04

Definition at line 42 of file event_trigger.h.

AT_REWRITE_DEFAULT_VAL

#define AT_REWRITE_DEFAULT_VAL   0x02

Definition at line 41 of file event_trigger.h.

CALLED_AS_EVENT_TRIGGER

#define CALLED_AS_EVENT_TRIGGER

(

fcinfo

)

((fcinfo)->context != NULL && IsA((fcinfo)->context, EventTriggerData))

Definition at line 49 of file event_trigger.h.

Typedef Documentation

EventTriggerData

typedef struct EventTriggerData EventTriggerData

Function Documentation

AlterEventTrigger()

Oid AlterEventTrigger ( AlterEventTrigStmt *  stmt )

extern

Definition at line 429 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, fb(), Form_pg_event_trigger, GETSTRUCT(), GetUserId(), heap_freetuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, namestrcmp(), OBJECT_EVENT_TRIGGER, object_ownercheck(), RowExclusiveLock, SearchSysCacheCopy1, SetDatabaseHasLoginEventTriggers(), stmt, table_close(), table_open(), and TRIGGER_DISABLED.

Referenced by standard_ProcessUtility().

AlterEventTriggerOwner()

ObjectAddress AlterEventTriggerOwner ( const char *  name, Oid  newOwnerId  )

extern

Definition at line 481 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, fb(), Form_pg_event_trigger, GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, name, ObjectAddressSet, RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by ExecAlterOwnerStmt().

AlterEventTriggerOwner_oid()

void AlterEventTriggerOwner_oid ( Oid  trigOid, Oid  newOwnerId  )

extern

Definition at line 516 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, fb(), heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by shdepReassignOwned_Owner().

CreateEventTrigger()

Oid CreateEventTrigger ( CreateEventTrigStmt *  stmt )

extern

Definition at line 126 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(), fb(), 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().

EventTriggerAlterTableEnd()

void EventTriggerAlterTableEnd ( void  )

extern

Definition at line 1850 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, fb(), lappend(), MemoryContextSwitchTo(), NIL, CollectedCommand::parent, pfree(), and CollectedCommand::subcmds.

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

EventTriggerAlterTableRelid()

void EventTriggerAlterTableRelid ( Oid  objectId )

extern

Definition at line 1797 of file event_trigger.c.

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

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

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

EventTriggerAlterTableStart()

void EventTriggerAlterTableStart ( const Node *  parsetree )

extern

Definition at line 1763 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_object(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, CollectedCommand::classId, EventTriggerQueryState::commandCollectionInhibited, copyObject, creating_extension, EventTriggerQueryState::currentCommand, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, fb(), CollectedCommand::in_extension, InvalidOid, MemoryContextSwitchTo(), NIL, CollectedCommand::objectId, palloc_object, CollectedCommand::parent, CollectedCommand::parsetree, SCT_AlterTable, CollectedCommand::subcmds, and CollectedCommand::type.

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

EventTriggerBeginCompleteQuery()

bool EventTriggerBeginCompleteQuery ( void  )

extern

Definition at line 1193 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, fb(), InvalidOid, MemoryContextAlloc(), NIL, slist_init(), TopMemoryContext, and trackDroppedObjectsNeeded().

Referenced by ProcessUtilitySlow().

EventTriggerCollectAlterDefPrivs()

void EventTriggerCollectAlterDefPrivs ( const AlterDefaultPrivilegesStmt *  stmt )

extern

Definition at line 2037 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_object(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, fb(), CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), CollectedCommand::objtype, palloc0_object, CollectedCommand::parsetree, SCT_AlterDefaultPrivileges, stmt, and CollectedCommand::type.

Referenced by ProcessUtilitySlow().

EventTriggerCollectAlterOpFam()

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

extern

Definition at line 1932 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_object(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 CollectedCommand::address, EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, fb(), CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), ObjectAddressSet, CollectedCommand::operators, CollectedCommand::opfam, palloc_object, CollectedCommand::parsetree, CollectedCommand::procedures, SCT_AlterOpFamily, stmt, and CollectedCommand::type.

Referenced by AlterOpFamilyAdd(), and AlterOpFamilyDrop().

EventTriggerCollectAlterTableSubcmd()

void EventTriggerCollectAlterTableSubcmd ( const Node *  subcmd, ObjectAddress  address  )

extern

Definition at line 1815 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_object(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, fb(), IsA, lappend(), MemoryContextSwitchTo(), newsub(), CollectedCommand::objectId, OidIsValid, palloc_object, and CollectedCommand::subcmds.

Referenced by ATExecCmd().

EventTriggerCollectAlterTSConfig()

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

extern

Definition at line 1999 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_object(CollectedCommand);
    command->type = SCT_AlterTSConfig;
    command->in_extension = creating_extension;
    ObjectAddressSet(command->d.atscfg.address,
                     TSConfigRelationId, cfgId);
    if (ndicts > 0)
    {
        command->d.atscfg.dictIds = palloc_array(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::address, CollectedCommand::atscfg, EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, CollectedCommand::dictIds, fb(), CollectedCommand::in_extension, lappend(), memcpy(), MemoryContextSwitchTo(), CollectedCommand::ndicts, ObjectAddressSet, palloc0_object, palloc_array, CollectedCommand::parsetree, SCT_AlterTSConfig, stmt, and CollectedCommand::type.

Referenced by DropConfigurationMapping(), and MakeConfigurationMapping().

EventTriggerCollectCreateOpClass()

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

extern

Definition at line 1965 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_object(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 CollectedCommand::address, EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, CollectedCommand::createopc, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, fb(), CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), ObjectAddressSet, CollectedCommand::operators, palloc0_object, CollectedCommand::parsetree, CollectedCommand::procedures, SCT_CreateOpClass, stmt, and CollectedCommand::type.

Referenced by DefineOpClass().

EventTriggerCollectGrant()

void EventTriggerCollectGrant ( InternalGrant *  istmt )

extern

Definition at line 1888 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_object(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_object(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, fb(), CollectedCommand::grant, InternalGrant::grantees, CollectedCommand::in_extension, CollectedCommand::istmt, lappend(), lfirst, list_copy(), memcpy(), MemoryContextSwitchTo(), NIL, InternalGrant::objects, palloc_object, CollectedCommand::parsetree, SCT_Grant, and CollectedCommand::type.

Referenced by ExecGrantStmt_oids().

EventTriggerCollectSimpleCommand()

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

extern

Definition at line 1725 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_object(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 CollectedCommand::address, EventTriggerQueryState::commandCollectionInhibited, EventTriggerQueryState::commandList, copyObject, creating_extension, currentEventTriggerState, EventTriggerQueryState::cxt, CollectedCommand::d, fb(), CollectedCommand::in_extension, lappend(), MemoryContextSwitchTo(), palloc_object, CollectedCommand::parsetree, SCT_Simple, CollectedCommand::secondaryObject, CollectedCommand::simple, and CollectedCommand::type.

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

EventTriggerDDLCommandEnd()

void EventTriggerDDLCommandEnd ( Node *  parsetree )

extern

Definition at line 778 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, fb(), IsUnderPostmaster, list_free(), and NIL.

Referenced by ProcessUtilitySlow().

EventTriggerDDLCommandStart()

void EventTriggerDDLCommandStart ( Node *  parsetree )

extern

Definition at line 727 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, fb(), IsUnderPostmaster, list_free(), and NIL.

Referenced by ProcessUtilitySlow().

EventTriggerEndCompleteQuery()

void EventTriggerEndCompleteQuery ( void  )

extern

Definition at line 1237 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, fb(), MemoryContextDelete(), and EventTriggerQueryState::previous.

Referenced by ProcessUtilitySlow().

EventTriggerInhibitCommandCollection()

void EventTriggerInhibitCommandCollection ( void  )

extern

Definition at line 1691 of file event_trigger.c.

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

References EventTriggerQueryState::commandCollectionInhibited, and currentEventTriggerState.

Referenced by ProcessUtilitySlow().

EventTriggerOnLogin()

void EventTriggerOnLogin ( void  )

extern

Definition at line 899 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.
     *
     * 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*.
         */
        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.
                 */
                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, fb(), Form_pg_database, GETSTRUCT(), GetTransactionSnapshot(), heap_freetuple(), HeapTupleIsValid, IsUnderPostmaster, list_free(), MyDatabaseHasLoginEventTriggers, MyDatabaseId, NIL, ObjectIdGetDatum(), OidIsValid, PopActiveSnapshot(), PushActiveSnapshot(), RecoveryInProgress(), 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 )

extern

Definition at line 826 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, fb(), 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  )

extern

Definition at line 1287 of file event_trigger.c.

{
    SQLDropObject *obj;
    MemoryContext oldcxt;
 
    if (!currentEventTriggerState)
        return;
 
    Assert(EventTriggerSupportsObject(object));
 
    oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
 
    obj = palloc0_object(SQLDropObject);
    obj->address = *object;
    obj->original = original;
    obj->normal = normal;
 
    if (object->classId == NamespaceRelationId)
    {
        /* Special handling is needed for temp namespaces */
        if (isTempNamespace(object->objectId))
            obj->istemp = true;
        else if (isAnyTempNamespace(object->objectId))
        {
            /* don't report temp schemas except my own */
            pfree(obj);
            MemoryContextSwitchTo(oldcxt);
            return;
        }
        obj->objname = get_namespace_name(object->objectId);
    }
    else if (object->classId == AttrDefaultRelationId)
    {
        /* We treat a column default as temp if its table is temp */
        ObjectAddress colobject;
 
        colobject = GetAttrDefaultColumnAddress(object->objectId);
        if (OidIsValid(colobject.objectId))
        {
            if (!obtain_object_name_namespace(&colobject, obj))
            {
                pfree(obj);
                MemoryContextSwitchTo(oldcxt);
                return;
            }
        }
    }
    else if (object->classId == TriggerRelationId)
    {
        /* Similarly, a trigger is temp if its table is temp */
        /* Sadly, there's no lsyscache.c support for trigger objects */
        Relation    pg_trigger_rel;
        ScanKeyData skey[1];
        SysScanDesc sscan;
        HeapTuple   tuple;
        Oid         relid;
 
        /* Fetch the trigger's table OID the hard way */
        pg_trigger_rel = table_open(TriggerRelationId, AccessShareLock);
        ScanKeyInit(&skey[0],
                    Anum_pg_trigger_oid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(object->objectId));
        sscan = systable_beginscan(pg_trigger_rel, TriggerOidIndexId, true,
                                   NULL, 1, skey);
        tuple = systable_getnext(sscan);
        if (HeapTupleIsValid(tuple))
            relid = ((Form_pg_trigger) GETSTRUCT(tuple))->tgrelid;
        else
            relid = InvalidOid; /* shouldn't happen */
        systable_endscan(sscan);
        table_close(pg_trigger_rel, AccessShareLock);
        /* Do nothing if we didn't find the trigger */
        if (OidIsValid(relid))
        {
            ObjectAddress relobject;
 
            relobject.classId = RelationRelationId;
            relobject.objectId = relid;
            /* Arbitrarily set objectSubId nonzero so as not to fill objname */
            relobject.objectSubId = 1;
            if (!obtain_object_name_namespace(&relobject, obj))
            {
                pfree(obj);
                MemoryContextSwitchTo(oldcxt);
                return;
            }
        }
    }
    else if (object->classId == PolicyRelationId)
    {
        /* Similarly, a policy is temp if its table is temp */
        /* Sadly, there's no lsyscache.c support for policy objects */
        Relation    pg_policy_rel;
        ScanKeyData skey[1];
        SysScanDesc sscan;
        HeapTuple   tuple;
        Oid         relid;
 
        /* Fetch the policy's table OID the hard way */
        pg_policy_rel = table_open(PolicyRelationId, AccessShareLock);
        ScanKeyInit(&skey[0],
                    Anum_pg_policy_oid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(object->objectId));
        sscan = systable_beginscan(pg_policy_rel, PolicyOidIndexId, true,
                                   NULL, 1, skey);
        tuple = systable_getnext(sscan);
        if (HeapTupleIsValid(tuple))
            relid = ((Form_pg_policy) GETSTRUCT(tuple))->polrelid;
        else
            relid = InvalidOid; /* shouldn't happen */
        systable_endscan(sscan);
        table_close(pg_policy_rel, AccessShareLock);
        /* Do nothing if we didn't find the policy */
        if (OidIsValid(relid))
        {
            ObjectAddress relobject;
 
            relobject.classId = RelationRelationId;
            relobject.objectId = relid;
            /* Arbitrarily set objectSubId nonzero so as not to fill objname */
            relobject.objectSubId = 1;
            if (!obtain_object_name_namespace(&relobject, obj))
            {
                pfree(obj);
                MemoryContextSwitchTo(oldcxt);
                return;
            }
        }
    }
    else
    {
        /* Generic handling for all other object classes */
        if (!obtain_object_name_namespace(object, obj))
        {
            /* don't report temp objects except my own */
            pfree(obj);
            MemoryContextSwitchTo(oldcxt);
            return;
        }
    }
 
    /* 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, BTEqualStrategyNumber, ObjectAddress::classId, currentEventTriggerState, EventTriggerQueryState::cxt, EventTriggerSupportsObject(), fb(), Form_pg_policy, Form_pg_trigger, get_namespace_name(), GetAttrDefaultColumnAddress(), getObjectIdentityParts(), getObjectTypeDescription(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, isAnyTempNamespace(), SQLDropObject::istemp, isTempNamespace(), MemoryContextSwitchTo(), SQLDropObject::next, SQLDropObject::normal, ObjectAddress::objectId, ObjectIdGetDatum(), SQLDropObject::objecttype, SQLDropObject::objidentity, SQLDropObject::objname, obtain_object_name_namespace(), OidIsValid, SQLDropObject::original, palloc0_object, pfree(), ScanKeyInit(), slist_push_head(), EventTriggerQueryState::SQLDropList, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by deleteObjectsInList(), and DropSubscription().

EventTriggerSupportsObject()

bool EventTriggerSupportsObject ( const ObjectAddress *  object )

extern

Definition at line 1167 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, and fb().

Referenced by deleteObjectsInList(), and EventTriggerSQLDropAddObject().

EventTriggerSupportsObjectType()

bool EventTriggerSupportsObjectType ( ObjectType  obtype )

extern

Definition at line 1143 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 fb(), 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  )

extern

Definition at line 1013 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, fb(), 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  )

extern

Definition at line 1703 of file event_trigger.c.

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

References EventTriggerQueryState::commandCollectionInhibited, and currentEventTriggerState.

Referenced by ProcessUtilitySlow().

get_event_trigger_oid()

Oid get_event_trigger_oid ( const char *  trigname, bool  missing_ok  )

extern

Definition at line 581 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, fb(), GetSysCacheOid1, and OidIsValid.

Referenced by get_object_address_unqualified().

trackDroppedObjectsNeeded()

bool trackDroppedObjectsNeeded ( void  )

extern

Definition at line 1255 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().

Variable Documentation

event_triggers

PGDLLIMPORT bool event_triggers

extern

Definition at line 88 of file event_trigger.c.

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