Alvaro Herrera escribió:

> I gave this patch a look.  I'm not done with it; I mostly gave the
> utility.c changes some love so that the end result is not as cluttered.
> I did this by creating a couple of macros that call the Start() thing,
> then set the OID, then call the End() thing.  This made pretty obvious
> the places that were missing to set the object OID; I changed the CREATE
> TABLE AS code to return it, for instance.  The patch I attach applies on
> top of Dimitri's v6 patch.

... and here's the attachment.

-- 
Álvaro Herrera                http://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, Training & Services
*** a/src/backend/commands/createas.c
--- b/src/backend/commands/createas.c
***************
*** 50,55 **** typedef struct
--- 50,58 ----
        BulkInsertState bistate;        /* bulk insert state */
  } DR_intorel;
  
+ /* the OID of the created table, for ExecCreateTableAs consumption */
+ static Oid    CreateAsRelid = InvalidOid;
+ 
  static void intorel_startup(DestReceiver *self, int operation, TupleDesc 
typeinfo);
  static void intorel_receive(TupleTableSlot *slot, DestReceiver *self);
  static void intorel_shutdown(DestReceiver *self);
***************
*** 59,71 **** static void intorel_destroy(DestReceiver *self);
  /*
   * ExecCreateTableAs -- execute a CREATE TABLE AS command
   */
! void
  ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
                                  ParamListInfo params, char *completionTag)
  {
        Query      *query = (Query *) stmt->query;
        IntoClause *into = stmt->into;
        DestReceiver *dest;
        List       *rewritten;
        PlannedStmt *plan;
        QueryDesc  *queryDesc;
--- 62,75 ----
  /*
   * ExecCreateTableAs -- execute a CREATE TABLE AS command
   */
! Oid
  ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
                                  ParamListInfo params, char *completionTag)
  {
        Query      *query = (Query *) stmt->query;
        IntoClause *into = stmt->into;
        DestReceiver *dest;
+       Oid                     relOid;
        List       *rewritten;
        PlannedStmt *plan;
        QueryDesc  *queryDesc;
***************
*** 88,94 **** ExecCreateTableAs(CreateTableAsStmt *stmt, const char 
*queryString,
  
                ExecuteQuery(estmt, into, queryString, params, dest, 
completionTag);
  
!               return;
        }
        Assert(query->commandType == CMD_SELECT);
  
--- 92,100 ----
  
                ExecuteQuery(estmt, into, queryString, params, dest, 
completionTag);
  
!               relOid = CreateAsRelid;
!               CreateAsRelid = InvalidOid;
!               return relOid;
        }
        Assert(query->commandType == CMD_SELECT);
  
***************
*** 156,161 **** ExecCreateTableAs(CreateTableAsStmt *stmt, const char 
*queryString,
--- 162,172 ----
        FreeQueryDesc(queryDesc);
  
        PopActiveSnapshot();
+ 
+       relOid = CreateAsRelid;
+       CreateAsRelid = InvalidOid;
+ 
+       return relOid;
  }
  
  /*
***************
*** 353,358 **** intorel_startup(DestReceiver *self, int operation, TupleDesc 
typeinfo)
--- 364,372 ----
        myState->rel = intoRelationDesc;
        myState->output_cid = GetCurrentCommandId(true);
  
+       /* and remember the new relation's OID for ExecCreateTableAs */
+       CreateAsRelid = RelationGetRelid(myState->rel);
+ 
        /*
         * We can skip WAL-logging the insertions, unless PITR or streaming
         * replication is in use. We can skip the FSM in any case.
*** a/src/backend/commands/event_trigger.c
--- b/src/backend/commands/event_trigger.c
***************
*** 81,87 **** typedef enum
        EVENT_TRIGGER_COMMAND_TAG_NOT_RECOGNIZED
  } event_trigger_command_tag_check_result;
  
! static event_trigger_support_data event_trigger_support[] = {
        { "AGGREGATE", true },
        { "CAST", true },
        { "CONSTRAINT", true },
--- 81,88 ----
        EVENT_TRIGGER_COMMAND_TAG_NOT_RECOGNIZED
  } event_trigger_command_tag_check_result;
  
! static event_trigger_support_data event_trigger_support[] =
! {
        { "AGGREGATE", true },
        { "CAST", true },
        { "CONSTRAINT", true },
***************
*** 121,127 **** static void AlterEventTriggerOwner_internal(Relation rel,
                                                                                
        HeapTuple tup,
                                                                                
        Oid newOwnerId);
  static event_trigger_command_tag_check_result check_ddl_tag(const char *tag);
- static void error_duplicate_filter_variable(const char *defname);
  static Datum filter_list_to_array(List *filterlist);
  static Oid insert_event_trigger_tuple(char *trigname, char *eventname,
                                                                          Oid 
evtOwner, Oid funcoid,
--- 122,127 ----
***************
*** 164,176 **** CreateEventTrigger(CreateEventTrigStmt *stmt)
                         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, "ddl_command_trace") == 0))
                ereport(ERROR,
!                       (errcode(ERRCODE_SYNTAX_ERROR),
!                        errmsg("unrecognized event name \"%s\"",
!                                       stmt->eventname)));
  
        /* Validate filter conditions. */
        foreach (lc, stmt->whenclause)
--- 164,176 ----
                         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, "ddl_command_trace") != 0)
                ereport(ERROR,
!                               (errcode(ERRCODE_SYNTAX_ERROR),
!                                errmsg("unrecognized event name \"%s\"",
!                                               stmt->eventname)));
  
        /* Validate filter conditions. */
        foreach (lc, stmt->whenclause)
***************
*** 179,192 **** CreateEventTrigger(CreateEventTrigStmt *stmt)
  
                if (strcmp(def->defname, "tag") == 0)
                {
!                       if (tags != NULL)
!                               error_duplicate_filter_variable(def->defname);
                        tags = (List *) def->arg;
                }
                else if (strcmp(def->defname, "context") == 0)
                {
!                       if (contexts != NULL)
!                               error_duplicate_filter_variable(def->defname);
                        contexts = (List *) def->arg;
                }
                else
--- 179,198 ----
  
                if (strcmp(def->defname, "tag") == 0)
                {
!                       if (tags != NIL)
!                               ereport(ERROR,
!                                               (errcode(ERRCODE_SYNTAX_ERROR),
!                                                errmsg("filter variable \"%s\" 
specified more than once",
!                                                               def->defname)));
                        tags = (List *) def->arg;
                }
                else if (strcmp(def->defname, "context") == 0)
                {
!                       if (contexts != NIL)
!                               ereport(ERROR,
!                                               (errcode(ERRCODE_SYNTAX_ERROR),
!                                                errmsg("filter variable \"%s\" 
specified more than once",
!                                                               def->defname)));
                        contexts = (List *) def->arg;
                }
                else
***************
*** 359,388 **** check_ddl_tag(const char *tag)
  }
  
  /*
-  * Complain about a duplicate filter variable.
-  */
- static void
- error_duplicate_filter_variable(const char *defname)
- {
-       ereport(ERROR,
-                       (errcode(ERRCODE_SYNTAX_ERROR),
-                        errmsg("filter variable \"%s\" specified more than 
once",
-                               defname)));
- }
- 
- /*
   * Insert the new pg_event_trigger row and record dependencies.
   */
  static Oid
  insert_event_trigger_tuple(char *trigname, char *eventname, Oid evtOwner,
                                                   Oid funcoid, List *taglist, 
List *contexts)
  {
!       Relation tgrel;
        Oid         trigoid;
        HeapTuple       tuple;
        Datum           values[Natts_pg_trigger];
        bool            nulls[Natts_pg_trigger];
!       ObjectAddress myself, referenced;
  
        /* Open pg_event_trigger. */
        tgrel = heap_open(EventTriggerRelationId, RowExclusiveLock);
--- 365,383 ----
  }
  
  /*
   * Insert the new pg_event_trigger row and record dependencies.
   */
  static Oid
  insert_event_trigger_tuple(char *trigname, char *eventname, Oid evtOwner,
                                                   Oid funcoid, List *taglist, 
List *contexts)
  {
!       Relation        tgrel;
        Oid         trigoid;
        HeapTuple       tuple;
        Datum           values[Natts_pg_trigger];
        bool            nulls[Natts_pg_trigger];
!       ObjectAddress myself,
!                                 referenced;
  
        /* Open pg_event_trigger. */
        tgrel = heap_open(EventTriggerRelationId, RowExclusiveLock);
***************
*** 922,930 **** EventTriggerDDLCommandStart(Node *parsetree, 
ProcessUtilityContext context)
        {
                EventTriggerCacheItem  *item = lfirst(lc);
  
!               if (ctag->operation == COMMAND_TAG_DROP
!                       && filter_event_trigger(context, &tag, item))
! 
                        runlist = lappend_oid(runlist, item->fnoid);
        }
  
--- 917,924 ----
        {
                EventTriggerCacheItem  *item = lfirst(lc);
  
!               if (ctag->operation == COMMAND_TAG_DROP &&
!                       filter_event_trigger(context, &tag, item))
                        runlist = lappend_oid(runlist, item->fnoid);
        }
  
***************
*** 1074,1082 **** EventTriggerSupportsObjectType(ObjectType obtype)
                        /* no support for event triggers on event triggers */
                        return false;
                default:
!                       break;
        }
-       return true;
  }
  
  /*
--- 1068,1075 ----
                        /* no support for event triggers on event triggers */
                        return false;
                default:
!                       return true;
        }
  }
  
  /*
*** a/src/backend/tcop/utility.c
--- b/src/backend/tcop/utility.c
***************
*** 340,345 **** ProcessUtility(Node *parsetree,
--- 340,369 ----
                                                                dest, 
completionTag, context);
  }
  
+ #define InvokeDDLCommandEventTriggers(parsetree, context, fncall) \
+       do { \
+               EventTriggerDDLCommandStart(parsetree, context); \
+               EventTriggerTargetOid = fncall; \
+               EventTriggerDDLCommandEnd(parsetree, context); \
+       } while (0)
+ 
+ #define InvokeDDLCommandEventTriggersIfSupported(parsetree, context, fncall, 
objtype) \
+       do { \
+               Oid             _targetoid; \
+               bool    _supported = EventTriggerSupportsObjectType(objtype); \
+               \
+               if (_supported) \
+               { \
+                       EventTriggerDDLCommandStart(parsetree, context); \
+               } \
+               _targetoid = fncall; \
+               if (_supported) \
+               { \
+                       EventTriggerTargetOid = _targetoid; \
+                       EventTriggerDDLCommandEnd(parsetree, context); \
+               } \
+       } while (0)
+ 
  void
  standard_ProcessUtility(Node *parsetree,
                                                const char *queryString,
***************
*** 509,518 **** standard_ProcessUtility(Node *parsetree,
                         * relation and attribute manipulation
                         */
                case T_CreateSchemaStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateSchemaCommand((CreateSchemaStmt *) 
parsetree, queryString);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateStmt:
--- 533,541 ----
                         * relation and attribute manipulation
                         */
                case T_CreateSchemaStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                                                                               
  CreateSchemaCommand((CreateSchemaStmt *) parsetree,
!                                                                               
                                          queryString));
                        break;
  
                case T_CreateStmt:
***************
*** 574,579 **** standard_ProcessUtility(Node *parsetree,
--- 597,603 ----
                                                
CreateForeignTable((CreateForeignTableStmt *) stmt,
                                                                                
   relOid);
  
+                                               EventTriggerTargetOid = relOid;
                                                EventTriggerDDLCommandEnd(stmt, 
context);
                                        }
                                        else
***************
*** 612,685 **** standard_ProcessUtility(Node *parsetree,
                        break;
  
                case T_CreateExtensionStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateExtension((CreateExtensionStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterExtensionStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               ExecAlterExtensionStmt((AlterExtensionStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterExtensionContentsStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               ExecAlterExtensionContentsStmt(
!                                       (AlterExtensionContentsStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
! 
                        break;
  
                case T_CreateFdwStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateForeignDataWrapper((CreateFdwStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterFdwStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterForeignDataWrapper((AlterFdwStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateForeignServerStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateForeignServer((CreateForeignServerStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterForeignServerStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterForeignServer((AlterForeignServerStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateUserMappingStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateUserMapping((CreateUserMappingStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterUserMappingStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterUserMapping((AlterUserMappingStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_DropUserMappingStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       RemoveUserMapping((DropUserMappingStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_DropStmt:
--- 636,688 ----
                        break;
  
                case T_CreateExtensionStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                                                                               
  CreateExtension((CreateExtensionStmt *) parsetree));
                        break;
  
                case T_AlterExtensionStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                                                                               
 ExecAlterExtensionStmt((AlterExtensionStmt *) parsetree));
                        break;
  
                case T_AlterExtensionContentsStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                                                                               
  ExecAlterExtensionContentsStmt((AlterExtensionContentsStmt *) parsetree));
                        break;
  
                case T_CreateFdwStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               CreateForeignDataWrapper((CreateFdwStmt *) 
parsetree));
                        break;
  
                case T_AlterFdwStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               AlterForeignDataWrapper((AlterFdwStmt *) 
parsetree));
                        break;
  
                case T_CreateForeignServerStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               CreateForeignServer((CreateForeignServerStmt *) 
parsetree));
                        break;
  
                case T_AlterForeignServerStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               AlterForeignServer((AlterForeignServerStmt *) 
parsetree));
                        break;
  
                case T_CreateUserMappingStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               CreateUserMapping((CreateUserMappingStmt *) 
parsetree));
                        break;
  
                case T_AlterUserMappingStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               AlterUserMapping((AlterUserMappingStmt *) 
parsetree));
                        break;
  
                case T_DropUserMappingStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               RemoveUserMapping((DropUserMappingStmt *) 
parsetree));
                        break;
  
                case T_DropStmt:
***************
*** 756,772 **** standard_ProcessUtility(Node *parsetree,
                         */
                case T_RenameStmt:
                        {
!                               RenameStmt  *stmt;
  
                                stmt = (RenameStmt *) parsetree;
!                               if 
(EventTriggerSupportsObjectType(stmt->renameType))
!                                       EventTriggerDDLCommandStart(parsetree, 
context);
! 
!                               /* there's s no harm in setting it in all cases 
*/
!                               EventTriggerTargetOid = ExecRenameStmt(stmt);
! 
!                               if 
(EventTriggerSupportsObjectType(stmt->renameType))
!                                       EventTriggerDDLCommandEnd(parsetree, 
context);
                                break;
                        }
  
--- 759,770 ----
                         */
                case T_RenameStmt:
                        {
!                               RenameStmt *stmt;
  
                                stmt = (RenameStmt *) parsetree;
!                               
InvokeDDLCommandEventTriggersIfSupported(parsetree, context,
!                                                                               
                                 stmt->renameType,
!                                                                               
                                 ExecRenameStmt(stmt));
                                break;
                        }
  
***************
*** 775,787 **** standard_ProcessUtility(Node *parsetree,
                                AlterObjectSchemaStmt  *stmt;
  
                                stmt = (AlterObjectSchemaStmt *) parsetree;
!                               if 
(EventTriggerSupportsObjectType(stmt->objectType))
!                                       EventTriggerDDLCommandStart(parsetree, 
context);
! 
!                               EventTriggerTargetOid = 
ExecAlterObjectSchemaStmt(stmt);
! 
!                               if 
(EventTriggerSupportsObjectType(stmt->objectType))
!                                       EventTriggerDDLCommandEnd(parsetree, 
context);
                                break;
                        }
  
--- 773,781 ----
                                AlterObjectSchemaStmt  *stmt;
  
                                stmt = (AlterObjectSchemaStmt *) parsetree;
!                               
InvokeDDLCommandEventTriggersIfSupported(parsetree, context,
!                                                                               
                                 ExecAlterObjectSchemaStmt(stmt),
!                                                                               
                                 stmt->objectType);
                                break;
                        }
  
***************
*** 790,802 **** standard_ProcessUtility(Node *parsetree,
                                AlterOwnerStmt  *stmt;
  
                                stmt = (AlterOwnerStmt *) parsetree;
!                               if 
(EventTriggerSupportsObjectType(stmt->objectType))
!                                       EventTriggerDDLCommandStart(parsetree, 
context);
! 
!                               EventTriggerTargetOid = 
ExecAlterOwnerStmt(stmt);
! 
!                               if 
(EventTriggerSupportsObjectType(stmt->objectType))
!                                       EventTriggerDDLCommandEnd(parsetree, 
context);
                                break;
                        }
  
--- 784,792 ----
                                AlterOwnerStmt  *stmt;
  
                                stmt = (AlterOwnerStmt *) parsetree;
!                               
InvokeDDLCommandEventTriggersIfSupported(parsetree, context,
!                                                                               
                                 ExecAlterOwnerStmt(stmt),
!                                                                               
                                 stmt->objectType);
                                break;
                        }
  
***************
*** 927,935 **** standard_ProcessUtility(Node *parsetree,
                        break;
  
                case T_AlterDefaultPrivilegesStmt:
-                       EventTriggerDDLCommandStart(parsetree, context);
                        
ExecAlterDefaultPrivilegesStmt((AlterDefaultPrivilegesStmt *) parsetree);
-                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                        /*
--- 917,923 ----
***************
*** 996,1048 **** standard_ProcessUtility(Node *parsetree,
                        {
                                CompositeTypeStmt *stmt = (CompositeTypeStmt *) 
parsetree;
  
!                               EventTriggerDDLCommandStart(parsetree, context);
!                               EventTriggerTargetOid =
!                                       DefineCompositeType(stmt->typevar, 
stmt->coldeflist);
!                               EventTriggerDDLCommandEnd(parsetree, context);
                        }
                        break;
  
                case T_CreateEnumStmt:  /* CREATE TYPE AS ENUM */
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               DefineEnum((CreateEnumStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateRangeStmt: /* CREATE TYPE AS RANGE */
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               DefineRange((CreateRangeStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterEnumStmt:   /* ALTER TYPE (enum) */
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterEnum((AlterEnumStmt *) parsetree, 
isTopLevel);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_ViewStmt:                /* CREATE VIEW */
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               DefineView((ViewStmt *) parsetree, queryString);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateFunctionStmt:              /* CREATE FUNCTION */
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateFunction((CreateFunctionStmt *) 
parsetree, queryString);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterFunctionStmt:               /* ALTER FUNCTION */
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterFunction((AlterFunctionStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_IndexStmt:               /* CREATE INDEX */
--- 984,1022 ----
                        {
                                CompositeTypeStmt *stmt = (CompositeTypeStmt *) 
parsetree;
  
!                               InvokeDDLCommandEventTriggers(parsetree, 
context,
!                                       DefineCompositeType(stmt->typevar, 
stmt->coldeflist));
                        }
                        break;
  
                case T_CreateEnumStmt:  /* CREATE TYPE AS ENUM */
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                                                                               
 DefineEnum((CreateEnumStmt *) parsetree));
                        break;
  
                case T_CreateRangeStmt: /* CREATE TYPE AS RANGE */
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                                                                       
DefineRange((CreateRangeStmt *) parsetree));
                        break;
  
                case T_AlterEnumStmt:   /* ALTER TYPE (enum) */
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               AlterEnum((AlterEnumStmt *) parsetree, 
isTopLevel));
                        break;
  
                case T_ViewStmt:                /* CREATE VIEW */
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               DefineView((ViewStmt *) parsetree, 
queryString));
                        break;
  
                case T_CreateFunctionStmt:              /* CREATE FUNCTION */
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               CreateFunction((CreateFunctionStmt *) 
parsetree, queryString));
                        break;
  
                case T_AlterFunctionStmt:               /* ALTER FUNCTION */
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                                                                               
 AlterFunction((AlterFunctionStmt *) parsetree));
                        break;
  
                case T_IndexStmt:               /* CREATE INDEX */
***************
*** 1079,1102 **** standard_ProcessUtility(Node *parsetree,
                        break;
  
                case T_RuleStmt:                /* CREATE RULE */
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               DefineRule((RuleStmt *) parsetree, queryString);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateSeqStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               DefineSequence((CreateSeqStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                break;
  
                case T_AlterSeqStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterSequence((AlterSeqStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_DoStmt:
--- 1053,1070 ----
                        break;
  
                case T_RuleStmt:                /* CREATE RULE */
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               DefineRule((RuleStmt *) parsetree, 
queryString));
                        break;
  
                case T_CreateSeqStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               DefineSequence((CreateSeqStmt *) parsetree));
                break;
  
                case T_AlterSeqStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               AlterSequence((AlterSeqStmt *) parsetree));
                        break;
  
                case T_DoStmt:
***************
*** 1194,1203 **** standard_ProcessUtility(Node *parsetree,
                        break;
  
                case T_CreateTableAsStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       ExecCreateTableAs((CreateTableAsStmt *) parsetree,
!                                                         queryString, params, 
completionTag);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_VariableSetStmt:
--- 1162,1170 ----
                        break;
  
                case T_CreateTableAsStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                                                       
ExecCreateTableAs((CreateTableAsStmt *) parsetree,
!                                                                               
          queryString, params, completionTag));
                        break;
  
                case T_VariableSetStmt:
***************
*** 1219,1229 **** standard_ProcessUtility(Node *parsetree,
                        break;
  
                case T_CreateTrigStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
                                CreateTrigger((CreateTrigStmt *) parsetree, 
queryString,
!                                                                InvalidOid, 
InvalidOid, false);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateEventTrigStmt:
--- 1186,1194 ----
                        break;
  
                case T_CreateTrigStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
                                CreateTrigger((CreateTrigStmt *) parsetree, 
queryString,
!                                                                InvalidOid, 
InvalidOid, false));
                        break;
  
                case T_CreateEventTrigStmt:
***************
*** 1237,1256 **** standard_ProcessUtility(Node *parsetree,
                        break;
  
                case T_CreatePLangStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateProceduralLanguage((CreatePLangStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                        /*
                         * ******************************** DOMAIN statements 
****
                         */
                case T_CreateDomainStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               DefineDomain((CreateDomainStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                        /*
--- 1202,1217 ----
                        break;
  
                case T_CreatePLangStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               CreateProceduralLanguage((CreatePLangStmt *) 
parsetree));
                        break;
  
                        /*
                         * ******************************** DOMAIN statements 
****
                         */
                case T_CreateDomainStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               DefineDomain((CreateDomainStmt *) parsetree));
                        break;
  
                        /*
***************
*** 1354,1405 **** standard_ProcessUtility(Node *parsetree,
                        break;
  
                case T_CreateConversionStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateConversionCommand((CreateConversionStmt 
*) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateCastStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               CreateCast((CreateCastStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateOpClassStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               DefineOpClass((CreateOpClassStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_CreateOpFamilyStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               DefineOpFamily((CreateOpFamilyStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterOpFamilyStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterOpFamily((AlterOpFamilyStmt *) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterTSDictionaryStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterTSDictionary((AlterTSDictionaryStmt *) 
parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                case T_AlterTSConfigurationStmt:
!                       EventTriggerDDLCommandStart(parsetree, context);
!                       EventTriggerTargetOid =
!                               AlterTSConfiguration((AlterTSConfigurationStmt 
*) parsetree);
!                       EventTriggerDDLCommandEnd(parsetree, context);
                        break;
  
                default:
--- 1315,1352 ----
                        break;
  
                case T_CreateConversionStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               CreateConversionCommand((CreateConversionStmt 
*) parsetree));
                        break;
  
                case T_CreateCastStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               CreateCast((CreateCastStmt *) parsetree));
                        break;
  
                case T_CreateOpClassStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               DefineOpClass((CreateOpClassStmt *) parsetree));
                        break;
  
                case T_CreateOpFamilyStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               DefineOpFamily((CreateOpFamilyStmt *) 
parsetree));
                        break;
  
                case T_AlterOpFamilyStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               AlterOpFamily((AlterOpFamilyStmt *) parsetree));
                        break;
  
                case T_AlterTSDictionaryStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               AlterTSDictionary((AlterTSDictionaryStmt *) 
parsetree));
                        break;
  
                case T_AlterTSConfigurationStmt:
!                       InvokeDDLCommandEventTriggers(parsetree, context,
!                               AlterTSConfiguration((AlterTSConfigurationStmt 
*) parsetree));
                        break;
  
                default:
*** a/src/include/commands/createas.h
--- b/src/include/commands/createas.h
***************
*** 19,25 ****
  #include "tcop/dest.h"
  
  
! extern void ExecCreateTableAs(CreateTableAsStmt *stmt, const char 
*queryString,
                                  ParamListInfo params, char *completionTag);
  
  extern int    GetIntoRelEFlags(IntoClause *intoClause);
--- 19,25 ----
  #include "tcop/dest.h"
  
  
! extern Oid    ExecCreateTableAs(CreateTableAsStmt *stmt, const char 
*queryString,
                                  ParamListInfo params, char *completionTag);
  
  extern int    GetIntoRelEFlags(IntoClause *intoClause);
*** a/src/include/commands/event_trigger.h
--- b/src/include/commands/event_trigger.h
***************
*** 44,50 **** typedef enum {
   * split_command_tag which should be the only thing editing those pieces of
   * information.
   */
! typedef struct {
        const char                      *tag;
        const char                      *opname;
        CommandTagOperation      operation;
--- 44,51 ----
   * split_command_tag which should be the only thing editing those pieces of
   * information.
   */
! typedef struct CommandTag
! {
        const char                      *tag;
        const char                      *opname;
        CommandTagOperation      operation;
-- 
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers

Reply via email to