Add CREATE support to event triggers

*** a/src/backend/catalog/dependency.c
--- b/src/backend/catalog/dependency.c
***************
*** 2014,2019 **** add_object_address(ObjectClass oclass, Oid objectId, int32 subId,
--- 2014,2026 ----
  	addrs->numrefs++;
  }
  
+ Oid
+ get_class_catalog(ObjectClass oclass)
+ {
+ 	Assert(oclass < MAX_OCLASS);
+ 	return object_classes[oclass];
+ }
+ 
  /*
   * Add an entry to an ObjectAddresses array.
   *
*** a/src/backend/commands/createas.c
--- b/src/backend/commands/createas.c
***************
*** 55,60 **** typedef struct
--- 55,63 ----
  	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);
***************
*** 64,70 **** static void intorel_destroy(DestReceiver *self);
  /*
   * ExecCreateTableAs -- execute a CREATE TABLE AS command
   */
! void
  ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
  				  ParamListInfo params, char *completionTag)
  {
--- 67,73 ----
  /*
   * ExecCreateTableAs -- execute a CREATE TABLE AS command
   */
! Oid
  ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
  				  ParamListInfo params, char *completionTag)
  {
***************
*** 75,80 **** ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
--- 78,84 ----
  	Oid			save_userid = InvalidOid;
  	int			save_sec_context = 0;
  	int			save_nestlevel = 0;
+ 	Oid			relOid;
  	List	   *rewritten;
  	PlannedStmt *plan;
  	QueryDesc  *queryDesc;
***************
*** 98,104 **** ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
  		Assert(!is_matview);	/* excluded by syntax */
  		ExecuteQuery(estmt, into, queryString, params, dest, completionTag);
  
! 		return;
  	}
  	Assert(query->commandType == CMD_SELECT);
  
--- 102,110 ----
  		Assert(!is_matview);	/* excluded by syntax */
  		ExecuteQuery(estmt, into, queryString, params, dest, completionTag);
  
! 		relOid = CreateAsRelid;
! 		CreateAsRelid = InvalidOid;
! 		return relOid;
  	}
  	Assert(query->commandType == CMD_SELECT);
  
***************
*** 190,195 **** ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
--- 196,206 ----
  		/* Restore userid and security context */
  		SetUserIdAndSecContext(save_userid, save_sec_context);
  	}
+ 
+ 	relOid = CreateAsRelid;
+ 	CreateAsRelid = InvalidOid;
+ 
+ 	return relOid;
  }
  
  /*
***************
*** 421,426 **** intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
--- 432,440 ----
  	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
***************
*** 31,40 ****
--- 31,42 ----
  #include "pgstat.h"
  #include "lib/ilist.h"
  #include "miscadmin.h"
+ #include "tcop/deparse_utility.h"
  #include "utils/acl.h"
  #include "utils/builtins.h"
  #include "utils/evtcache.h"
  #include "utils/fmgroids.h"
+ #include "utils/json.h"
  #include "utils/lsyscache.h"
  #include "utils/memutils.h"
  #include "utils/rel.h"
***************
*** 48,53 **** typedef struct EventTriggerQueryState
--- 50,56 ----
  	slist_head	SQLDropList;
  	bool		in_sql_drop;
  	MemoryContext cxt;
+ 	List	   *stash;
  	struct EventTriggerQueryState *previous;
  } EventTriggerQueryState;
  
***************
*** 491,497 **** AlterEventTriggerOwner(const char *name, Oid newOwnerId)
  }
  
  /*
!  * Change extension owner, by OID
   */
  void
  AlterEventTriggerOwner_oid(Oid trigOid, Oid newOwnerId)
--- 494,500 ----
  }
  
  /*
!  * Change event trigger owner, by OID
   */
  void
  AlterEventTriggerOwner_oid(Oid trigOid, Oid newOwnerId)
***************
*** 1022,1034 **** EventTriggerBeginCompleteQuery(void)
  	EventTriggerQueryState *state;
  	MemoryContext cxt;
  
- 	/*
- 	 * Currently, sql_drop 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_MINSIZE,
--- 1025,1030 ----
***************
*** 1036,1043 **** EventTriggerBeginCompleteQuery(void)
  								ALLOCSET_DEFAULT_MAXSIZE);
  	state = MemoryContextAlloc(cxt, sizeof(EventTriggerQueryState));
  	state->cxt = cxt;
! 	slist_init(&(state->SQLDropList));
  	state->in_sql_drop = false;
  
  	state->previous = currentEventTriggerState;
  	currentEventTriggerState = state;
--- 1032,1041 ----
  								ALLOCSET_DEFAULT_MAXSIZE);
  	state = MemoryContextAlloc(cxt, sizeof(EventTriggerQueryState));
  	state->cxt = cxt;
! 	if (trackDroppedObjectsNeeded())
! 		slist_init(&(state->SQLDropList));
  	state->in_sql_drop = false;
+ 	state->stash = NIL;
  
  	state->previous = currentEventTriggerState;
  	currentEventTriggerState = state;
***************
*** 1294,1296 **** pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)
--- 1292,2048 ----
  
  	return (Datum) 0;
  }
+ 
+ /*
+  * Support for tracking of objects created during command run.
+  *
+  * When a command is run that creates some SQL objects, we collect the
+  * classid/objid of the objects being created, as well as the parsetree of the
+  * creation command; later, when event triggers are run for that command, they
+  * can use pg_event_trigger_get_creation_commands which computes and returns a
+  * usable representation of the creation commands for the objects.
+  */
+ typedef struct stashedObject
+ {
+ 	Oid		objectId;
+ 	Oid		classId;
+ 	Node   *parsetree;
+ } stashedObject;
+ 
+ static stashedObject *
+ newStashedObject(Oid objectId, ObjectClass class, Node *parsetree)
+ {
+ 	stashedObject *stashed = palloc(sizeof(stashedObject));
+ 
+ 	stashed->objectId = objectId;
+ 	stashed->classId = get_class_catalog(class);
+ 	stashed->parsetree = copyObject(parsetree);
+ 
+ 	return stashed;
+ }
+ 
+ void
+ EventTriggerStashCreatedObject(Oid objectId, ObjectClass class,
+ 							   Node *parsetree)
+ {
+ 	MemoryContext	oldcxt;
+ 
+ 	oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
+ 
+ 	currentEventTriggerState->stash =
+ 		lappend(currentEventTriggerState->stash,
+ 				newStashedObject(objectId, class, parsetree));
+ 
+ 	MemoryContextSwitchTo(oldcxt);
+ }
+ 
+ Datum
+ pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS)
+ {
+ 	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+ 	TupleDesc	tupdesc;
+ 	Tuplestorestate *tupstore;
+ 	MemoryContext per_query_ctx;
+ 	MemoryContext oldcontext;
+ 	ListCell   *lc;
+ 
+ 	/*
+ 	 * Protect this function from being called out of context
+ 	 */
+ 	if (!currentEventTriggerState)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 				 errmsg("%s can only be called in an event trigger function",
+ 						"pg_event_trigger_normalized_command")));
+ 
+ 	/* check to see if caller supports us returning a tuplestore */
+ 	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 				 errmsg("set-valued function called in context that cannot accept a set")));
+ 	if (!(rsinfo->allowedModes & SFRM_Materialize))
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 				 errmsg("materialize mode required, but it is not allowed in this context")));
+ 
+ 	/* Build a tuple descriptor for our result type */
+ 	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+ 		elog(ERROR, "return type must be a row type");
+ 
+ 	/* Build tuplestore to hold the result rows */
+ 	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+ 	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+ 
+ 	tupstore = tuplestore_begin_heap(true, false, work_mem);
+ 	rsinfo->returnMode = SFRM_Materialize;
+ 	rsinfo->setResult = tupstore;
+ 	rsinfo->setDesc = tupdesc;
+ 
+ 	MemoryContextSwitchTo(oldcontext);
+ 
+ 	foreach(lc, currentEventTriggerState->stash)
+ 	{
+ 		stashedObject *obj = lfirst(lc);
+ 		char	   *command;
+ 
+ 		deparse_utility_command(obj->objectId, obj->parsetree,
+ 								&command);
+ 
+ 		/*
+ 		 * Some parse trees return NULL when deparse is attempted; we don't
+ 		 * emit anything for them.
+ 		 */
+ 		if (command != NULL)
+ 		{
+ 			Datum		values[2];
+ 			bool		nulls[2];
+ 			ObjectAddress addr;
+ 			char	   *identity;
+ 			int			i = 0;
+ 
+ 			addr.classId = obj->classId;
+ 			addr.objectId = obj->objectId;
+ 			addr.objectSubId = 0;
+ 			identity = getObjectIdentity(&addr);
+ 
+ 			MemSet(nulls, 0, sizeof(nulls));
+ 
+ 			/* identity */
+ 			values[i++] = CStringGetTextDatum(identity);
+ 			/* command */
+ 			values[i++] = CStringGetTextDatum(command);
+ 
+ 			tuplestore_putvalues(tupstore, tupdesc, values, nulls);
+ 			pfree(identity);
+ 		}
+ 	}
+ 
+ 	/* clean up and return the tuplestore */
+ 	tuplestore_donestoring(tupstore);
+ 
+ 	PG_RETURN_VOID();
+ }
+ 
+ /* ************************* JSON STUFF FROM HERE ************************* *
+  *  Code below is used to decode blobs returned by deparse_utility_command  *
+  *																			*/
+ 
+ /*
+  * Note we only support types that are valid in command representation from
+  * deparse_utility_command.
+  */
+ typedef enum
+ {
+ 	JsonIsArray,
+ 	JsonIsObject,
+ 	JsonIsString
+ } JsonType;
+ 
+ typedef enum
+ {
+ 	SpecTypename,
+ 	SpecDottedName,
+ 	SpecString,
+ 	SpecIdentifier
+ } convSpecifier;
+ 
+ /*
+  * Extract the named json field, which must be of type string, from the given
+  * JSON datum, which must be of type object.  If the field doesn't exist,
+  * NULL is returned.  Otherwise the string value is returned, and value_len,
+  * if not NULL, is set to its length.
+  */
+ static char *
+ _expand_get_strval(Datum json, char *field_name, int *value_len)
+ {
+ 	FunctionCallInfoData fcinfo;
+ 	Datum	result;
+ 	char   *value_str;
+ 
+ 	InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+ 
+ 	fcinfo.arg[0] = json;
+ 	fcinfo.argnull[0] = false;
+ 	fcinfo.arg[1] = CStringGetTextDatum(field_name);
+ 	fcinfo.argnull[1] = false;
+ 
+ 	result = (*json_object_field_text) (&fcinfo);
+ 
+ 	if (fcinfo.isnull)
+ 		return NULL;
+ 
+ 	value_str = TextDatumGetCString(result);
+ 	if (value_len)
+ 		*value_len = VARSIZE_ANY_EXHDR(result);
+ 
+ 	pfree(DatumGetPointer(result));
+ 
+ 	return value_str;
+ }
+ 
+ /*
+  * Extract the named json field, which must be of type boolean, from the given
+  * JSON datum, which must be of type object.  If the field doesn't exist,
+  * isnull is set to TRUE and the return value should not be consulted.
+  * Otherwise the boolean value is returned.
+  */
+ static bool
+ _expand_get_boolval(Datum json, char *field_name, bool *isnull)
+ {
+ 	FunctionCallInfoData fcinfo;
+ 	Datum	result;
+ 	char   *value_str;
+ 
+ 	InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+ 
+ 	fcinfo.arg[0] = json;
+ 	fcinfo.argnull[0] = false;
+ 	fcinfo.arg[1] = CStringGetTextDatum(field_name);
+ 	fcinfo.argnull[1] = false;
+ 
+ 	result = (*json_object_field_text) (&fcinfo);
+ 
+ 	if (fcinfo.isnull)
+ 	{
+ 		*isnull = true;
+ 		return false;
+ 	}
+ 
+ 	value_str = TextDatumGetCString(result);
+ 
+ 	if (strcmp(value_str, "true") == 0)
+ 		return true;
+ 
+ 	Assert(strcmp(value_str, "false") == 0);
+ 	return false;
+ }
+ 
+ /*
+  * Given a JSON value, return its type.
+  *
+  * We return both a JsonType (for easy control flow), and a string name (for
+  * error reporting).
+  */
+ static JsonType
+ jsonval_get_type(Datum jsonval, char **typename)
+ {
+ 
+ 	JsonType json_elt_type;
+ 	Datum	paramtype_datum;
+ 	char   *paramtype;
+ 
+ 	paramtype_datum = DirectFunctionCall1(json_typeof, jsonval);
+ 	paramtype = TextDatumGetCString(paramtype_datum);
+ 
+ 	if (strcmp(paramtype, "array") == 0)
+ 		json_elt_type = JsonIsArray;
+ 	else if (strcmp(paramtype, "object") == 0)
+ 		json_elt_type = JsonIsObject;
+ 	else if (strcmp(paramtype, "string") == 0)
+ 		json_elt_type = JsonIsString;
+ 	else
+ 		/* XXX improve this; need to specify array index or param name */
+ 		elog(ERROR, "unexpected JSON element type %s",
+ 			 paramtype);
+ 
+ 	if (typename)
+ 		*typename = pstrdup(paramtype);
+ 
+ 	return json_elt_type;
+ }
+ 
+ /*
+  * dequote_jsonval
+  * 		Take a string value extracted from a JSON object, and return a copy of it
+  * 		with the quoting removed.
+  *
+  * Another alternative to this would be to run the extraction routine again,
+  * using the "_text" variant which returns the value without quotes; but this
+  * is expensive, and moreover it complicates the logic a lot because not all
+  * values are extracted in the same way (some are extracted using
+  * json_object_field, others using json_array_element).  Dequoting the object
+  * already at hand is a lot easier.
+  */
+ static char *
+ dequote_jsonval(char *jsonval)
+ {
+ 	char   *result;
+ 	int		inputlen = strlen(jsonval);
+ 	int		i;
+ 	int		j = 0;
+ 
+ 	result = palloc(strlen(jsonval) + 1);
+ 
+ 	/* skip the start and end quotes right away */
+ 	for (i = 1; i < inputlen - 1; i++)
+ 	{
+ 		/*
+ 		 * XXX this skips the \ in a \" sequence but leaves other escaped
+ 		 * sequences in place.  Are there other cases we need to handle
+ 		 * specially?
+ 		 */
+ 		if (jsonval[i] == '\\' &&
+ 			jsonval[i + 1] == '"')
+ 		{
+ 			i++;
+ 			continue;
+ 		}
+ 
+ 		result[j++] = jsonval[i];
+ 	}
+ 	result[j] = '\0';
+ 
+ 	return result;
+ }
+ 
+ /*
+  * Expand a json value as an identifier.  The value must be of type string.
+  */
+ static void
+ expand_jsonval_identifier(StringInfo buf, Datum jsonval)
+ {
+ 	char   *unquoted;
+ 
+ 	unquoted = dequote_jsonval(TextDatumGetCString(jsonval));
+ 	appendStringInfo(buf, "%s", quote_identifier(unquoted));
+ 
+ 	pfree(unquoted);
+ }
+ 
+ /*
+  * Expand a json value as a dotted-name.  The value must be of type object
+  * and must contain elements "schema" (optional) and "relation" (mandatory).
+  *
+  * XXX maybe "relation" should be called something else, as this is used for
+  * qualified names of any kind, not just relations.
+  */
+ static void
+ expand_jsonval_dottedname(StringInfo buf, Datum jsonval)
+ {
+ 	char *schema;
+ 	char *relation;
+ 	const char *qschema;
+ 	const char *qrel;
+ 
+ 	schema = _expand_get_strval(jsonval, "schema", NULL);
+ 	relation = _expand_get_strval(jsonval, "relation", NULL);
+ 	if (relation == NULL)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("invalid NULL relation name in %%D element")));
+ 
+ 	qrel = quote_identifier(relation);
+ 	if (schema == NULL)
+ 	{
+ 		appendStringInfo(buf, "%s", qrel);
+ 	}
+ 	else
+ 	{
+ 		qschema = quote_identifier(schema);
+ 		appendStringInfo(buf, "%s.%s",
+ 						 qschema, qrel);
+ 		if (qschema != schema)
+ 			pfree((char *) qschema);
+ 		pfree(schema);
+ 	}
+ 
+ 	if (qrel != relation)
+ 		pfree((char *) qrel);
+ 	pfree(relation);
+ }
+ 
+ /*
+  * expand a json value as a type name.
+  */
+ static void
+ expand_jsonval_typename(StringInfo buf, Datum jsonval)
+ {
+ 	char   *schema = NULL;
+ 	char   *typename;
+ 	char   *typmodstr;
+ 	bool	array_isnull;
+ 	bool	system_isnull;
+ 	bool	is_system;
+ 	bool	is_array;
+ 
+ 	typename = _expand_get_strval(jsonval, "typename", NULL);
+ 	if (typename == NULL)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("invalid NULL type name in %%T element")));
+ 	typmodstr = _expand_get_strval(jsonval, "typmod", NULL);	/* OK if null */
+ 	is_system = _expand_get_boolval(jsonval, "is_system", &system_isnull);
+ 	if (system_isnull)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("invalid NULL is_system flag in %%T element")));
+ 
+ 	is_array = _expand_get_boolval(jsonval, "is_array", &array_isnull);
+ 
+ 	/*
+ 	 * When a system type, must not schema-qualify and must not quote the name
+ 	 * either.
+ 	 */
+ 	if (!is_system)
+ 		schema = _expand_get_strval(jsonval, "schema", NULL);
+ 
+ 	/*
+ 	 * schema might be NULL here either because it's a system type, or because
+ 	 * the data specifies no schema value.
+ 	 */
+ 	if (schema == NULL || schema[0] == '\0')
+ 	{
+ 		appendStringInfo(buf, "%s%s%s",
+ 						 typename,
+ 						 typmodstr ? typmodstr : "",
+ 						 is_array ? "[]" : "");
+ 	}
+ 	else
+ 	{
+ 		appendStringInfo(buf, "%s.%s%s%s",
+ 						 quote_identifier(schema),
+ 						 quote_identifier(typename),
+ 						 typmodstr ? typmodstr : "",
+ 						 is_array ? "[]" : "");
+ 	}
+ }
+ 
+ /*
+  * Expand a json value as a string.  The value must be of type string or of
+  * type object, in which case it must contain a "fmt" element which will be
+  * recursively expanded; also, if the object contains an element "present"
+  * and it is set to false, the expansion is the empty string.
+  */
+ static void
+ expand_jsonval_string(StringInfo buf, Datum jsonval, JsonType json_elt_type)
+ {
+ 	if (json_elt_type == JsonIsString)
+ 	{
+ 		char   *str;
+ 		char   *unquoted;
+ 
+ 		str = TextDatumGetCString(jsonval);
+ 		unquoted = dequote_jsonval(str);
+ 		appendStringInfo(buf, "%s", unquoted);
+ 		pfree(str);
+ 		pfree(unquoted);
+ 	}
+ 	else if (json_elt_type == JsonIsObject)
+ 	{
+ 		bool	present;
+ 		bool	isnull;
+ 
+ 		present = _expand_get_boolval(jsonval, "present", &isnull);
+ 
+ 		if (isnull || present)
+ 		{
+ 			Datum	inner;
+ 			char   *str;
+ 
+ 			inner = DirectFunctionCall1(pg_event_trigger_expand_command,
+ 										jsonval);
+ 			str = TextDatumGetCString(inner);
+ 
+ 			appendStringInfoString(buf, str);
+ 			pfree(DatumGetPointer(inner));
+ 			pfree(str);
+ 		}
+ 	}
+ }
+ 
+ /*
+  * Expand one json element according to rules.
+  */
+ static void
+ expand_one_element(StringInfo buf, char *param,
+ 				   Datum jsonval, char *valtype, JsonType json_elt_type,
+ 				   convSpecifier specifier)
+ {
+ 	/*
+ 	 * Validate the parameter type.  If dotted-name was specified, then a JSON
+ 	 * object element is expected; if an identifier was specified, then a JSON
+ 	 * string is expected.  If a string was specified, then either a JSON
+ 	 * object or a string is expected.
+ 	 */
+ 	if (specifier == SpecDottedName && json_elt_type != JsonIsObject)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("expected JSON object for %%D element \"%s\", got %s",
+ 						param, valtype)));
+ 	if (specifier == SpecTypename && json_elt_type != JsonIsObject)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("expected JSON object for %%T element \"%s\", got %s",
+ 						param, valtype)));
+ 	if (specifier == SpecIdentifier && json_elt_type != JsonIsString)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("expected JSON string for %%I element \"%s\", got %s",
+ 						param, valtype)));
+ 	if (specifier == SpecString &&
+ 		json_elt_type != JsonIsString && json_elt_type != JsonIsObject)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("expected JSON string or object for %%s element \"%s\", got %s",
+ 						param, valtype)));
+ 
+ 	switch (specifier)
+ 	{
+ 		case SpecIdentifier:
+ 			expand_jsonval_identifier(buf, jsonval);
+ 			break;
+ 
+ 		case SpecDottedName:
+ 			expand_jsonval_dottedname(buf, jsonval);
+ 			break;
+ 
+ 		case SpecString:
+ 			expand_jsonval_string(buf, jsonval, json_elt_type);
+ 			break;
+ 
+ 		case SpecTypename:
+ 			expand_jsonval_typename(buf, jsonval);
+ 			break;
+ 	}
+ }
+ 
+ /*
+  * Expand one JSON array element according to rules.
+  */
+ static void
+ expand_one_array_element(StringInfo buf, Datum array, int idx, char *param,
+ 						 convSpecifier specifier)
+ {
+ 	Datum		elemval;
+ 	JsonType	json_elt_type;
+ 	char	   *elemtype;
+ 
+ 	elemval = DirectFunctionCall2(json_array_element,
+ 								  PointerGetDatum(array),
+ 								  Int32GetDatum(idx));
+ 	json_elt_type = jsonval_get_type(elemval, &elemtype);
+ 
+ 	expand_one_element(buf, param,
+ 					   elemval, elemtype, json_elt_type,
+ 					   specifier);
+ }
+ 
+ #define ADVANCE_PARSE_POINTER(ptr,end_ptr) \
+ 	do { \
+ 		if (++(ptr) >= (end_ptr)) \
+ 			ereport(ERROR, \
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+ 					 errmsg("unterminated format specifier"))); \
+ 	} while (0)
+ 
+ /*------
+  * Returns a formatted string from a JSON object.
+  *
+  * The starting point is the element named "fmt" (which must be a string).
+  * This format string may contain zero or more %-escapes, which consist of an
+  * element name enclosed in { }, possibly followed by a conversion modifier,
+  * followed by a conversion specifier.  Possible conversion specifiers are:
+  *
+  * %		expand to a literal %.
+  * I		expand as a single, non-qualified identifier
+  * D		expand as a possibly-qualified identifier
+  * T		expand as a type name
+  * s		expand as a simple string (no quoting)
+  *
+  * The element name may have an optional separator specification preceded
+  * by a colon.  Its presence indicates that the element is expected to be
+  * an array; the specified separator is used to join the array elements.
+  *
+  * XXX the current implementation works fine, but is likely to be slow: for
+  * each element found in the fmt string we parse the JSON object once.  It
+  * might be better to use jsonapi.h directly so that we build a hash or tree of
+  * elements and their values once before parsing the fmt string, and later scan
+  * fmt using the tree.
+  *------
+  */
+ Datum
+ pg_event_trigger_expand_command(PG_FUNCTION_ARGS)
+ {
+ 
+ 	text	*json = PG_GETARG_TEXT_P(0);
+ 	char   *fmt_str;
+ 	int		fmt_len;
+ 	const char *cp;
+ 	const char *start_ptr;
+ 	const char *end_ptr;
+ 	StringInfoData str;
+ 
+ 	fmt_str = _expand_get_strval(PointerGetDatum(json), "fmt",
+ 								 &fmt_len);
+ 
+ 	if (fmt_str == NULL)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("invalid NULL format string")));
+ 
+ 	start_ptr = fmt_str;
+ 	end_ptr = start_ptr + fmt_len;
+ 	initStringInfo(&str);
+ 
+ 	for (cp = start_ptr; cp < end_ptr; cp++)
+ 	{
+ 		convSpecifier specifier;
+ 		bool	is_array;
+ 		char   *param = NULL;
+ 		char   *arraysep = NULL;
+ 		Datum	paramval;
+ 		char   *paramtype;
+ 		JsonType json_elt_type;
+ 
+ 		if (*cp != '%')
+ 		{
+ 			appendStringInfoCharMacro(&str, *cp);
+ 			continue;
+ 		}
+ 
+ 		is_array = false;
+ 
+ 		ADVANCE_PARSE_POINTER(cp, end_ptr);
+ 
+ 		/* Easy case: %% outputs a single % */
+ 		if (*cp == '%')
+ 		{
+ 			appendStringInfoCharMacro(&str, *cp);
+ 			continue;
+ 		}
+ 
+ 		/*
+ 		 * Scan the mandatory element name.  Allow for an array separator
+ 		 * (which may be the empty string) to be specified after colon.
+ 		 */
+ 		if (*cp == '{')
+ 		{
+ 			StringInfoData	parbuf;
+ 			StringInfoData	arraysepbuf;
+ 			StringInfo		appendTo;
+ 
+ 			initStringInfo(&parbuf);
+ 			appendTo = &parbuf;
+ 
+ 			ADVANCE_PARSE_POINTER(cp, end_ptr);
+ 			for (; cp < end_ptr; )
+ 			{
+ 				if (*cp == ':')
+ 				{
+ 					/*
+ 					 * found array separator delimiter; element name is now
+ 					 * complete, start filling the separator.
+ 					 */
+ 					initStringInfo(&arraysepbuf);
+ 					appendTo = &arraysepbuf;
+ 					is_array = true;
+ 					ADVANCE_PARSE_POINTER(cp, end_ptr);
+ 					continue;
+ 				}
+ 
+ 				if (*cp == '}')
+ 				{
+ 					ADVANCE_PARSE_POINTER(cp, end_ptr);
+ 					break;
+ 				}
+ 				appendStringInfoCharMacro(appendTo, *cp);
+ 				ADVANCE_PARSE_POINTER(cp, end_ptr);
+ 			}
+ 			param = parbuf.data;
+ 			if (is_array)
+ 				arraysep = arraysepbuf.data;
+ 		}
+ 		if (param == NULL)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("missing conversion name in conversion specifier")));
+ 
+ 		/*
+ 		 * The following conversion specifiers are currently recognized:
+ 		 * 'I' -- expand as an identifier, adding quotes if necessary
+ 		 * 'D' -- expand as a dotted-name, for qualified names; each element
+ 		 * is quoted if necessary
+ 		 * 's' -- expand as a simple string; no quoting.
+ 		 */
+ 		switch (*cp)
+ 		{
+ 			case 'I':
+ 				specifier = SpecIdentifier;
+ 				break;
+ 			case 'D':
+ 				specifier = SpecDottedName;
+ 				break;
+ 			case 's':
+ 				specifier = SpecString;
+ 				break;
+ 			case 'T':
+ 				specifier = SpecTypename;
+ 				break;
+ 			default:
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("invalid conversion specifier \"%c\"", *cp)));
+ 		}
+ 
+ 		/*
+ 		 * Obtain the element to be expanded.  Note we cannot use
+ 		 * DirectFunctionCall here, because the element might not exist.
+ 		 */
+ 		{
+ 			FunctionCallInfoData fcinfo;
+ 
+ 			InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+ 
+ 			fcinfo.arg[0] = PointerGetDatum(json);
+ 			fcinfo.argnull[0] = false;
+ 			fcinfo.arg[1] = CStringGetTextDatum(param);
+ 			fcinfo.argnull[1] = false;
+ 
+ 			paramval = (*json_object_field) (&fcinfo);
+ 
+ 			if (fcinfo.isnull)
+ 			{
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("non-existant element \"%s\" in JSON formatting object",
+ 								param)));
+ 			}
+ 		}
+ 
+ 		/* figure out its type */
+ 		json_elt_type = jsonval_get_type(paramval, &paramtype);
+ 
+ 		/* Validate that we got an array if the format string specified one. */
+ 		if (is_array && json_elt_type != JsonIsArray)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("expected JSON array for element \"%s\", got %s",
+ 							param, paramtype)));
+ 
+ 		/* And finally print out the data */
+ 		if (is_array)
+ 		{
+ 			int		count;
+ 			bool	putsep = false;
+ 			int		i;
+ 
+ 			count = DatumGetInt32(DirectFunctionCall1(json_array_length,
+ 													  paramval));
+ 			for (i = 0; i < count; i++)
+ 			{
+ 				if (putsep)
+ 					appendStringInfoString(&str, arraysep);
+ 				putsep = true;
+ 
+ 				expand_one_array_element(&str, paramval, i, param, specifier);
+ 			}
+ 		}
+ 		else
+ 		{
+ 			expand_one_element(&str, param, paramval, paramtype, json_elt_type,
+ 							   specifier);
+ 		}
+ 	}
+ 
+ 	PG_RETURN_TEXT_P(CStringGetTextDatum(str.data));
+ }
*** a/src/backend/commands/matview.c
--- b/src/backend/commands/matview.c
***************
*** 132,138 **** SetMatViewPopulatedState(Relation relation, bool newstate)
   * The matview's "populated" state is changed based on whether the contents
   * reflect the result set of the materialized view's query.
   */
! void
  ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
  				   ParamListInfo params, char *completionTag)
  {
--- 132,138 ----
   * The matview's "populated" state is changed based on whether the contents
   * reflect the result set of the materialized view's query.
   */
! Oid
  ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
  				   ParamListInfo params, char *completionTag)
  {
***************
*** 274,279 **** ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
--- 274,281 ----
  	}
  	else
  		refresh_by_heap_swap(matviewOid, OIDNewHeap);
+ 
+ 	return matviewOid;
  }
  
  /*
*** a/src/backend/commands/schemacmds.c
--- b/src/backend/commands/schemacmds.c
***************
*** 24,29 ****
--- 24,30 ----
  #include "catalog/objectaccess.h"
  #include "catalog/pg_namespace.h"
  #include "commands/dbcommands.h"
+ #include "commands/event_trigger.h"
  #include "commands/schemacmds.h"
  #include "miscadmin.h"
  #include "parser/parse_utilcmd.h"
***************
*** 130,135 **** CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString)
--- 131,145 ----
  	PushOverrideSearchPath(overridePath);
  
  	/*
+ 	 * Report the new schema to possibly interested event triggers.  Note we
+ 	 * must do this here and not in ProcessUtilitySlow because otherwise the
+ 	 * objects created below are reported before the schema, which would be
+ 	 * wrong.
+ 	 */
+ 	EventTriggerStashCreatedObject(namespaceId, OCLASS_SCHEMA,
+ 								   (Node *) stmt);
+ 
+ 	/*
  	 * Examine the list of commands embedded in the CREATE SCHEMA command, and
  	 * reorganize them into a sequentially executable order with no forward
  	 * references.	Note that the result is still a list of raw parsetrees ---
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 43,48 ****
--- 43,49 ----
  #include "catalog/pg_type_fn.h"
  #include "catalog/storage.h"
  #include "catalog/toasting.h"
+ #include "commands/alter_table.h"
  #include "commands/cluster.h"
  #include "commands/comment.h"
  #include "commands/defrem.h"
***************
*** 112,165 **** typedef struct OnCommitItem
  static List *on_commits = NIL;
  
  
- /*
-  * State information for ALTER TABLE
-  *
-  * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
-  * structs, one for each table modified by the operation (the named table
-  * plus any child tables that are affected).  We save lists of subcommands
-  * to apply to this table (possibly modified by parse transformation steps);
-  * these lists will be executed in Phase 2.  If a Phase 3 step is needed,
-  * necessary information is stored in the constraints and newvals lists.
-  *
-  * Phase 2 is divided into multiple passes; subcommands are executed in
-  * a pass determined by subcommand type.
-  */
- 
- #define AT_PASS_UNSET			-1		/* UNSET will cause ERROR */
- #define AT_PASS_DROP			0		/* DROP (all flavors) */
- #define AT_PASS_ALTER_TYPE		1		/* ALTER COLUMN TYPE */
- #define AT_PASS_OLD_INDEX		2		/* re-add existing indexes */
- #define AT_PASS_OLD_CONSTR		3		/* re-add existing constraints */
- #define AT_PASS_COL_ATTRS		4		/* set other column attributes */
- /* We could support a RENAME COLUMN pass here, but not currently used */
- #define AT_PASS_ADD_COL			5		/* ADD COLUMN */
- #define AT_PASS_ADD_INDEX		6		/* ADD indexes */
- #define AT_PASS_ADD_CONSTR		7		/* ADD constraints, defaults */
- #define AT_PASS_MISC			8		/* other stuff */
- #define AT_NUM_PASSES			9
- 
- typedef struct AlteredTableInfo
- {
- 	/* Information saved before any work commences: */
- 	Oid			relid;			/* Relation to work on */
- 	char		relkind;		/* Its relkind */
- 	TupleDesc	oldDesc;		/* Pre-modification tuple descriptor */
- 	/* Information saved by Phase 1 for Phase 2: */
- 	List	   *subcmds[AT_NUM_PASSES]; /* Lists of AlterTableCmd */
- 	/* Information saved by Phases 1/2 for Phase 3: */
- 	List	   *constraints;	/* List of NewConstraint */
- 	List	   *newvals;		/* List of NewColumnValue */
- 	bool		new_notnull;	/* T if we added new NOT NULL constraints */
- 	bool		rewrite;		/* T if a rewrite is forced */
- 	Oid			newTableSpace;	/* new tablespace; 0 means no change */
- 	/* Objects to rebuild after completing ALTER TYPE operations */
- 	List	   *changedConstraintOids;	/* OIDs of constraints to rebuild */
- 	List	   *changedConstraintDefs;	/* string definitions of same */
- 	List	   *changedIndexOids;		/* OIDs of indexes to rebuild */
- 	List	   *changedIndexDefs;		/* string definitions of same */
- } AlteredTableInfo;
- 
  /* Struct describing one new constraint to check in Phase 3 scan */
  /* Note: new NOT NULL constraints are handled elsewhere */
  typedef struct NewConstraint
--- 113,118 ----
*** a/src/backend/tcop/Makefile
--- b/src/backend/tcop/Makefile
***************
*** 12,18 **** subdir = src/backend/tcop
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS= dest.o fastpath.o postgres.o pquery.o utility.o
  
  ifneq (,$(filter $(PORTNAME),cygwin win32))
  override CPPFLAGS += -DWIN32_STACK_RLIMIT=$(WIN32_STACK_RLIMIT)
--- 12,18 ----
  top_builddir = ../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS= dest.o deparse_utility.o fastpath.o postgres.o pquery.o utility.o
  
  ifneq (,$(filter $(PORTNAME),cygwin win32))
  override CPPFLAGS += -DWIN32_STACK_RLIMIT=$(WIN32_STACK_RLIMIT)
*** /dev/null
--- b/src/backend/tcop/deparse_utility.c
***************
*** 0 ****
--- 1,1030 ----
+ /*-------------------------------------------------------------------------
+  *
+  * deparse_utility.c
+  *	  Functions to convert utility commands back to command strings
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *
+  * IDENTIFICATION
+  *	  src/backend/tcop/deparse_utility.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ #include "access/htup_details.h"
+ #include "catalog/heap.h"
+ #include "catalog/index.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_class.h"
+ #include "catalog/pg_inherits.h"
+ #include "catalog/pg_proc.h"
+ #include "catalog/pg_type.h"
+ #include "commands/defrem.h"
+ #include "funcapi.h"
+ #include "lib/ilist.h"
+ #include "lib/stringinfo.h"
+ #include "nodes/makefuncs.h"
+ #include "nodes/parsenodes.h"
+ #include "parser/analyze.h"
+ #include "parser/parse_collate.h"
+ #include "parser/parse_expr.h"
+ #include "parser/parse_relation.h"
+ #include "parser/parse_type.h"
+ #include "tcop/deparse_utility.h"
+ #include "utils/builtins.h"
+ #include "utils/fmgroids.h"
+ #include "utils/json.h"
+ #include "utils/lsyscache.h"
+ #include "utils/memutils.h"
+ #include "utils/rel.h"
+ #include "utils/syscache.h"
+ 
+ 
+ typedef enum
+ {
+ 	ParamTypeNull,
+ 	ParamTypeBoolean,
+ 	ParamTypeString,
+ 	ParamTypeArray,
+ 	ParamTypeObject
+ } ParamType;
+ 
+ typedef struct deparseParam
+ {
+ 	char   *name;
+ 	ParamType type;
+ 	bool	bool_value;
+ 	char   *str_value;
+ 	struct deparseParams *obj_value;
+ 	List   *array_value;
+ 	slist_node node;
+ } deparseParam;
+ 
+ typedef struct deparseParams
+ {
+ 	MemoryContext cxt;
+ 	slist_head	params;
+ 	int			numParams;
+ } deparseParams;
+ 
+ /*
+  * Allocate a new object to store parameters.  If parent is NULL, a new memory
+  * context is created for all allocations involving the parameters; if it's not
+  * null, then the memory context from the given object is used.
+  */
+ static deparseParams *
+ setup_params(deparseParams *parent)
+ {
+ 	MemoryContext	cxt;
+ 	deparseParams  *params;
+ 
+ 	if (parent == NULL)
+ 	{
+ 		cxt = AllocSetContextCreate(CurrentMemoryContext,
+ 									"deparse parameters",
+ 									ALLOCSET_DEFAULT_MINSIZE,
+ 									ALLOCSET_DEFAULT_INITSIZE,
+ 									ALLOCSET_DEFAULT_MAXSIZE);
+ 	}
+ 	else
+ 		cxt = parent->cxt;
+ 
+ 	params = MemoryContextAlloc(cxt, sizeof(deparseParams));
+ 	params->cxt = cxt;
+ 	params->numParams = 0;
+ 	slist_init(&params->params);
+ 
+ 	return params;
+ }
+ 
+ /*
+  * Add a new parameter with a NULL value
+  */
+ static void
+ append_null_param(deparseParams *params, char *name)
+ {
+ 	deparseParam	*param;
+ 
+ 	param = MemoryContextAllocZero(params->cxt, sizeof(deparseParam));
+ 
+ 	param->name = MemoryContextStrdup(params->cxt, name);
+ 	param->type = ParamTypeNull;
+ 
+ 	slist_push_head(&params->params, &param->node);
+ 	params->numParams++;
+ }
+ 
+ /*
+  * Add a new boolean parameter
+  */
+ static void
+ append_boolean_param(deparseParams *params, char *name, bool value)
+ {
+ 	deparseParam	*param;
+ 
+ 	param = MemoryContextAllocZero(params->cxt, sizeof(deparseParam));
+ 
+ 	param->name = MemoryContextStrdup(params->cxt, name);
+ 	param->type = ParamTypeBoolean;
+ 	param->bool_value = value;
+ 
+ 	slist_push_head(&params->params, &param->node);
+ 	params->numParams++;
+ }
+ 
+ /*
+  * Add a new string parameter.
+  */
+ static void
+ append_string_param(deparseParams *params, char *name, char *value)
+ {
+ 	deparseParam	*param;
+ 
+ 	param = MemoryContextAllocZero(params->cxt, sizeof(deparseParam));
+ 
+ 	param->name = MemoryContextStrdup(params->cxt, name);
+ 	param->type = ParamTypeString;
+ 	param->str_value = MemoryContextStrdup(params->cxt, value);
+ 
+ 	slist_push_head(&params->params, &param->node);
+ 	params->numParams++;
+ }
+ 
+ /*
+  * Add a new JSON parameter
+  */
+ static void
+ append_object_param(deparseParams *params, char *name, deparseParams *value)
+ {
+ 	deparseParam	*param;
+ 
+ 	param = MemoryContextAllocZero(params->cxt, sizeof(deparseParam));
+ 
+ 	param->name = MemoryContextStrdup(params->cxt, name);
+ 	param->type = ParamTypeObject;
+ 	param->obj_value = value;	/* XXX not duped */
+ 
+ 	slist_push_head(&params->params, &param->node);
+ 	params->numParams++;
+ }
+ 
+ /*
+  * add a new array parameter
+  */
+ static void
+ append_array_param(deparseParams *params, char *name, List *array)
+ {
+ 	deparseParam   *param;
+ 
+ 	param = MemoryContextAllocZero(params->cxt, sizeof(deparseParam));
+ 
+ 	param->name = MemoryContextStrdup(params->cxt, name);
+ 	param->type = ParamTypeArray;
+ 	param->array_value = array;	/* XXX not duped */
+ 
+ 	slist_push_head(&params->params, &param->node);
+ 	params->numParams++;
+ }
+ 
+ /*
+  * Release all memory used by parameters and their expansion
+  */
+ static void
+ free_params(deparseParams *params)
+ {
+ 	MemoryContextDelete(params->cxt);
+ }
+ 
+ /*
+  * Create a true JSON object from our ad-hoc representation.
+  *
+  * Note this allocates memory in params->cxt.  We don't need a separate memory
+  * context, and the one provided by the params object has the right lifetime.
+  */
+ static char *
+ finalize_params(deparseParams *params)
+ {
+ 	TupleDesc	tupdesc;
+ 	MemoryContext oldcxt;
+ 	Datum	   *values;
+ 	bool	   *nulls;
+ 	HeapTuple	htup;
+ 	int			i;
+ 	Datum		json;
+ 	char	   *jsonstr;
+ 	slist_iter	iter;
+ 
+ 	oldcxt = MemoryContextSwitchTo(params->cxt);
+ 	tupdesc = CreateTemplateTupleDesc(params->numParams, false);
+ 	values = palloc(sizeof(Datum) * params->numParams);
+ 	nulls = palloc(sizeof(bool) * params->numParams);
+ 
+ 	i = 1;
+ 	slist_foreach(iter, &params->params)
+ 	{
+ 		deparseParam *param = slist_container(deparseParam, node, iter.cur);
+ 		Oid		typeid;
+ 
+ 		switch (param->type)
+ 		{
+ 			case ParamTypeNull:
+ 			case ParamTypeString:
+ 				typeid = TEXTOID;
+ 				break;
+ 			case ParamTypeBoolean:
+ 				typeid = BOOLOID;
+ 				break;
+ 			case ParamTypeArray:
+ 			case ParamTypeObject:
+ 				typeid = JSONOID;
+ 				break;
+ 			default:
+ 				elog(ERROR, "unable to determine type id");
+ 				typeid = InvalidOid;
+ 		}
+ 
+ 		TupleDescInitEntry(tupdesc, i, param->name, typeid, -1, 0);
+ 
+ 		nulls[i - 1] = false;
+ 		switch (param->type)
+ 		{
+ 			case ParamTypeNull:
+ 				nulls[i - 1] = true;
+ 				break;
+ 			case ParamTypeBoolean:
+ 				values[i - 1] = BoolGetDatum(param->bool_value);
+ 				break;
+ 			case ParamTypeString:
+ 				values[i - 1] = CStringGetTextDatum(param->str_value);
+ 				break;
+ 			case ParamTypeArray:
+ 				{
+ 					ArrayType  *arrayt;
+ 					Datum	   *arrvals;
+ 					Datum		jsonary;
+ 					ListCell   *cell;
+ 					int			length = list_length(param->array_value);
+ 					int			j;
+ 
+ 					/*
+ 					 * Arrays are stored as Lists up to this point, with each
+ 					 * element being a deparseParam; we need to construct an
+ 					 * ArrayType with them to turn the whole thing into a JSON
+ 					 * array.
+ 					 */
+ 					j = 0;
+ 					arrvals = palloc(sizeof(Datum) * length);
+ 					foreach(cell, param->array_value)
+ 					{
+ 						deparseParams *json = lfirst(cell);
+ 
+ 						arrvals[j++] =
+ 							CStringGetTextDatum(finalize_params(json));
+ 					}
+ 					arrayt = construct_array(arrvals, length,
+ 											 JSONOID, -1, false, 'i');
+ 
+ 					jsonary = DirectFunctionCall1(array_to_json,
+ 												  (PointerGetDatum(arrayt)));
+ 
+ 					values[i - 1] = jsonary;
+ 				}
+ 				break;
+ 			case ParamTypeObject:
+ 				values[i - 1] =
+ 					CStringGetTextDatum(finalize_params(param->obj_value));
+ 				break;
+ 		}
+ 
+ 		i++;
+ 	}
+ 
+ 	BlessTupleDesc(tupdesc);
+ 	htup = heap_form_tuple(tupdesc, values, nulls);
+ 	json = DirectFunctionCall1(row_to_json, HeapTupleGetDatum(htup));
+ 
+ 	/* switch to caller's context so that our output is allocated there */
+ 	MemoryContextSwitchTo(oldcxt);
+ 
+ 	jsonstr = TextDatumGetCString(json);
+ 
+ 	return jsonstr;
+ }
+ 
+ /*
+  * A helper routine to be used to setup %{}T elements.
+  */
+ static deparseParams *
+ setup_params_for_type(deparseParams *parent, Oid typeId, int32 typmod)
+ {
+ 	deparseParams *typeParam = setup_params(parent);
+ 	bool	is_system;
+ 	char   *typnsp;
+ 	char   *typename;
+ 	char   *typmodstr;
+ 	bool	is_array;
+ 
+ 	format_type_detailed(typeId, typmod,
+ 						 &is_system, &typnsp, &typename, &typmodstr, &is_array);
+ 
+ 	append_boolean_param(typeParam, "is_array", is_array);
+ 	append_boolean_param(typeParam, "is_system", is_system);
+ 
+ 	append_string_param(typeParam, "typename", typename);
+ 	if (!is_system)
+ 		append_string_param(typeParam, "schema", typnsp);
+ 	append_string_param(typeParam, "typmod", typmodstr);
+ 
+ 	return typeParam;
+ }
+ 
+ /*
+  * A helper routine to be used to setup %{}D elements.
+  */
+ static deparseParams *
+ setup_params_for_qualname(deparseParams *parent, Oid nspid, char *name)
+ {
+ 	deparseParams *qualified = setup_params(parent);
+ 	char   *namespace;
+ 
+ 	namespace = get_namespace_name(nspid);
+ 	append_string_param(qualified, "schema", namespace);
+ 	append_string_param(qualified, "relation", name);
+ 
+ 	pfree(namespace);
+ 
+ 	return qualified;
+ }
+ 
+ /*
+  * Given a raw expression used for a DEFAULT or a CHECK constraint, turn it
+  * back into source code.
+  *
+  * Note we don't apply sanity checks such as on the return type of the
+  * expression; since the expression was already run through the regular
+  * code paths, we assume it's correct.
+  */
+ static char *
+ uncookConstraintOrDefault(Node *raw_expr, ParseExprKind kind,
+ 						  RangeVar *relation, Oid relOid)
+ {
+ 	Node    *expr;
+ 	char	*src;
+ 	List	*dpcontext = NULL;
+ 	ParseState *pstate;
+ 	MemoryContext cxt;
+ 	MemoryContext oldcxt;
+ 
+ 	cxt = AllocSetContextCreate(CurrentMemoryContext,
+ 								"uncook context",
+ 								ALLOCSET_SMALL_MINSIZE,
+ 								ALLOCSET_SMALL_INITSIZE,
+ 								ALLOCSET_SMALL_MAXSIZE);
+ 	oldcxt = MemoryContextSwitchTo(cxt);
+ 
+ 	pstate = make_parsestate(NULL);
+ 	if (relation)
+ 	{
+ 		RangeTblEntry *rte;
+ 
+ 		rte = addRangeTableEntry(pstate, relation, NULL, false, true);
+ 		addRTEtoQuery(pstate, rte, true, true, true);
+ 		dpcontext = deparse_context_for(relation->relname, relOid);
+ 	}
+ 
+ 	/*
+ 	 * Transform raw parsetree to executable expression, and apply collations
+ 	 * as necessary.
+ 	 */
+ 	expr = transformExpr(pstate, raw_expr, kind);
+ 	assign_expr_collations(pstate, expr);
+ 
+ 	/*
+ 	 * Finally, produce the requested expression, making sure it's allocated
+ 	 * in the destination memory context.
+ 	 */
+ 	MemoryContextSwitchTo(oldcxt);
+ 	src = deparse_expression(expr, dpcontext, false, false);
+ 
+ 	/* and free resources */
+ 	free_parsestate(pstate);
+ 	MemoryContextDelete(cxt);
+ 
+ 	return src;
+ }
+ 
+ /*
+  * deparseColumnConstraint
+  * 		deparse a T_Constraint node as it appears in a column definition
+  */
+ static deparseParams *
+ deparseColumnConstraint(deparseParams *parent, RangeVar *rangevar, Oid relOid,
+ 						Constraint *node)
+ {
+ 	deparseParams *constraint;
+ 
+ 	constraint = setup_params(parent);
+ 	switch (node->contype)
+ 	{
+ 		case CONSTR_NOTNULL:
+ 			append_string_param(constraint, "fmt",
+ 								"%{name} NOT NULL");
+ 			break;
+ 
+ 		case CONSTR_NULL:
+ 			/* ..?? */
+ 			break;
+ 
+ 		case CONSTR_UNIQUE:
+ 			append_string_param(constraint, "fmt",
+ 								"UNIQUE");
+ 			/* _rwOptConsTableSpace(buf, c->indexspace); */
+ 			break;
+ 
+ 		case CONSTR_PRIMARY:
+ 			append_string_param(constraint, "fmt",
+ 								"%{name} PRIMARY KEY (%{columns}s)");
+ 			break;
+ 
+ 		case CONSTR_CHECK:
+ 			{
+ 				char *src;
+ 
+ 				src = uncookConstraintOrDefault(node->raw_expr,
+ 												EXPR_KIND_CHECK_CONSTRAINT,
+ 												rangevar,
+ 												relOid);
+ 				append_string_param(constraint, "fmt",
+ 									"CHECK (%{constraint})");
+ 				append_string_param(constraint, "constraint",
+ 									src);
+ 				pfree(src);
+ 			}
+ 			break;
+ 
+ 		case CONSTR_DEFAULT:
+ 			{
+ 				char	*src = NULL;
+ 
+ 				if (node->cooked_expr)
+ 				{
+ 					List   *dpcontext;
+ 					Node   *expr = (Node *) stringToNode(node->cooked_expr);
+ 
+ 					dpcontext = deparse_context_for(rangevar->relname,
+ 													relOid);
+ 					src = deparse_expression(expr, dpcontext, false, false);
+ 				}
+ 				else if (node->raw_expr)
+ 				{
+ 					/* deparse the default expression */
+ 					src = uncookConstraintOrDefault(node->raw_expr,
+ 													EXPR_KIND_COLUMN_DEFAULT,
+ 													rangevar, relOid);
+ 				}
+ 
+ 				append_string_param(constraint, "fmt",
+ 									"DEFAULT %{default}");
+ 				append_string_param(constraint, "default", src);
+ 			}
+ 
+ 			break;
+ 
+ 		case CONSTR_FOREIGN:
+ 			break;
+ 
+ 		default:
+ 			/* unexpected */
+ 			elog(WARNING, "constraint %d is not a column constraint",
+ 				 node->contype);
+ 			break;
+ 	}
+ 
+ 	return constraint;
+ }
+ 
+ /*
+  * deparse a ColumnDef node
+  *
+  * This routine doesn't process the constraint nodes in the coldef; caller must
+  * see to it.  (Constraints represented intrinsically in the ColDef node
+  * itself, such as NOT NULL, are emitted here).
+  */
+ static deparseParams *
+ deparse_ColumnDef(deparseParams *parent, Oid relid, ColumnDef *coldef)
+ {
+ 	deparseParams *column;
+ 	deparseParams *collation;
+ 	HeapTuple	attrTup;
+ 	Form_pg_attribute	attrForm;
+ 	Oid			typid;
+ 	int32		typmod;
+ 	Oid			typcollation;
+ 
+ 	/*
+ 	 * Inherited columns without local definitions, and columns coming from OF
+ 	 * TYPE clauses, must not be emitted.  XXX -- maybe it is useful to have
+ 	 * them with "present = false" or such?
+ 	 */
+ 	if (!coldef->is_local || coldef->is_from_type)
+ 		return NULL;
+ 
+ 	attrTup = SearchSysCacheAttName(relid, coldef->colname);
+ 	if (!HeapTupleIsValid(attrTup))
+ 		elog(ERROR, "could not find cache entry for column \"%s\" of relation %u",
+ 			 coldef->colname, relid);
+ 	attrForm = (Form_pg_attribute) GETSTRUCT(attrTup);
+ 
+ 	column = setup_params(parent);
+ 
+ 	get_atttypetypmodcoll(relid, attrForm->attnum,
+ 						  &typid, &typmod, &typcollation);
+ 
+ 	append_string_param(column, "fmt",
+ 						"%{name}I %{type}T %{collation}s");
+ 	append_string_param(column, "name", coldef->colname);
+ 
+ 	append_object_param(column, "type",
+ 						setup_params_for_type(column, typid, typmod));
+ 
+ 	collation = setup_params(parent);
+ 	append_string_param(collation, "fmt", "COLLATE %{name}I");
+ 	if (OidIsValid(typcollation))
+ 	{
+ 		char	*collname;
+ 
+ 		collname = get_collation_name(attrForm->attcollation);
+ 		append_string_param(collation, "name", collname);
+ 		pfree(collname);
+ 	}
+ 	else
+ 		append_boolean_param(collation, "present", false);
+ 	append_object_param(column, "collation", collation);
+ 
+ 	ReleaseSysCache(attrTup);
+ 
+ 	return column;
+ }
+ 
+ /*
+  * Subroutine for deparse_CreateStmt: deal with column elements
+  */
+ static List *
+ deparseTableElements(List *elements, deparseParams *parent,
+ 					 RangeVar *rangevar,
+ 					 Oid relOid, List *tableElements)
+ {
+ 	ListCell   *lc;
+ 
+ 	foreach(lc, tableElements)
+ 	{
+ 		Node   *elt = (Node *) lfirst(lc);
+ 
+ 		switch (nodeTag(elt))
+ 		{
+ 			case T_ColumnDef:
+ 				{
+ 					ColumnDef  *colDef = (ColumnDef *) elt;
+ 					ListCell   *lc;
+ 					deparseParams *column;
+ 
+ 					column = deparse_ColumnDef(parent, relOid, colDef);
+ 
+ 					if (column != NULL)
+ 						elements = lappend(elements, column);
+ 
+ 					/*
+ 					 * A ColumnDef might contain constraints internally;
+ 					 * process them, too.
+ 					 */
+ 					foreach(lc, colDef->constraints)
+ 					{
+ 						Constraint	*constr = lfirst(lc);
+ 						deparseParams *constraint;
+ 
+ 						constraint =
+ 							deparseColumnConstraint(parent, rangevar,
+ 													relOid,
+ 													(Constraint *) constr);
+ 						if (constraint)
+ 							elements = lappend(elements, constraint);
+ 					}
+ 				}
+ 				break;
+ 			case T_Constraint:
+ 				break;
+ 			default:
+ 				elog(ERROR, "invalid node type %d", nodeTag(elt));
+ 		}
+ 	}
+ 
+ 	return elements;
+ }
+ 
+ static void
+ append_persistence_param(deparseParams *params, char *name, char persistence)
+ {
+ 	switch (persistence)
+ 	{
+ 		case RELPERSISTENCE_TEMP:
+ 			append_string_param(params, name, "TEMPORARY");
+ 			break;
+ 		case RELPERSISTENCE_UNLOGGED:
+ 			append_string_param(params, name, "UNLOGGED");
+ 			break;
+ 		case RELPERSISTENCE_PERMANENT:
+ 			append_string_param(params, name, "");
+ 			break;
+ 	}
+ }
+ 
+ /*
+  * deparse_CreateStmt
+  * 		Process CREATE TABLE statements
+  */
+ static void
+ deparse_CreateStmt(Oid objectId, Node *parsetree, char **command)
+ {
+ 	CreateStmt *node = (CreateStmt *) parsetree;
+ 	Relation	relation = relation_open(objectId, AccessShareLock);
+ 	RangeVar   *rangevar;
+ 	deparseParams *createStmt;
+ 	deparseParams *tmp;
+ 
+ 	rangevar = makeRangeVar(get_namespace_name(relation->rd_rel->relnamespace),
+ 							RelationGetRelationName(relation),
+ 							-1);
+ 
+ 	createStmt = setup_params(NULL);
+ 	append_string_param(createStmt, "fmt",
+ 						"CREATE %{persistence}s TABLE %{identity}D "
+ 						"%{if_not_exists}s "
+ 						"%{of_type}s (%{table_elements:, }s) "
+ 						"%{inherits}s %{on_commit}s %{tablespace}s");
+ 
+ 	/*
+ 	 * missing: WITH, LIKE, table elements in the typed table case
+ 	 */
+ 
+ 	append_persistence_param(createStmt,
+ 							 "persistence",
+ 							 relation->rd_rel->relpersistence);
+ 
+ 	tmp = setup_params_for_qualname(createStmt,
+ 									relation->rd_rel->relnamespace,
+ 									RelationGetRelationName(relation));
+ 	append_object_param(createStmt, "identity", tmp);
+ 
+ 	append_string_param(createStmt, "if_not_exists",
+ 						node->if_not_exists ? "IF NOT EXISTS" : "");
+ 
+ 	tmp = setup_params(createStmt);
+ 	append_string_param(tmp, "fmt", "OF %{of_type}T");
+ 	if (node->ofTypename)
+ 	{
+ 		deparseParams *of_type_type;
+ 
+ 		append_boolean_param(tmp, "present", true);
+ 		of_type_type = setup_params_for_type(createStmt,
+ 											 relation->rd_rel->reloftype,
+ 											 -1);
+ 		append_object_param(tmp, "of_type", of_type_type);
+ 
+ 		/*
+ 		 * XXX typed tables can have "table elements" which need to be
+ 		 * processed here
+ 		 */
+ 	}
+ 	else
+ 	{
+ 		append_null_param(tmp, "of_type");
+ 		append_boolean_param(tmp, "present", false);
+ 	}
+ 	append_object_param(createStmt, "of_type", tmp);
+ 
+ 	append_array_param(createStmt, "table_elements",
+ 					   deparseTableElements(NIL,
+ 											createStmt,
+ 											rangevar,
+ 											objectId,
+ 											node->tableElts));
+ 
+ 	/*
+ 	 * Add inheritance specification.  We cannot simply scan the list of
+ 	 * parents from the parser node, because that may lack the actual qualified
+ 	 * names of the parent relations.  Rather than trying to re-resolve them from
+ 	 * the information in the parse node, it seems more accurate and convenient
+ 	 * to grab it from pg_inherits.
+ 	 */
+ 	tmp = setup_params(createStmt);
+ 	append_string_param(tmp, "fmt", "INHERITS (%{parents:, }D)");
+ 	if (list_length(node->inhRelations) > 0)
+ 	{
+ 		List	   *parents = NIL;
+ 		Relation	catalogRelation;
+ 		SysScanDesc scan;
+ 		ScanKeyData key;
+ 		HeapTuple	tuple;
+ 
+ 		catalogRelation = heap_open(InheritsRelationId, RowExclusiveLock);
+ 
+ 		ScanKeyInit(&key,
+ 					Anum_pg_inherits_inhrelid,
+ 					BTEqualStrategyNumber, F_OIDEQ,
+ 					ObjectIdGetDatum(objectId));
+ 
+ 		scan = systable_beginscan(catalogRelation, InheritsRelidSeqnoIndexId,
+ 								  true, NULL, 1, &key);
+ 
+ 		while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+ 		{
+ 			deparseParams *parent;
+ 			Form_pg_inherits formInh = (Form_pg_inherits) GETSTRUCT(tuple);
+ 			Relation	prel;
+ 
+ 			prel = heap_open(formInh->inhparent, AccessShareLock);
+ 
+ 			parent = setup_params_for_qualname(createStmt,
+ 											   prel->rd_rel->relnamespace,
+ 											   RelationGetRelationName(prel));
+ 
+ 			heap_close(prel, AccessShareLock);
+ 
+ 			parents = lappend(parents, parent);
+ 		}
+ 
+ 		systable_endscan(scan);
+ 		heap_close(catalogRelation, RowExclusiveLock);
+ 
+ 		append_array_param(tmp, "parents", parents);
+ 		append_boolean_param(tmp, "present", true);
+ 	}
+ 	else
+ 	{
+ 		append_null_param(tmp, "parents");
+ 		append_boolean_param(tmp, "present", false);
+ 	}
+ 	append_object_param(createStmt, "inherits", tmp);
+ 
+ 	tmp = setup_params(createStmt);
+ 	append_string_param(tmp, "fmt", "TABLESPACE %{tablespace}I");
+ 	if (node->tablespacename)
+ 		append_string_param(tmp, "tablespace", node->tablespacename);
+ 	else
+ 	{
+ 		append_null_param(tmp, "tablespace");
+ 		append_boolean_param(tmp, "present", false);
+ 	}
+ 	append_object_param(createStmt, "tablespace", tmp);
+ 
+ 	tmp = setup_params(createStmt);
+ 	append_string_param(tmp, "fmt", "ON COMMIT %{on_commit_value}s");
+ 	switch (node->oncommit)
+ 	{
+ 		case ONCOMMIT_DROP:
+ 			append_string_param(tmp, "on_commit_value", "DROP");
+ 			break;
+ 
+ 		case ONCOMMIT_DELETE_ROWS:
+ 			append_string_param(tmp, "on_commit_value", "DELETE ROWS");
+ 			break;
+ 
+ 		case ONCOMMIT_PRESERVE_ROWS:
+ 			append_string_param(tmp, "on_commit_value", "PRESERVE ROWS");
+ 			break;
+ 
+ 		case ONCOMMIT_NOOP:
+ 			append_null_param(tmp, "on_commit_value");
+ 			append_boolean_param(tmp, "present", false);
+ 			break;
+ 	}
+ 	append_object_param(createStmt, "on_commit", tmp);
+ 
+ 	*command = finalize_params(createStmt);
+ 
+ 	free_params(createStmt);
+ 	relation_close(relation, AccessShareLock);
+ }
+ 
+ /*
+  * rewrite CreateSeqStmt parser production
+  */
+ static void
+ deparse_CreateSeqStmt(Oid objectId, Node *parsetree, char **command)
+ {
+ 	deparseParams *createSeqStmt;
+ 	deparseParams *sequence;
+ 	Relation relation = relation_open(objectId, AccessShareLock);
+ 
+ 	createSeqStmt = setup_params(NULL);
+ 	append_string_param(createSeqStmt, "fmt",
+ 						"CREATE %{persistence}s SEQUENCE %{identity}D");
+ 
+ 	append_persistence_param(createSeqStmt,
+ 							 "persistence",
+ 							 relation->rd_rel->relpersistence);
+ 
+ 	sequence = setup_params_for_qualname(createSeqStmt,
+ 										 relation->rd_rel->relnamespace,
+ 										 RelationGetRelationName(relation));
+ 	append_object_param(createSeqStmt, "sequence", sequence);
+ 
+ 	/* XXX Sequence options need to be processed here */
+ 
+ 	*command = finalize_params(createSeqStmt);
+ 
+ 	free_params(createSeqStmt);
+ 	relation_close(relation, AccessShareLock);
+ }
+ 
+ /*
+  * deparse IndexStmt
+  *		Process CREATE INDEX statements
+  */
+ static void
+ deparse_IndexStmt(Oid objectId, Node *parsetree, char **command)
+ {
+ 	IndexStmt	   *node  = (IndexStmt *) parsetree;
+ 	deparseParams  *indexStmt;
+ 	deparseParams  *table;
+ 	Relation		idxrel;
+ 	Relation		heaprel;
+ 
+ 	if (node->primary || node->isconstraint)
+ 	{
+ 		/*
+ 		 * indexes for PRIMARY KEY or other constraints are output separately;
+ 		 * return empty here.
+ 		 */
+ 		*command = NULL;
+ 		return;
+ 	}
+ 
+ 	idxrel = relation_open(objectId, AccessShareLock);
+ 	heaprel = relation_open(idxrel->rd_index->indrelid, AccessShareLock);
+ 
+ 	indexStmt = setup_params(NULL);
+ 	append_string_param(indexStmt, "fmt",
+ 						"CREATE %{unique}s INDEX %{concurrently}s %{name}I "
+ 						"ON %{table}D");
+ 
+ 	append_string_param(indexStmt, "unique",
+ 						node->unique ? "UNIQUE" : "");
+ 
+ 	append_string_param(indexStmt, "concurrently",
+ 						node->concurrent ?  "CONCURRENTLY" : "");
+ 
+ 	append_string_param(indexStmt, "name", RelationGetRelationName(idxrel));
+ 
+ 	table = setup_params_for_qualname(indexStmt,
+ 									  heaprel->rd_rel->relnamespace,
+ 									  RelationGetRelationName(heaprel));
+ 	append_object_param(indexStmt, "table", table);
+ 
+ 	*command = finalize_params(indexStmt);
+ 	free_params(indexStmt);
+ 
+ 	heap_close(idxrel, AccessShareLock);
+ 	heap_close(heaprel, AccessShareLock);
+ }
+ 
+ /*
+  * deparse CREATE SCHEMA
+  *
+  * We don't process the schema elements here, because CreateSchemaCommand
+  * passes them back to ProcessUtility; they get output separately.
+  */
+ static void
+ deparse_CreateSchemaStmt(Oid objectId, Node *parsetree, char **command)
+ {
+ 	CreateSchemaStmt	*node  = (CreateSchemaStmt *) parsetree;
+ 	deparseParams  *createSchema;
+ 	deparseParams  *auth;
+ 
+ 	createSchema = setup_params(NULL);
+ 	append_string_param(createSchema, "fmt",
+ 						"CREATE SCHEMA %{if_not_exists}s %{name}I "
+ 						"%{authorization}s");
+ 
+ 	append_string_param(createSchema, "name", node->schemaname);
+ 	append_string_param(createSchema, "if_not_exists",
+ 						node->if_not_exists ? "IF NOT EXISTS" : "");
+ 
+ 	auth = setup_params(createSchema);
+ 	append_string_param(auth, "fmt", "AUTHORIZATION %{authorization_role}I");
+ 	if (node->authid)
+ 	{
+ 		append_string_param(auth, "authorization_role", node->authid);
+ 		append_boolean_param(auth, "present", true);
+ 	}
+ 	else
+ 	{
+ 		append_null_param(auth, "authorization_role");
+ 		append_boolean_param(auth, "present", false);
+ 	}
+ 	append_object_param(createSchema, "authorization", auth);
+ 
+ 	*command = finalize_params(createSchema);
+ 
+ 	free_params(createSchema);
+ }
+ 
+ /*
+  * Given a utility command parsetree and the OID of the corresponding object,
+  * return a JSON representation of the command.
+  *
+  * The command is expanded fully, so that there are no ambiguities even in the
+  * face of search_path changes.
+  *
+  * Note we currently only support commands for which ProcessUtilitySlow saves
+  * objects to create; currently this excludes all forms of ALTER and DROP.
+  */
+ void
+ deparse_utility_command(Oid objectId, Node *parsetree, char **command)
+ {
+ 	switch (nodeTag(parsetree))
+ 	{
+ 		case T_CreateSchemaStmt:
+ 			deparse_CreateSchemaStmt(objectId, parsetree, command);
+ 			break;
+ 
+ 		case T_CreateStmt:
+ 			deparse_CreateStmt(objectId, parsetree, command);
+ 
+ 		case T_CreateForeignTableStmt:
+ 			break;
+ 
+ 		case T_DefineStmt:
+ 			break;
+ 
+ 		case T_IndexStmt:
+ 			deparse_IndexStmt(objectId, parsetree, command);
+ 			break;
+ 
+ 		case T_CreateExtensionStmt:
+ 			break;
+ 
+ 		case T_CreateFdwStmt:
+ 			break;
+ 
+ 		case T_CreateForeignServerStmt:
+ 			break;
+ 
+ 		case T_CreateUserMappingStmt:
+ 			break;
+ 
+ 		case T_CompositeTypeStmt:	/* CREATE TYPE (composite) */
+ 		case T_CreateEnumStmt:		/* CREATE TYPE AS ENUM */
+ 		case T_CreateRangeStmt:		/* CREATE TYPE AS RANGE */
+ 			break;
+ 
+ 		case T_ViewStmt:
+ 			break;
+ 
+ 		case T_CreateFunctionStmt:
+ 			break;
+ 
+ 		case T_RuleStmt:
+ 			break;
+ 
+ 		case T_CreateSeqStmt:
+ 			deparse_CreateSeqStmt(objectId, parsetree, command);
+ 			break;
+ 
+ 		case T_CreateTableAsStmt:
+ 			break;
+ 
+ 		case T_RefreshMatViewStmt:
+ 			break;
+ 
+ 		case T_CreateTrigStmt:
+ 			break;
+ 
+ 		case T_CreatePLangStmt:
+ 			break;
+ 
+ 		case T_CreateDomainStmt:
+ 			break;
+ 
+ 		case T_CreateConversionStmt:
+ 			break;
+ 
+ 		case T_CreateCastStmt:
+ 			break;
+ 
+ 		case T_CreateOpClassStmt:
+ 			break;
+ 
+ 		case T_CreateOpFamilyStmt:
+ 			break;
+ 
+ 		default:
+ 			elog(LOG, "unrecognized node type: %d",
+ 				 (int) nodeTag(parsetree));
+ 	}
+ 
+ 	return;
+ }
*** a/src/backend/tcop/utility.c
--- b/src/backend/tcop/utility.c
***************
*** 898,903 **** ProcessUtilitySlow(Node *parsetree,
--- 898,904 ----
  	bool		isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL);
  	bool		isCompleteQuery = (context <= PROCESS_UTILITY_QUERY);
  	bool		needCleanup;
+ 	Oid			objectId;
  
  	/* All event trigger calls are done only when isCompleteQuery is true */
  	needCleanup = isCompleteQuery && EventTriggerBeginCompleteQuery();
***************
*** 916,921 **** ProcessUtilitySlow(Node *parsetree,
--- 917,926 ----
  			case T_CreateSchemaStmt:
  				CreateSchemaCommand((CreateSchemaStmt *) parsetree,
  									queryString);
+ 				/*
+ 				 * CreateSchemaCommand calls EventTriggerStashCreatedObject
+ 				 * internally, for reasons explained there.
+ 				 */
  				break;
  
  			case T_CreateStmt:
***************
*** 923,929 **** ProcessUtilitySlow(Node *parsetree,
  				{
  					List	   *stmts;
  					ListCell   *l;
- 					Oid			relOid;
  
  					/* Run parse analysis ... */
  					stmts = transformCreateStmt((CreateStmt *) parsetree,
--- 928,933 ----
***************
*** 940,948 **** ProcessUtilitySlow(Node *parsetree,
  							static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
  
  							/* Create the table itself */
! 							relOid = DefineRelation((CreateStmt *) stmt,
! 													RELKIND_RELATION,
! 													InvalidOid);
  
  							/*
  							 * Let AlterTableCreateToastTable decide if this
--- 944,955 ----
  							static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
  
  							/* Create the table itself */
! 							objectId = DefineRelation((CreateStmt *) stmt,
! 													  RELKIND_RELATION,
! 													  InvalidOid);
! 							EventTriggerStashCreatedObject(objectId,
! 														   OCLASS_CLASS,
! 														   stmt);
  
  							/*
  							 * Let AlterTableCreateToastTable decide if this
***************
*** 964,983 **** ProcessUtilitySlow(Node *parsetree,
  												   toast_options,
  												   true);
  
! 							AlterTableCreateToastTable(relOid, toast_options);
  						}
  						else if (IsA(stmt, CreateForeignTableStmt))
  						{
  							/* Create the table itself */
! 							relOid = DefineRelation((CreateStmt *) stmt,
! 													RELKIND_FOREIGN_TABLE,
! 													InvalidOid);
  							CreateForeignTable((CreateForeignTableStmt *) stmt,
! 											   relOid);
  						}
  						else
  						{
! 							/* Recurse for anything else */
  							ProcessUtility(stmt,
  										   queryString,
  										   PROCESS_UTILITY_SUBCOMMAND,
--- 971,997 ----
  												   toast_options,
  												   true);
  
! 							AlterTableCreateToastTable(objectId, toast_options);
  						}
  						else if (IsA(stmt, CreateForeignTableStmt))
  						{
  							/* Create the table itself */
! 							objectId = DefineRelation((CreateStmt *) stmt,
! 													  RELKIND_FOREIGN_TABLE,
! 													  InvalidOid);
  							CreateForeignTable((CreateForeignTableStmt *) stmt,
! 											   objectId);
! 							EventTriggerStashCreatedObject(objectId,
! 														   OCLASS_CLASS,
! 														   stmt);
  						}
  						else
  						{
! 							/*
! 							 * Recurse for anything else.  Note the recursive
! 							 * call will stash the objects so created into our
! 							 * event trigger context.
! 							 */
  							ProcessUtility(stmt,
  										   queryString,
  										   PROCESS_UTILITY_SUBCOMMAND,
***************
*** 1104,1153 **** ProcessUtilitySlow(Node *parsetree,
  			case T_DefineStmt:
  				{
  					DefineStmt *stmt = (DefineStmt *) parsetree;
  
  					switch (stmt->kind)
  					{
  						case OBJECT_AGGREGATE:
! 							DefineAggregate(stmt->defnames, stmt->args,
! 											stmt->oldstyle, stmt->definition,
! 											queryString);
  							break;
  						case OBJECT_OPERATOR:
  							Assert(stmt->args == NIL);
! 							DefineOperator(stmt->defnames, stmt->definition);
  							break;
  						case OBJECT_TYPE:
  							Assert(stmt->args == NIL);
! 							DefineType(stmt->defnames, stmt->definition);
  							break;
  						case OBJECT_TSPARSER:
  							Assert(stmt->args == NIL);
! 							DefineTSParser(stmt->defnames, stmt->definition);
  							break;
  						case OBJECT_TSDICTIONARY:
  							Assert(stmt->args == NIL);
! 							DefineTSDictionary(stmt->defnames,
! 											   stmt->definition);
  							break;
  						case OBJECT_TSTEMPLATE:
  							Assert(stmt->args == NIL);
! 							DefineTSTemplate(stmt->defnames,
! 											 stmt->definition);
  							break;
  						case OBJECT_TSCONFIGURATION:
  							Assert(stmt->args == NIL);
! 							DefineTSConfiguration(stmt->defnames,
! 												  stmt->definition);
  							break;
  						case OBJECT_COLLATION:
  							Assert(stmt->args == NIL);
! 							DefineCollation(stmt->defnames, stmt->definition);
  							break;
  						default:
  							elog(ERROR, "unrecognized define stmt type: %d",
  								 (int) stmt->kind);
  							break;
  					}
  				}
  				break;
  
--- 1118,1183 ----
  			case T_DefineStmt:
  				{
  					DefineStmt *stmt = (DefineStmt *) parsetree;
+ 					ObjectClass	class;
  
  					switch (stmt->kind)
  					{
  						case OBJECT_AGGREGATE:
! 							objectId =
! 								DefineAggregate(stmt->defnames, stmt->args,
! 												stmt->oldstyle,
! 												stmt->definition, queryString);
! 							class = OCLASS_PROC;
  							break;
  						case OBJECT_OPERATOR:
  							Assert(stmt->args == NIL);
! 							objectId = DefineOperator(stmt->defnames,
! 													  stmt->definition);
! 							class = OCLASS_OPERATOR;
  							break;
  						case OBJECT_TYPE:
  							Assert(stmt->args == NIL);
! 							objectId = DefineType(stmt->defnames,
! 												  stmt->definition);
! 							class = OCLASS_TYPE;
  							break;
  						case OBJECT_TSPARSER:
  							Assert(stmt->args == NIL);
! 							objectId = DefineTSParser(stmt->defnames,
! 													  stmt->definition);
! 							class = OCLASS_TSPARSER;
  							break;
  						case OBJECT_TSDICTIONARY:
  							Assert(stmt->args == NIL);
! 							objectId = DefineTSDictionary(stmt->defnames,
! 														  stmt->definition);
! 							class = OCLASS_TSDICT;
  							break;
  						case OBJECT_TSTEMPLATE:
  							Assert(stmt->args == NIL);
! 							objectId = DefineTSTemplate(stmt->defnames,
! 														stmt->definition);
! 							class = OCLASS_TSTEMPLATE;
  							break;
  						case OBJECT_TSCONFIGURATION:
  							Assert(stmt->args == NIL);
! 							objectId = DefineTSConfiguration(stmt->defnames,
! 															 stmt->definition);
! 							class = OCLASS_TSCONFIG;
  							break;
  						case OBJECT_COLLATION:
  							Assert(stmt->args == NIL);
! 							objectId = DefineCollation(stmt->defnames,
! 													   stmt->definition);
! 							class = OCLASS_COLLATION;
  							break;
  						default:
  							elog(ERROR, "unrecognized define stmt type: %d",
  								 (int) stmt->kind);
  							break;
  					}
+ 
+ 					EventTriggerStashCreatedObject(objectId, class, parsetree);
  				}
  				break;
  
***************
*** 1165,1181 **** ProcessUtilitySlow(Node *parsetree,
  					stmt = transformIndexStmt(stmt, queryString);
  
  					/* ... and do it */
! 					DefineIndex(stmt,
! 								InvalidOid,		/* no predefined OID */
! 								false,	/* is_alter_table */
! 								true,	/* check_rights */
! 								false,	/* skip_build */
! 								false); /* quiet */
  				}
  				break;
  
  			case T_CreateExtensionStmt:
! 				CreateExtension((CreateExtensionStmt *) parsetree);
  				break;
  
  			case T_AlterExtensionStmt:
--- 1195,1214 ----
  					stmt = transformIndexStmt(stmt, queryString);
  
  					/* ... and do it */
! 					objectId = DefineIndex(stmt,
! 										   InvalidOid,		/* no predefined OID */
! 										   false,	/* is_alter_table */
! 										   true,	/* check_rights */
! 										   false,	/* skip_build */
! 										   false); /* quiet */
! 					EventTriggerStashCreatedObject(objectId, OCLASS_CLASS,
! 												   parsetree);
  				}
  				break;
  
  			case T_CreateExtensionStmt:
! 				objectId = CreateExtension((CreateExtensionStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_EXTENSION, parsetree);
  				break;
  
  			case T_AlterExtensionStmt:
***************
*** 1187,1193 **** ProcessUtilitySlow(Node *parsetree,
  				break;
  
  			case T_CreateFdwStmt:
! 				CreateForeignDataWrapper((CreateFdwStmt *) parsetree);
  				break;
  
  			case T_AlterFdwStmt:
--- 1220,1227 ----
  				break;
  
  			case T_CreateFdwStmt:
! 				objectId = CreateForeignDataWrapper((CreateFdwStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_FDW, parsetree);
  				break;
  
  			case T_AlterFdwStmt:
***************
*** 1195,1201 **** ProcessUtilitySlow(Node *parsetree,
  				break;
  
  			case T_CreateForeignServerStmt:
! 				CreateForeignServer((CreateForeignServerStmt *) parsetree);
  				break;
  
  			case T_AlterForeignServerStmt:
--- 1229,1237 ----
  				break;
  
  			case T_CreateForeignServerStmt:
! 				objectId = CreateForeignServer((CreateForeignServerStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_FOREIGN_SERVER,
! 										parsetree);
  				break;
  
  			case T_AlterForeignServerStmt:
***************
*** 1203,1209 **** ProcessUtilitySlow(Node *parsetree,
  				break;
  
  			case T_CreateUserMappingStmt:
! 				CreateUserMapping((CreateUserMappingStmt *) parsetree);
  				break;
  
  			case T_AlterUserMappingStmt:
--- 1239,1247 ----
  				break;
  
  			case T_CreateUserMappingStmt:
! 				objectId = CreateUserMapping((CreateUserMappingStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_USER_MAPPING,
! 										parsetree);
  				break;
  
  			case T_AlterUserMappingStmt:
***************
*** 1218,1233 **** ProcessUtilitySlow(Node *parsetree,
  				{
  					CompositeTypeStmt *stmt = (CompositeTypeStmt *) parsetree;
  
! 					DefineCompositeType(stmt->typevar, stmt->coldeflist);
  				}
  				break;
  
  			case T_CreateEnumStmt:		/* CREATE TYPE AS ENUM */
! 				DefineEnum((CreateEnumStmt *) parsetree);
  				break;
  
  			case T_CreateRangeStmt:		/* CREATE TYPE AS RANGE */
! 				DefineRange((CreateRangeStmt *) parsetree);
  				break;
  
  			case T_AlterEnumStmt:		/* ALTER TYPE (enum) */
--- 1256,1274 ----
  				{
  					CompositeTypeStmt *stmt = (CompositeTypeStmt *) parsetree;
  
! 					objectId = DefineCompositeType(stmt->typevar, stmt->coldeflist);
! 					EventTriggerStashCreatedObject(objectId, OCLASS_TYPE, parsetree);
  				}
  				break;
  
  			case T_CreateEnumStmt:		/* CREATE TYPE AS ENUM */
! 				objectId = DefineEnum((CreateEnumStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_TYPE, parsetree);
  				break;
  
  			case T_CreateRangeStmt:		/* CREATE TYPE AS RANGE */
! 				objectId = DefineRange((CreateRangeStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_TYPE, parsetree);
  				break;
  
  			case T_AlterEnumStmt:		/* ALTER TYPE (enum) */
***************
*** 1235,1257 **** ProcessUtilitySlow(Node *parsetree,
  				break;
  
  			case T_ViewStmt:	/* CREATE VIEW */
! 				DefineView((ViewStmt *) parsetree, queryString);
  				break;
  
  			case T_CreateFunctionStmt:	/* CREATE FUNCTION */
! 				CreateFunction((CreateFunctionStmt *) parsetree, queryString);
  				break;
  
  			case T_AlterFunctionStmt:	/* ALTER FUNCTION */
! 				AlterFunction((AlterFunctionStmt *) parsetree);
  				break;
  
  			case T_RuleStmt:	/* CREATE RULE */
! 				DefineRule((RuleStmt *) parsetree, queryString);
  				break;
  
  			case T_CreateSeqStmt:
! 				DefineSequence((CreateSeqStmt *) parsetree);
  				break;
  
  			case T_AlterSeqStmt:
--- 1276,1302 ----
  				break;
  
  			case T_ViewStmt:	/* CREATE VIEW */
! 				objectId = DefineView((ViewStmt *) parsetree, queryString);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_CLASS, parsetree);
  				break;
  
  			case T_CreateFunctionStmt:	/* CREATE FUNCTION */
! 				objectId = CreateFunction((CreateFunctionStmt *) parsetree, queryString);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_PROC, parsetree);
  				break;
  
  			case T_AlterFunctionStmt:	/* ALTER FUNCTION */
! 				objectId = AlterFunction((AlterFunctionStmt *) parsetree);
  				break;
  
  			case T_RuleStmt:	/* CREATE RULE */
! 				objectId = DefineRule((RuleStmt *) parsetree, queryString);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_REWRITE, parsetree);
  				break;
  
  			case T_CreateSeqStmt:
! 				objectId = DefineSequence((CreateSeqStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_CLASS, parsetree);
  				break;
  
  			case T_AlterSeqStmt:
***************
*** 1259,1300 **** ProcessUtilitySlow(Node *parsetree,
  				break;
  
  			case T_CreateTableAsStmt:
! 				ExecCreateTableAs((CreateTableAsStmt *) parsetree,
  								  queryString, params, completionTag);
  				break;
  
  			case T_RefreshMatViewStmt:
! 				ExecRefreshMatView((RefreshMatViewStmt *) parsetree,
  								   queryString, params, completionTag);
  				break;
  
  			case T_CreateTrigStmt:
! 				(void) CreateTrigger((CreateTrigStmt *) parsetree, queryString,
  									 InvalidOid, InvalidOid, false);
  				break;
  
  			case T_CreatePLangStmt:
! 				CreateProceduralLanguage((CreatePLangStmt *) parsetree);
  				break;
  
  			case T_CreateDomainStmt:
! 				DefineDomain((CreateDomainStmt *) parsetree);
  				break;
  
  			case T_CreateConversionStmt:
! 				CreateConversionCommand((CreateConversionStmt *) parsetree);
  				break;
  
  			case T_CreateCastStmt:
! 				CreateCast((CreateCastStmt *) parsetree);
  				break;
  
  			case T_CreateOpClassStmt:
! 				DefineOpClass((CreateOpClassStmt *) parsetree);
  				break;
  
  			case T_CreateOpFamilyStmt:
! 				DefineOpFamily((CreateOpFamilyStmt *) parsetree);
  				break;
  
  			case T_AlterOpFamilyStmt:
--- 1304,1354 ----
  				break;
  
  			case T_CreateTableAsStmt:
! 				objectId = ExecCreateTableAs((CreateTableAsStmt *) parsetree,
  								  queryString, params, completionTag);
+ 				EventTriggerStashCreatedObject(objectId, OCLASS_CLASS, parsetree);
  				break;
  
  			case T_RefreshMatViewStmt:
! 				objectId = ExecRefreshMatView((RefreshMatViewStmt *) parsetree,
  								   queryString, params, completionTag);
+ 				EventTriggerStashCreatedObject(objectId, OCLASS_CLASS, parsetree);
  				break;
  
  			case T_CreateTrigStmt:
! 				objectId = CreateTrigger((CreateTrigStmt *) parsetree, queryString,
  									 InvalidOid, InvalidOid, false);
+ 				EventTriggerStashCreatedObject(objectId, OCLASS_TRIGGER, parsetree);
  				break;
  
  			case T_CreatePLangStmt:
! 				objectId = CreateProceduralLanguage((CreatePLangStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_LANGUAGE, parsetree);
  				break;
  
  			case T_CreateDomainStmt:
! 				objectId = DefineDomain((CreateDomainStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_TYPE, parsetree);
  				break;
  
  			case T_CreateConversionStmt:
! 				objectId = CreateConversionCommand((CreateConversionStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_CONVERSION, parsetree);
  				break;
  
  			case T_CreateCastStmt:
! 				objectId = CreateCast((CreateCastStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_CAST, parsetree);
  				break;
  
  			case T_CreateOpClassStmt:
! 				objectId = DefineOpClass((CreateOpClassStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_OPCLASS, parsetree);
  				break;
  
  			case T_CreateOpFamilyStmt:
! 				objectId = DefineOpFamily((CreateOpFamilyStmt *) parsetree);
! 				EventTriggerStashCreatedObject(objectId, OCLASS_OPFAMILY, parsetree);
  				break;
  
  			case T_AlterOpFamilyStmt:
*** a/src/backend/utils/adt/format_type.c
--- b/src/backend/utils/adt/format_type.c
***************
*** 31,37 ****
  static char *format_type_internal(Oid type_oid, int32 typemod,
  					 bool typemod_given, bool allow_invalid,
  					 bool force_qualify);
! static char *printTypmod(const char *typname, int32 typmod, Oid typmodout);
  
  
  /*
--- 31,38 ----
  static char *format_type_internal(Oid type_oid, int32 typemod,
  					 bool typemod_given, bool allow_invalid,
  					 bool force_qualify);
! static char *printTypmod(const char *typname, int32 typmod, Oid typmodout,
! 						 bool typmodOnly);
  
  
  /*
***************
*** 96,101 **** format_type_be(Oid type_oid)
--- 97,105 ----
  	return format_type_internal(type_oid, -1, false, false, false);
  }
  
+ /*
+  * This version returns a name which is always qualified.
+  */
  char *
  format_type_be_qualified(Oid type_oid)
  {
***************
*** 111,188 **** format_type_with_typemod(Oid type_oid, int32 typemod)
  	return format_type_internal(type_oid, typemod, true, false, false);
  }
  
  static char *
! format_type_internal(Oid type_oid, int32 typemod,
! 					 bool typemod_given, bool allow_invalid,
! 					 bool force_qualify)
  {
! 	bool		with_typemod = typemod_given && (typemod >= 0);
! 	HeapTuple	tuple;
! 	Form_pg_type typeform;
! 	Oid			array_base_type;
! 	bool		is_array;
! 	char	   *buf;
! 
! 	if (type_oid == InvalidOid && allow_invalid)
! 		return pstrdup("-");
! 
! 	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
! 	if (!HeapTupleIsValid(tuple))
! 	{
! 		if (allow_invalid)
! 			return pstrdup("???");
! 		else
! 			elog(ERROR, "cache lookup failed for type %u", type_oid);
! 	}
! 	typeform = (Form_pg_type) GETSTRUCT(tuple);
! 
! 	/*
! 	 * Check if it's a regular (variable length) array type.  Fixed-length
! 	 * array types such as "name" shouldn't get deconstructed.  As of Postgres
! 	 * 8.1, rather than checking typlen we check the toast property, and don't
! 	 * deconstruct "plain storage" array types --- this is because we don't
! 	 * want to show oidvector as oid[].
! 	 */
! 	array_base_type = typeform->typelem;
! 
! 	if (array_base_type != InvalidOid &&
! 		typeform->typstorage != 'p')
! 	{
! 		/* Switch our attention to the array element type */
! 		ReleaseSysCache(tuple);
! 		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
! 		if (!HeapTupleIsValid(tuple))
! 		{
! 			if (allow_invalid)
! 				return pstrdup("???[]");
! 			else
! 				elog(ERROR, "cache lookup failed for type %u", type_oid);
! 		}
! 		typeform = (Form_pg_type) GETSTRUCT(tuple);
! 		type_oid = array_base_type;
! 		is_array = true;
! 	}
! 	else
! 		is_array = false;
! 
! 	/*
! 	 * See if we want to special-case the output for certain built-in types.
! 	 * Note that these special cases should all correspond to special
! 	 * productions in gram.y, to ensure that the type name will be taken as a
! 	 * system type, not a user type of the same name.
! 	 *
! 	 * If we do not provide a special-case output here, the type name will be
! 	 * handled the same way as a user type name --- in particular, it will be
! 	 * double-quoted if it matches any lexer keyword.  This behavior is
! 	 * essential for some cases, such as types "bit" and "char".
! 	 */
! 	buf = NULL;					/* flag for no special case */
  
  	switch (type_oid)
  	{
  		case BITOID:
  			if (with_typemod)
! 				buf = printTypmod("bit", typemod, typeform->typmodout);
  			else if (typemod_given)
  			{
  				/*
--- 115,140 ----
  	return format_type_internal(type_oid, typemod, true, false, false);
  }
  
+ /*
+  * Formats a system type.
+  *
+  * These special cases should all correspond to special productions in gram.y,
+  * to ensure that the type name will be taken as a system type, not a user type
+  * of the same name.
+  *
+  * Returns NULL if not a system type.
+  */
  static char *
! format_special_type(Oid type_oid, Form_pg_type typeform,
! 					int32 typemod, bool typemod_given, bool with_typemod)
  {
! 	char   *buf = NULL;
  
  	switch (type_oid)
  	{
  		case BITOID:
  			if (with_typemod)
! 				buf = printTypmod("bit", typemod, typeform->typmodout, false);
  			else if (typemod_given)
  			{
  				/*
***************
*** 201,207 **** format_type_internal(Oid type_oid, int32 typemod,
  
  		case BPCHAROID:
  			if (with_typemod)
! 				buf = printTypmod("character", typemod, typeform->typmodout);
  			else if (typemod_given)
  			{
  				/*
--- 153,160 ----
  
  		case BPCHAROID:
  			if (with_typemod)
! 				buf = printTypmod("character", typemod, typeform->typmodout,
! 								  false);
  			else if (typemod_given)
  			{
  				/*
***************
*** 236,296 **** format_type_internal(Oid type_oid, int32 typemod,
  
  		case NUMERICOID:
  			if (with_typemod)
! 				buf = printTypmod("numeric", typemod, typeform->typmodout);
  			else
  				buf = pstrdup("numeric");
  			break;
  
  		case INTERVALOID:
  			if (with_typemod)
! 				buf = printTypmod("interval", typemod, typeform->typmodout);
  			else
  				buf = pstrdup("interval");
  			break;
  
  		case TIMEOID:
  			if (with_typemod)
! 				buf = printTypmod("time", typemod, typeform->typmodout);
  			else
  				buf = pstrdup("time without time zone");
  			break;
  
  		case TIMETZOID:
  			if (with_typemod)
! 				buf = printTypmod("time", typemod, typeform->typmodout);
  			else
  				buf = pstrdup("time with time zone");
  			break;
  
  		case TIMESTAMPOID:
  			if (with_typemod)
! 				buf = printTypmod("timestamp", typemod, typeform->typmodout);
  			else
  				buf = pstrdup("timestamp without time zone");
  			break;
  
  		case TIMESTAMPTZOID:
  			if (with_typemod)
! 				buf = printTypmod("timestamp", typemod, typeform->typmodout);
  			else
  				buf = pstrdup("timestamp with time zone");
  			break;
  
  		case VARBITOID:
  			if (with_typemod)
! 				buf = printTypmod("bit varying", typemod, typeform->typmodout);
  			else
  				buf = pstrdup("bit varying");
  			break;
  
  		case VARCHAROID:
  			if (with_typemod)
! 				buf = printTypmod("character varying", typemod, typeform->typmodout);
  			else
  				buf = pstrdup("character varying");
  			break;
  	}
  
  	if (buf == NULL)
  	{
  		/*
--- 189,334 ----
  
  		case NUMERICOID:
  			if (with_typemod)
! 				buf = printTypmod("numeric", typemod, typeform->typmodout,
! 								  false);
  			else
  				buf = pstrdup("numeric");
  			break;
  
  		case INTERVALOID:
  			if (with_typemod)
! 				buf = printTypmod("interval", typemod, typeform->typmodout,
! 								  false);
  			else
  				buf = pstrdup("interval");
  			break;
  
  		case TIMEOID:
  			if (with_typemod)
! 				buf = printTypmod("time", typemod, typeform->typmodout,
! 								  false);
  			else
  				buf = pstrdup("time without time zone");
  			break;
  
  		case TIMETZOID:
  			if (with_typemod)
! 				buf = printTypmod("time", typemod, typeform->typmodout,
! 								  false);
  			else
  				buf = pstrdup("time with time zone");
  			break;
  
  		case TIMESTAMPOID:
  			if (with_typemod)
! 				buf = printTypmod("timestamp", typemod, typeform->typmodout,
! 								  false);
  			else
  				buf = pstrdup("timestamp without time zone");
  			break;
  
  		case TIMESTAMPTZOID:
  			if (with_typemod)
! 				buf = printTypmod("timestamp", typemod, typeform->typmodout,
! 								  false);
  			else
  				buf = pstrdup("timestamp with time zone");
  			break;
  
  		case VARBITOID:
  			if (with_typemod)
! 				buf = printTypmod("bit varying", typemod, typeform->typmodout,
! 								  false);
  			else
  				buf = pstrdup("bit varying");
  			break;
  
  		case VARCHAROID:
  			if (with_typemod)
! 				buf = printTypmod("character varying", typemod,
! 								  typeform->typmodout, false);
  			else
  				buf = pstrdup("character varying");
  			break;
  	}
  
+ 	return buf;
+ }
+ 
+ /*
+  * Return a formatted typename.
+  *
+  * If qualify is Auto, the type name is qualified if necessary, which means
+  * qualify when not visible to search_path.  If qualify is Always, it is
+  * qualified regardless of visibility.
+  */
+ static char *
+ format_type_internal(Oid type_oid, int32 typemod,
+ 					 bool typemod_given, bool allow_invalid,
+ 					 bool force_qualify)
+ {
+ 	bool		with_typemod = typemod_given && (typemod >= 0);
+ 	HeapTuple	tuple;
+ 	Form_pg_type typeform;
+ 	Oid			array_base_type;
+ 	bool		is_array;
+ 	char	   *buf;
+ 
+ 	if (type_oid == InvalidOid && allow_invalid)
+ 		return pstrdup("-");
+ 
+ 	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
+ 	if (!HeapTupleIsValid(tuple))
+ 	{
+ 		if (allow_invalid)
+ 			return pstrdup("???");
+ 		else
+ 			elog(ERROR, "cache lookup failed for type %u", type_oid);
+ 	}
+ 	typeform = (Form_pg_type) GETSTRUCT(tuple);
+ 
+ 	/*
+ 	 * Check if it's a regular (variable length) array type.  Fixed-length
+ 	 * array types such as "name" shouldn't get deconstructed.  As of Postgres
+ 	 * 8.1, rather than checking typlen we check the toast property, and don't
+ 	 * deconstruct "plain storage" array types --- this is because we don't
+ 	 * want to show oidvector as oid[].
+ 	 */
+ 	array_base_type = typeform->typelem;
+ 
+ 	if (array_base_type != InvalidOid &&
+ 		typeform->typstorage != 'p')
+ 	{
+ 		/* Switch our attention to the array element type */
+ 		ReleaseSysCache(tuple);
+ 		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
+ 		if (!HeapTupleIsValid(tuple))
+ 		{
+ 			if (allow_invalid)
+ 				return pstrdup("???[]");
+ 			else
+ 				elog(ERROR, "cache lookup failed for type %u", type_oid);
+ 		}
+ 		typeform = (Form_pg_type) GETSTRUCT(tuple);
+ 		type_oid = array_base_type;
+ 		is_array = true;
+ 	}
+ 	else
+ 		is_array = false;
+ 
+ 	/*
+ 	 * See if we want to special-case the output for certain built-in types.
+ 	 *
+ 	 * If we do not provide a special-case output here, the type name will be
+ 	 * handled the same way as a user type name --- in particular, it will be
+ 	 * double-quoted if it matches any lexer keyword.  This behavior is
+ 	 * essential for some cases, such as types "bit" and "char".
+ 	 */
+ 	buf = NULL;					/* flag for no special case */
+ 
+ 	buf = format_special_type(type_oid, typeform,
+ 							  typemod, typemod_given, with_typemod);
+ 
  	if (buf == NULL)
  	{
  		/*
***************
*** 312,318 **** format_type_internal(Oid type_oid, int32 typemod,
  		buf = quote_qualified_identifier(nspname, typname);
  
  		if (with_typemod)
! 			buf = printTypmod(buf, typemod, typeform->typmodout);
  	}
  
  	if (is_array)
--- 350,356 ----
  		buf = quote_qualified_identifier(nspname, typname);
  
  		if (with_typemod)
! 			buf = printTypmod(buf, typemod, typeform->typmodout, false);
  	}
  
  	if (is_array)
***************
*** 323,334 **** format_type_internal(Oid type_oid, int32 typemod,
  	return buf;
  }
  
  
  /*
   * Add typmod decoration to the basic type name
   */
  static char *
! printTypmod(const char *typname, int32 typmod, Oid typmodout)
  {
  	char	   *res;
  
--- 361,473 ----
  	return buf;
  }
  
+ /*
+  * Similar to format_type_internal, except we return each bit of information
+  * separately:
+  *
+  * - is_system is set if the type corresponds to a special case in gram.y
+  *   (and therefore does not need any quoting or schema-qualification)
+  *
+  * - nspname is the schema name, without quotes.  This is NULL if the
+  *   type is a system type.
+  *
+  * - typename is set to the type name, without quotes
+  *
+  * - typmod is set to the typemod, if any, as a string with parens
+  *
+  * - is_array indicates whether []s must be added
+  *
+  * XXX there is a lot of code duplication between this routine and
+  * format_type_internal.  (One thing that doesn't quite match is the whole
+  * allow_invalid business.)
+  */
+ void
+ format_type_detailed(Oid type_oid, int32 typemod,
+ 					 bool *is_system,
+ 					 char **nspname, char **typname, char **typemodstr,
+ 					 bool *is_array)
+ {
+ 	HeapTuple	tuple;
+ 	Form_pg_type typeform;
+ 	Oid			array_base_type;
+ 	char	   *buf;
+ 
+ 	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
+ 	if (!HeapTupleIsValid(tuple))
+ 		elog(ERROR, "cache lookup failed for type %u", type_oid);
+ 
+ 	typeform = (Form_pg_type) GETSTRUCT(tuple);
+ 
+ 	/*
+ 	 * Check if it's a regular (variable length) array type.  Fixed-length
+ 	 * array types such as "name" shouldn't get deconstructed.  As of Postgres
+ 	 * 8.1, rather than checking typlen we check the toast property, and don't
+ 	 * deconstruct "plain storage" array types --- this is because we don't
+ 	 * want to show oidvector as oid[].
+ 	 */
+ 	array_base_type = typeform->typelem;
+ 
+ 	if (array_base_type != InvalidOid &&
+ 		typeform->typstorage != 'p')
+ 	{
+ 		/* Switch our attention to the array element type */
+ 		ReleaseSysCache(tuple);
+ 		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
+ 		if (!HeapTupleIsValid(tuple))
+ 			elog(ERROR, "cache lookup failed for type %u", type_oid);
+ 
+ 		typeform = (Form_pg_type) GETSTRUCT(tuple);
+ 		type_oid = array_base_type;
+ 		*is_array = true;
+ 	}
+ 	else
+ 		*is_array = false;
+ 
+ 	/*
+ 	 * See if we want to special-case the output for certain built-in types.
+ 	 *
+ 	 * If we do not provide a special-case output here, the type name must be
+ 	 * handled the same way as a user type name --- in particular, it must be
+ 	 * double-quoted if it matches any lexer keyword.  This behavior is
+ 	 * essential for some cases, such as types "bit" and "char".
+ 	 */
+ 	buf = format_special_type(type_oid, typeform,
+ 							  typemod, typemod >= 0, false);
+ 
+ 	if (buf != NULL)
+ 	{
+ 		*is_system = true;
+ 		*typname = buf;
+ 		*nspname = NULL;
+ 
+ 		if (typemod > 0)
+ 			*typemodstr = printTypmod(buf, typemod, typeform->typmodout, true);
+ 		else
+ 			*typemodstr = pstrdup("");	/* XXX ?? */
+ 	}
+ 	else
+ 	{
+ 		/* Default handling: report the name as it appears in the catalog. */
+ 		*is_system = false;
+ 
+ 		*nspname = get_namespace_name(typeform->typnamespace);
+ 		*typname = pstrdup(NameStr(typeform->typname));
+ 
+ 		if (typemod > 0)
+ 			*typemodstr = printTypmod(buf, typemod, typeform->typmodout, true);
+ 		else
+ 			*typemodstr = pstrdup("");	/* XXX ?? */
+ 	}
+ 
+ 	ReleaseSysCache(tuple);
+ }
+ 
  
  /*
   * Add typmod decoration to the basic type name
   */
  static char *
! printTypmod(const char *typname, int32 typmod, Oid typmodout, bool typmodOnly)
  {
  	char	   *res;
  
***************
*** 338,344 **** printTypmod(const char *typname, int32 typmod, Oid typmodout)
  	if (typmodout == InvalidOid)
  	{
  		/* Default behavior: just print the integer typmod with parens */
! 		res = psprintf("%s(%d)", typname, (int) typmod);
  	}
  	else
  	{
--- 477,486 ----
  	if (typmodout == InvalidOid)
  	{
  		/* Default behavior: just print the integer typmod with parens */
! 		if (typmodOnly)
! 			res = psprintf("(%d)", (int) typmod);
! 		else
! 			res = psprintf("%s(%d)", typname, (int) typmod);
  	}
  	else
  	{
***************
*** 347,359 **** printTypmod(const char *typname, int32 typmod, Oid typmodout)
  
  		tmstr = DatumGetCString(OidFunctionCall1(typmodout,
  												 Int32GetDatum(typmod)));
! 		res = psprintf("%s%s", typname, tmstr);
  	}
  
  	return res;
  }
  
- 
  /*
   * type_maximum_size --- determine maximum width of a variable-width column
   *
--- 489,503 ----
  
  		tmstr = DatumGetCString(OidFunctionCall1(typmodout,
  												 Int32GetDatum(typmod)));
! 		if (typmodOnly)
! 			res = psprintf("%s", tmstr);
! 		else
! 			res = psprintf("%s%s", typname, tmstr);
  	}
  
  	return res;
  }
  
  /*
   * type_maximum_size --- determine maximum width of a variable-width column
   *
*** a/src/backend/utils/adt/jsonfuncs.c
--- b/src/backend/utils/adt/jsonfuncs.c
***************
*** 212,224 **** typedef struct PopulateRecordsetState
  }	PopulateRecordsetState;
  
  /*
!  * SQL function json_object-keys
   *
   * Returns the set of keys for the object argument.
   *
   * This SRF operates in value-per-call mode. It processes the
   * object during the first call, and the keys are simply stashed
!  * in an array, whise size is expanded as necessary. This is probably
   * safe enough for a list of keys of a single object, since they are
   * limited in size to NAMEDATALEN and the number of keys is unlikely to
   * be so huge that it has major memory implications.
--- 212,224 ----
  }	PopulateRecordsetState;
  
  /*
!  * SQL function json_object_keys
   *
   * Returns the set of keys for the object argument.
   *
   * This SRF operates in value-per-call mode. It processes the
   * object during the first call, and the keys are simply stashed
!  * in an array, whose size is expanded as necessary. This is probably
   * safe enough for a list of keys of a single object, since they are
   * limited in size to NAMEDATALEN and the number of keys is unlikely to
   * be so huge that it has major memory implications.
*** a/src/backend/utils/adt/ruleutils.c
--- b/src/backend/utils/adt/ruleutils.c
***************
*** 4156,4161 **** get_query_def(Query *query, StringInfo buf, List *parentnamespace,
--- 4156,4175 ----
  	}
  }
  
+ char *
+ pg_get_viewstmt_definition(Query *viewParse)
+ {
+ 	StringInfoData	buf;
+ 
+ 	initStringInfo(&buf);
+ 
+ 	get_query_def(viewParse, &buf, NIL, NULL, 0,
+ 				  WRAP_COLUMN_DEFAULT, 1);
+ 
+ 	return buf.data;
+ }
+ 
+ 
  /* ----------
   * get_values_def			- Parse back a VALUES list
   * ----------
*** a/src/include/catalog/dependency.h
--- b/src/include/catalog/dependency.h
***************
*** 176,181 **** extern void recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
--- 176,183 ----
  
  extern ObjectClass getObjectClass(const ObjectAddress *object);
  
+ extern Oid get_class_catalog(ObjectClass oclass);
+ 
  extern ObjectAddresses *new_object_addresses(void);
  
  extern void add_exact_object_address(const ObjectAddress *object,
*** a/src/include/catalog/pg_proc.h
--- b/src/include/catalog/pg_proc.h
***************
*** 4759,4764 **** DESCR("SP-GiST support for quad tree over range");
--- 4759,4768 ----
  /* event triggers */
  DATA(insert OID = 3566 (  pg_event_trigger_dropped_objects		PGNSP PGUID 12 10 100 0 0 f f f f t t s 0 0 2249 "" "{26,26,23,25,25,25,25}" "{o,o,o,o,o,o,o}" "{classid, objid, objsubid, object_type, schema_name, object_name, object_identity}" _null_ pg_event_trigger_dropped_objects _null_ _null_ _null_ ));
  DESCR("list objects dropped by the current command");
+ DATA(insert OID = 3567 (  pg_event_trigger_get_creation_commands PGNSP PGUID 12 10 100 0 0 f f f f t t s 0 0 2249 "" "{25,25}" "{o,o}" "{identity,command}" _null_ pg_event_trigger_get_creation_commands _null_ _null_ _null_ ));
+ DESCR("list objects created by the current command");
+ DATA(insert OID = 3568 (  pg_event_trigger_expand_command PGNSP PGUID 12 10 1 0 0 f f f f t f s 1 0 25 "114" _null_ _null_ _null_ _null_ pg_event_trigger_expand_command _null_ _null_ _null_ ));
+ DESCR("format JSON message");
  
  /* generic transition functions for ordered-set aggregates */
  DATA(insert OID = 3970 ( ordered_set_transition			PGNSP PGUID 12 1 0 0 0 f f f f f f i 2 0 2281 "2281 2276" _null_ _null_ _null_ _null_ ordered_set_transition _null_ _null_ _null_ ));
*** /dev/null
--- b/src/include/commands/alter_table.h
***************
*** 0 ****
--- 1,53 ----
+ #ifndef ALTER_TABLE_H
+ #define ALTER_TABLE_H
+ 
+ /*
+  * State information for ALTER TABLE
+  *
+  * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
+  * structs, one for each table modified by the operation (the named table
+  * plus any child tables that are affected).  We save lists of subcommands
+  * to apply to this table (possibly modified by parse transformation steps);
+  * these lists will be executed in Phase 2.  If a Phase 3 step is needed,
+  * necessary information is stored in the constraints and newvals lists.
+  *
+  * Phase 2 is divided into multiple passes; subcommands are executed in
+  * a pass determined by subcommand type.
+  */
+ 
+ #define AT_PASS_UNSET			-1		/* UNSET will cause ERROR */
+ #define AT_PASS_DROP			0		/* DROP (all flavors) */
+ #define AT_PASS_ALTER_TYPE		1		/* ALTER COLUMN TYPE */
+ #define AT_PASS_OLD_INDEX		2		/* re-add existing indexes */
+ #define AT_PASS_OLD_CONSTR		3		/* re-add existing constraints */
+ #define AT_PASS_COL_ATTRS		4		/* set other column attributes */
+ /* We could support a RENAME COLUMN pass here, but not currently used */
+ #define AT_PASS_ADD_COL			5		/* ADD COLUMN */
+ #define AT_PASS_ADD_INDEX		6		/* ADD indexes */
+ #define AT_PASS_ADD_CONSTR		7		/* ADD constraints, defaults */
+ #define AT_PASS_MISC			8		/* other stuff */
+ #define AT_NUM_PASSES			9
+ 
+ typedef struct AlteredTableInfo
+ {
+ 	/* Information saved before any work commences: */
+ 	Oid			relid;			/* Relation to work on */
+ 	char		relkind;		/* Its relkind */
+ 	TupleDesc	oldDesc;		/* Pre-modification tuple descriptor */
+ 	/* Information saved by Phase 1 for Phase 2: */
+ 	List	   *subcmds[AT_NUM_PASSES]; /* Lists of AlterTableCmd */
+ 	/* Information saved by Phases 1/2 for Phase 3: */
+ 	List	   *constraints;	/* List of NewConstraint */
+ 	List	   *newvals;		/* List of NewColumnValue */
+ 	bool		new_notnull;	/* T if we added new NOT NULL constraints */
+ 	bool		rewrite;		/* T if a rewrite is forced */
+ 	Oid			newTableSpace;	/* new tablespace; 0 means no change */
+ 	/* Objects to rebuild after completing ALTER TYPE operations */
+ 	List	   *changedConstraintOids;	/* OIDs of constraints to rebuild */
+ 	List	   *changedConstraintDefs;	/* string definitions of same */
+ 	List	   *changedIndexOids;		/* OIDs of indexes to rebuild */
+ 	List	   *changedIndexDefs;		/* string definitions of same */
+ } AlteredTableInfo;
+ 
+ 
+ #endif	/* ALTER_TABLE_H */
*** 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
***************
*** 49,54 **** extern void EventTriggerSQLDrop(Node *parsetree);
--- 49,56 ----
  
  extern bool EventTriggerBeginCompleteQuery(void);
  extern void EventTriggerEndCompleteQuery(void);
+ extern void EventTriggerStashCreatedObject(Oid objectId, Oid classId,
+ 							   Node *parsetree);
  extern bool trackDroppedObjectsNeeded(void);
  extern void EventTriggerSQLDropAddObject(ObjectAddress *object);
  
*** a/src/include/commands/matview.h
--- b/src/include/commands/matview.h
***************
*** 22,28 ****
  
  extern void SetMatViewPopulatedState(Relation relation, bool newstate);
  
! extern void ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
  				   ParamListInfo params, char *completionTag);
  
  extern DestReceiver *CreateTransientRelDestReceiver(Oid oid);
--- 22,28 ----
  
  extern void SetMatViewPopulatedState(Relation relation, bool newstate);
  
! extern Oid ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
  				   ParamListInfo params, char *completionTag);
  
  extern DestReceiver *CreateTransientRelDestReceiver(Oid oid);
*** /dev/null
--- b/src/include/tcop/deparse_utility.h
***************
*** 0 ****
--- 1,18 ----
+ /*-------------------------------------------------------------------------
+  *
+  * deparse_utility.h
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  * src/include/tcop/deparse_utility.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ #ifndef DEPARSE_UTILITY_H
+ #define DEPARSE_UTILITY_H
+ 
+ extern void deparse_utility_command(Oid objectId, Node *parsetree,
+ 						char **command);
+ 
+ #endif	/* DEPARSE_UTILITY_H */
*** a/src/include/utils/builtins.h
--- b/src/include/utils/builtins.h
***************
*** 672,677 **** extern Datum pg_get_triggerdef_ext(PG_FUNCTION_ARGS);
--- 672,678 ----
  extern Datum pg_get_constraintdef(PG_FUNCTION_ARGS);
  extern Datum pg_get_constraintdef_ext(PG_FUNCTION_ARGS);
  extern char *pg_get_constraintdef_string(Oid constraintId);
+ extern char *pg_get_viewstmt_definition(Query *viewParse);
  extern Datum pg_get_expr(PG_FUNCTION_ARGS);
  extern Datum pg_get_expr_ext(PG_FUNCTION_ARGS);
  extern Datum pg_get_userbyid(PG_FUNCTION_ARGS);
***************
*** 1057,1062 **** extern char *format_type_be_qualified(Oid type_oid);
--- 1058,1066 ----
  extern char *format_type_with_typemod(Oid type_oid, int32 typemod);
  extern Datum oidvectortypes(PG_FUNCTION_ARGS);
  extern int32 type_maximum_size(Oid type_oid, int32 typemod);
+ extern void format_type_detailed(Oid type_oid, int32 typemod,
+ 					 bool *is_system, char **nspname, char **typname,
+ 					 char **typemodstr, bool *is_array);
  
  /* quote.c */
  extern Datum quote_ident(PG_FUNCTION_ARGS);
***************
*** 1177,1182 **** extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
--- 1181,1188 ----
  
  /* commands/event_trigger.c */
  extern Datum pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS);
+ extern Datum pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS);
+ extern Datum pg_event_trigger_expand_command(PG_FUNCTION_ARGS);
  
  /* commands/extension.c */
  extern Datum pg_available_extensions(PG_FUNCTION_ARGS);

diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c
index e511669..0c75ed1 100644
--- a/src/backend/catalog/dependency.c
+++ b/src/backend/catalog/dependency.c
@@ -2014,6 +2014,13 @@ add_object_address(ObjectClass oclass, Oid objectId, int32 subId,
 	addrs->numrefs++;
 }
 
+Oid
+get_class_catalog(ObjectClass oclass)
+{
+	Assert(oclass < MAX_OCLASS);
+	return object_classes[oclass];
+}
+
 /*
  * Add an entry to an ObjectAddresses array.
  *
diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 73e6e20..bdc15f1 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -55,6 +55,9 @@ typedef struct
 	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);
@@ -64,7 +67,7 @@ static void intorel_destroy(DestReceiver *self);
 /*
  * ExecCreateTableAs -- execute a CREATE TABLE AS command
  */
-void
+Oid
 ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 				  ParamListInfo params, char *completionTag)
 {
@@ -75,6 +78,7 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 	Oid			save_userid = InvalidOid;
 	int			save_sec_context = 0;
 	int			save_nestlevel = 0;
+	Oid			relOid;
 	List	   *rewritten;
 	PlannedStmt *plan;
 	QueryDesc  *queryDesc;
@@ -98,7 +102,9 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		Assert(!is_matview);	/* excluded by syntax */
 		ExecuteQuery(estmt, into, queryString, params, dest, completionTag);
 
-		return;
+		relOid = CreateAsRelid;
+		CreateAsRelid = InvalidOid;
+		return relOid;
 	}
 	Assert(query->commandType == CMD_SELECT);
 
@@ -190,6 +196,11 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		/* Restore userid and security context */
 		SetUserIdAndSecContext(save_userid, save_sec_context);
 	}
+
+	relOid = CreateAsRelid;
+	CreateAsRelid = InvalidOid;
+
+	return relOid;
 }
 
 /*
@@ -421,6 +432,9 @@ intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
 	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.
diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index 59f0842..9a9cd5a 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -31,10 +31,12 @@
 #include "pgstat.h"
 #include "lib/ilist.h"
 #include "miscadmin.h"
+#include "tcop/deparse_utility.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/evtcache.h"
 #include "utils/fmgroids.h"
+#include "utils/json.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/rel.h"
@@ -48,6 +50,7 @@ typedef struct EventTriggerQueryState
 	slist_head	SQLDropList;
 	bool		in_sql_drop;
 	MemoryContext cxt;
+	List	   *stash;
 	struct EventTriggerQueryState *previous;
 } EventTriggerQueryState;
 
@@ -491,7 +494,7 @@ AlterEventTriggerOwner(const char *name, Oid newOwnerId)
 }
 
 /*
- * Change extension owner, by OID
+ * Change event trigger owner, by OID
  */
 void
 AlterEventTriggerOwner_oid(Oid trigOid, Oid newOwnerId)
@@ -1022,13 +1025,6 @@ EventTriggerBeginCompleteQuery(void)
 	EventTriggerQueryState *state;
 	MemoryContext cxt;
 
-	/*
-	 * Currently, sql_drop 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_MINSIZE,
@@ -1036,8 +1032,10 @@ EventTriggerBeginCompleteQuery(void)
 								ALLOCSET_DEFAULT_MAXSIZE);
 	state = MemoryContextAlloc(cxt, sizeof(EventTriggerQueryState));
 	state->cxt = cxt;
-	slist_init(&(state->SQLDropList));
+	if (trackDroppedObjectsNeeded())
+		slist_init(&(state->SQLDropList));
 	state->in_sql_drop = false;
+	state->stash = NIL;
 
 	state->previous = currentEventTriggerState;
 	currentEventTriggerState = state;
@@ -1217,7 +1215,7 @@ pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 		 errmsg("%s can only be called in a sql_drop event trigger function",
-				"pg_event_trigger_dropped_objects()")));
+				PG_FUNCNAME_MACRO)));
 
 	/* check to see if caller supports us returning a tuplestore */
 	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
@@ -1294,3 +1292,779 @@ pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)
 
 	return (Datum) 0;
 }
+
+/*
+ * Support for tracking of objects created during command run.
+ *
+ * When a command is run that creates some SQL objects, we collect the
+ * classid/objid of the objects being created, as well as the parsetree of the
+ * creation command; later, when event triggers are run for that command, they
+ * can use pg_event_trigger_get_creation_commands which computes and returns a
+ * usable representation of the creation commands for the objects.
+ */
+typedef struct stashedObject
+{
+	Oid			objectId;
+	Oid			classId;
+	Node	   *parsetree;
+} stashedObject;
+
+static stashedObject *
+newStashedObject(Oid objectId, ObjectClass class, Node *parsetree)
+{
+	stashedObject *stashed = palloc(sizeof(stashedObject));
+
+	stashed->objectId = objectId;
+	stashed->classId = get_class_catalog(class);
+	stashed->parsetree = copyObject(parsetree);
+
+	return stashed;
+}
+
+void
+EventTriggerStashCreatedObject(Oid objectId, ObjectClass class,
+							   Node *parsetree)
+{
+	MemoryContext oldcxt;
+
+	oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
+
+	currentEventTriggerState->stash =
+		lappend(currentEventTriggerState->stash,
+				newStashedObject(objectId, class, parsetree));
+
+	MemoryContextSwitchTo(oldcxt);
+}
+
+Datum
+pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+	TupleDesc	tupdesc;
+	Tuplestorestate *tupstore;
+	MemoryContext per_query_ctx;
+	MemoryContext oldcontext;
+	ListCell   *lc;
+
+	/*
+	 * Protect this function from being called out of context
+	 */
+	if (!currentEventTriggerState)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("%s can only be called in an event trigger function",
+						PG_FUNCNAME_MACRO)));
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	/* Build a tuple descriptor for our result type */
+	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+		elog(ERROR, "return type must be a row type");
+
+	/* Build tuplestore to hold the result rows */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupstore = tuplestore_begin_heap(true, false, work_mem);
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	MemoryContextSwitchTo(oldcontext);
+
+	foreach(lc, currentEventTriggerState->stash)
+	{
+		stashedObject *obj = lfirst(lc);
+		char	   *command;
+
+		command = deparse_utility_command(obj->objectId, obj->parsetree);
+
+		/*
+		 * Some parse trees return NULL when deparse is attempted; we don't
+		 * emit anything for them.
+		 */
+		if (command != NULL)
+		{
+			Datum		values[2];
+			bool		nulls[2];
+			ObjectAddress addr;
+			char	   *identity;
+			int			i = 0;
+
+			addr.classId = obj->classId;
+			addr.objectId = obj->objectId;
+			addr.objectSubId = 0;
+			identity = getObjectIdentity(&addr);
+
+			MemSet(nulls, 0, sizeof(nulls));
+
+			/* identity */
+			values[i++] = CStringGetTextDatum(identity);
+			/* command */
+			values[i++] = CStringGetTextDatum(command);
+
+			tuplestore_putvalues(tupstore, tupdesc, values, nulls);
+			pfree(identity);
+		}
+	}
+
+	/* clean up and return the tuplestore */
+	tuplestore_donestoring(tupstore);
+
+	PG_RETURN_VOID();
+}
+
+/* ************************* JSON STUFF FROM HERE ************************* *
+ *	Code below is used to decode blobs returned by deparse_utility_command	*
+ *																			*/
+
+/*
+ * Note we only support types that are valid in command representation from
+ * deparse_utility_command.
+ */
+typedef enum
+{
+	JsonIsArray,
+	JsonIsObject,
+	JsonIsString
+} JsonType;
+
+typedef enum
+{
+	SpecTypename,
+	SpecOperatorname,
+	SpecDottedName,
+	SpecString,
+	SpecIdentifier
+} convSpecifier;
+
+/*
+ * Extract the named json field, which must be of type string, from the given
+ * JSON datum, which must be of type object.  If the field doesn't exist,
+ * NULL is returned.  Otherwise the string value is returned.
+ */
+static char *
+expand_get_strval(Datum json, char *field_name)
+{
+	FunctionCallInfoData fcinfo;
+	Datum		result;
+	char	   *value_str;
+
+	InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+
+	fcinfo.arg[0] = json;
+	fcinfo.argnull[0] = false;
+	fcinfo.arg[1] = CStringGetTextDatum(field_name);
+	fcinfo.argnull[1] = false;
+
+	result = (*json_object_field_text) (&fcinfo);
+
+	if (fcinfo.isnull)
+		return NULL;
+
+	value_str = TextDatumGetCString(result);
+
+	pfree(DatumGetPointer(result));
+
+	return value_str;
+}
+
+/*
+ * Extract the named json field, which must be of type boolean, from the given
+ * JSON datum, which must be of type object.  If the field doesn't exist,
+ * isnull is set to TRUE and the return value should not be consulted.
+ * Otherwise the boolean value is returned.
+ */
+static bool
+expand_get_boolval(Datum json, char *field_name, bool *isnull)
+{
+	FunctionCallInfoData fcinfo;
+	Datum		result;
+	char	   *value_str;
+
+	InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+
+	fcinfo.arg[0] = json;
+	fcinfo.argnull[0] = false;
+	fcinfo.arg[1] = CStringGetTextDatum(field_name);
+	fcinfo.argnull[1] = false;
+
+	result = (*json_object_field_text) (&fcinfo);
+
+	if (fcinfo.isnull)
+	{
+		*isnull = true;
+		return false;
+	}
+
+	value_str = TextDatumGetCString(result);
+
+	if (strcmp(value_str, "true") == 0)
+		return true;
+
+	Assert(strcmp(value_str, "false") == 0);
+	return false;
+}
+
+/*
+ * Given a JSON value, return its type.
+ *
+ * We return both a JsonType (for easy control flow), and a string name (for
+ * error reporting).
+ */
+static JsonType
+jsonval_get_type(Datum jsonval, char **typename)
+{
+	JsonType	json_elt_type;
+	Datum		paramtype_datum;
+	char	   *paramtype;
+
+	paramtype_datum = DirectFunctionCall1(json_typeof, jsonval);
+	paramtype = TextDatumGetCString(paramtype_datum);
+
+	if (strcmp(paramtype, "array") == 0)
+		json_elt_type = JsonIsArray;
+	else if (strcmp(paramtype, "object") == 0)
+		json_elt_type = JsonIsObject;
+	else if (strcmp(paramtype, "string") == 0)
+		json_elt_type = JsonIsString;
+	else
+		/* XXX improve this; need to specify array index or param name */
+		elog(ERROR, "unexpected JSON element type %s",
+			 paramtype);
+
+	if (typename)
+		*typename = pstrdup(paramtype);
+
+	return json_elt_type;
+}
+
+/*
+ * dequote_jsonval
+ *		Take a string value extracted from a JSON object, and return a copy of it
+ *		with the quoting removed.
+ *
+ * Another alternative to this would be to run the extraction routine again,
+ * using the "_text" variant which returns the value without quotes; but this
+ * is expensive, and moreover it complicates the logic a lot because not all
+ * values are extracted in the same way (some are extracted using
+ * json_object_field, others using json_array_element).  Dequoting the object
+ * already at hand is a lot easier.
+ */
+static char *
+dequote_jsonval(char *jsonval)
+{
+	char	   *result;
+	int			inputlen = strlen(jsonval);
+	int			i;
+	int			j = 0;
+
+	result = palloc(strlen(jsonval) + 1);
+
+	/* skip the start and end quotes right away */
+	for (i = 1; i < inputlen - 1; i++)
+	{
+		/*
+		 * XXX this skips the \ in a \" sequence but leaves other escaped
+		 * sequences in place.	Are there other cases we need to handle
+		 * specially?
+		 */
+		if (jsonval[i] == '\\' &&
+			jsonval[i + 1] == '"')
+		{
+			i++;
+			continue;
+		}
+
+		result[j++] = jsonval[i];
+	}
+	result[j] = '\0';
+
+	return result;
+}
+
+/*
+ * Expand a json value as an identifier.  The value must be of type string.
+ */
+static void
+expand_jsonval_identifier(StringInfo buf, Datum jsonval)
+{
+	char	   *unquoted;
+
+	unquoted = dequote_jsonval(TextDatumGetCString(jsonval));
+	appendStringInfo(buf, "%s", quote_identifier(unquoted));
+
+	pfree(unquoted);
+}
+
+/*
+ * Expand a json value as a dotted-name.  The value must be of type object
+ * and must contain elements "schemaname" (optional), "objname" (mandatory),
+ * "attrname" (optional).
+ *
+ * XXX do we need a "catalogname" as well?
+ */
+static void
+expand_jsonval_dottedname(StringInfo buf, Datum jsonval)
+{
+	char	   *schema;
+	char	   *objname;
+	char	   *attrname;
+	const char *qschema;
+	const char *qname;
+
+	schema = expand_get_strval(jsonval, "schemaname");
+	objname = expand_get_strval(jsonval, "objname");
+	if (objname == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid NULL object name in %%D element")));
+	qname = quote_identifier(objname);
+	if (schema == NULL)
+	{
+		appendStringInfo(buf, "%s", qname);
+	}
+	else
+	{
+		qschema = quote_identifier(schema);
+		appendStringInfo(buf, "%s.%s",
+						 qschema, qname);
+		if (qschema != schema)
+			pfree((char *) qschema);
+		pfree(schema);
+	}
+
+	attrname = expand_get_strval(jsonval, "attrname");
+	if (attrname)
+	{
+		const char *qattr;
+
+		qattr = quote_identifier(attrname);
+		appendStringInfo(buf, ".%s", qattr);
+		if (qattr != attrname)
+			pfree((char *) qattr);
+		pfree(attrname);
+	}
+
+	if (qname != objname)
+		pfree((char *) qname);
+	pfree(objname);
+}
+
+/*
+ * expand a json value as a type name.
+ */
+static void
+expand_jsonval_typename(StringInfo buf, Datum jsonval)
+{
+	char	   *schema = NULL;
+	char	   *typename;
+	char	   *typmodstr;
+	bool		array_isnull;
+	bool		is_array;
+
+	typename = expand_get_strval(jsonval, "typename");
+	if (typename == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid NULL type name in %%T element")));
+	typmodstr = expand_get_strval(jsonval, "typmod");	/* OK if null */
+	is_array = expand_get_boolval(jsonval, "is_array", &array_isnull);
+	schema = expand_get_strval(jsonval, "schemaname");
+
+	/* schema might be NULL or empty here, beware */
+	if (schema == NULL || schema[0] == '\0')
+		appendStringInfo(buf, "%s%s%s",
+						 quote_identifier(typename),
+						 typmodstr ? typmodstr : "",
+						 is_array ? "[]" : "");
+	else
+		appendStringInfo(buf, "%s.%s%s%s",
+						 quote_identifier(schema),
+						 quote_identifier(typename),
+						 typmodstr ? typmodstr : "",
+						 is_array ? "[]" : "");
+}
+
+/*
+ * Expand a json value as an operator name
+ */
+static void
+expand_jsonval_operator(StringInfo buf, Datum jsonval)
+{
+	char	   *schema = NULL;
+	char	   *operator;
+
+	operator = expand_get_strval(jsonval, "objname");
+	if (operator == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid NULL operator name in %%O element")));
+	schema = expand_get_strval(jsonval, "schemaname");
+
+	/* schema might be NULL or empty */
+	if (schema == NULL || schema[0] == '\0')
+		appendStringInfo(buf, "%s", operator);
+	else
+		appendStringInfo(buf, "%s.%s",
+						 quote_identifier(schema),
+						 operator);
+}
+
+/*
+ * Expand a json value as a string.  The value must be of type string or of
+ * type object, in which case it must contain a "fmt" element which will be
+ * recursively expanded; also, if the object contains an element "present"
+ * and it is set to false, the expansion is the empty string.
+ */
+static void
+expand_jsonval_string(StringInfo buf, Datum jsonval, JsonType json_elt_type)
+{
+	if (json_elt_type == JsonIsString)
+	{
+		char	   *str;
+		char	   *unquoted;
+
+		str = TextDatumGetCString(jsonval);
+		unquoted = dequote_jsonval(str);
+		appendStringInfo(buf, "%s", unquoted);
+		pfree(str);
+		pfree(unquoted);
+	}
+	else if (json_elt_type == JsonIsObject)
+	{
+		bool		present;
+		bool		isnull;
+
+		present = expand_get_boolval(jsonval, "present", &isnull);
+
+		if (isnull || present)
+		{
+			Datum		inner;
+			char	   *str;
+
+			inner = DirectFunctionCall1(pg_event_trigger_expand_command,
+										jsonval);
+			str = TextDatumGetCString(inner);
+
+			appendStringInfoString(buf, str);
+			pfree(DatumGetPointer(inner));
+			pfree(str);
+		}
+	}
+}
+
+/*
+ * Expand one json element according to rules.
+ */
+static void
+expand_one_element(StringInfo buf, char *param,
+				   Datum jsonval, char *valtype, JsonType json_elt_type,
+				   convSpecifier specifier)
+{
+	/*
+	 * Validate the parameter type.  If dotted-name was specified, then a JSON
+	 * object element is expected; if an identifier was specified, then a JSON
+	 * string is expected.	If a string was specified, then either a JSON
+	 * object or a string is expected.
+	 */
+	if (specifier == SpecDottedName && json_elt_type != JsonIsObject)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON object for %%D element \"%s\", got %s",
+						param, valtype)));
+	if (specifier == SpecTypename && json_elt_type != JsonIsObject)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON object for %%T element \"%s\", got %s",
+						param, valtype)));
+	if (specifier == SpecOperatorname && json_elt_type != JsonIsObject)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON object for %%O element \"%s\", got %s",
+						param, valtype)));
+	if (specifier == SpecIdentifier && json_elt_type != JsonIsString)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON string for %%I element \"%s\", got %s",
+						param, valtype)));
+	if (specifier == SpecString &&
+		json_elt_type != JsonIsString && json_elt_type != JsonIsObject)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON string or object for %%s element \"%s\", got %s",
+						param, valtype)));
+
+	switch (specifier)
+	{
+		case SpecIdentifier:
+			expand_jsonval_identifier(buf, jsonval);
+			break;
+
+		case SpecDottedName:
+			expand_jsonval_dottedname(buf, jsonval);
+			break;
+
+		case SpecString:
+			expand_jsonval_string(buf, jsonval, json_elt_type);
+			break;
+
+		case SpecTypename:
+			expand_jsonval_typename(buf, jsonval);
+			break;
+
+		case SpecOperatorname:
+			expand_jsonval_operator(buf, jsonval);
+			break;
+	}
+}
+
+/*
+ * Expand one JSON array element according to rules.
+ */
+static void
+expand_one_array_element(StringInfo buf, Datum array, int idx, char *param,
+						 convSpecifier specifier)
+{
+	Datum		elemval;
+	JsonType	json_elt_type;
+	char	   *elemtype;
+
+	elemval = DirectFunctionCall2(json_array_element,
+								  PointerGetDatum(array),
+								  Int32GetDatum(idx));
+	json_elt_type = jsonval_get_type(elemval, &elemtype);
+
+	expand_one_element(buf, param,
+					   elemval, elemtype, json_elt_type,
+					   specifier);
+}
+
+#define ADVANCE_PARSE_POINTER(ptr,end_ptr) \
+	do { \
+		if (++(ptr) >= (end_ptr)) \
+			ereport(ERROR, \
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+					 errmsg("unterminated format specifier"))); \
+	} while (0)
+
+/*------
+ * Returns a formatted string from a JSON object.
+ *
+ * The starting point is the element named "fmt" (which must be a string).
+ * This format string may contain zero or more %-escapes, which consist of an
+ * element name enclosed in { }, possibly followed by a conversion modifier,
+ * followed by a conversion specifier.	Possible conversion specifiers are:
+ *
+ * %		expand to a literal %.
+ * I		expand as a single, non-qualified identifier
+ * D		expand as a possibly-qualified identifier
+ * T		expand as a type name
+ * O		expand as an operator name
+ * s		expand as a simple string (no quoting)
+ *
+ * The element name may have an optional separator specification preceded
+ * by a colon.	Its presence indicates that the element is expected to be
+ * an array; the specified separator is used to join the array elements.
+ *
+ * XXX the current implementation works fine, but is likely to be slow: for
+ * each element found in the fmt string we parse the JSON object once.	It
+ * might be better to use jsonapi.h directly so that we build a hash or tree of
+ * elements and their values once before parsing the fmt string, and later scan
+ * fmt using the tree.
+ *------
+ */
+Datum
+pg_event_trigger_expand_command(PG_FUNCTION_ARGS)
+{
+	text	   *json = PG_GETARG_TEXT_P(0);
+	char	   *fmt_str;
+	int			fmt_len;
+	const char *cp;
+	const char *start_ptr;
+	const char *end_ptr;
+	StringInfoData str;
+
+	fmt_str = expand_get_strval(PointerGetDatum(json), "fmt");
+	if (fmt_str == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid NULL format string")));
+	fmt_len = strlen(fmt_str);
+
+	start_ptr = fmt_str;
+	end_ptr = start_ptr + fmt_len;
+	initStringInfo(&str);
+
+	for (cp = start_ptr; cp < end_ptr; cp++)
+	{
+		convSpecifier specifier;
+		bool		is_array;
+		char	   *param = NULL;
+		char	   *arraysep = NULL;
+		Datum		paramval;
+		char	   *paramtype;
+		JsonType	json_elt_type;
+
+		if (*cp != '%')
+		{
+			appendStringInfoCharMacro(&str, *cp);
+			continue;
+		}
+
+		is_array = false;
+
+		ADVANCE_PARSE_POINTER(cp, end_ptr);
+
+		/* Easy case: %% outputs a single % */
+		if (*cp == '%')
+		{
+			appendStringInfoCharMacro(&str, *cp);
+			continue;
+		}
+
+		/*
+		 * Scan the mandatory element name.  Allow for an array separator
+		 * (which may be the empty string) to be specified after colon.
+		 */
+		if (*cp == '{')
+		{
+			StringInfoData parbuf;
+			StringInfoData arraysepbuf;
+			StringInfo	appendTo;
+
+			initStringInfo(&parbuf);
+			appendTo = &parbuf;
+
+			ADVANCE_PARSE_POINTER(cp, end_ptr);
+			for (; cp < end_ptr;)
+			{
+				if (*cp == ':')
+				{
+					/*
+					 * found array separator delimiter; element name is now
+					 * complete, start filling the separator.
+					 */
+					initStringInfo(&arraysepbuf);
+					appendTo = &arraysepbuf;
+					is_array = true;
+					ADVANCE_PARSE_POINTER(cp, end_ptr);
+					continue;
+				}
+
+				if (*cp == '}')
+				{
+					ADVANCE_PARSE_POINTER(cp, end_ptr);
+					break;
+				}
+				appendStringInfoCharMacro(appendTo, *cp);
+				ADVANCE_PARSE_POINTER(cp, end_ptr);
+			}
+			param = parbuf.data;
+			if (is_array)
+				arraysep = arraysepbuf.data;
+		}
+		if (param == NULL)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("missing conversion name in conversion specifier")));
+
+		/*
+		 * The following conversion specifiers are currently recognized: 'I'
+		 * -- expand as an identifier, adding quotes if necessary 'D' --
+		 * expand as a dotted-name, for qualified names; each element is
+		 * quoted if necessary 's' -- expand as a simple string; no quoting.
+		 */
+		switch (*cp)
+		{
+			case 'I':
+				specifier = SpecIdentifier;
+				break;
+			case 'D':
+				specifier = SpecDottedName;
+				break;
+			case 's':
+				specifier = SpecString;
+				break;
+			case 'T':
+				specifier = SpecTypename;
+				break;
+			case 'O':
+				specifier = SpecOperatorname;
+				break;
+			default:
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("invalid conversion specifier \"%c\"", *cp)));
+		}
+
+		/*
+		 * Obtain the element to be expanded.  Note we cannot use
+		 * DirectFunctionCall here, because the element might not exist.
+		 */
+		{
+			FunctionCallInfoData fcinfo;
+
+			InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+
+			fcinfo.arg[0] = PointerGetDatum(json);
+			fcinfo.argnull[0] = false;
+			fcinfo.arg[1] = CStringGetTextDatum(param);
+			fcinfo.argnull[1] = false;
+
+			paramval = (*json_object_field) (&fcinfo);
+
+			if (fcinfo.isnull)
+			{
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("non-existant element \"%s\" in JSON formatting object",
+								param)));
+			}
+		}
+
+		/* figure out its type */
+		json_elt_type = jsonval_get_type(paramval, &paramtype);
+
+		/* Validate that we got an array if the format string specified one. */
+		if (is_array && json_elt_type != JsonIsArray)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("expected JSON array for element \"%s\", got %s",
+							param, paramtype)));
+
+		/* And finally print out the data */
+		if (is_array)
+		{
+			int			count;
+			bool		putsep = false;
+			int			i;
+
+			count = DatumGetInt32(DirectFunctionCall1(json_array_length,
+													  paramval));
+			for (i = 0; i < count; i++)
+			{
+				if (putsep)
+					appendStringInfoString(&str, arraysep);
+				putsep = true;
+
+				expand_one_array_element(&str, paramval, i, param, specifier);
+			}
+		}
+		else
+		{
+			expand_one_element(&str, param, paramval, paramtype, json_elt_type,
+							   specifier);
+		}
+	}
+
+	PG_RETURN_TEXT_P(CStringGetTextDatum(str.data));
+}
diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c
index a331f3e..0f0ecbe 100644
--- a/src/backend/commands/matview.c
+++ b/src/backend/commands/matview.c
@@ -132,7 +132,7 @@ SetMatViewPopulatedState(Relation relation, bool newstate)
  * The matview's "populated" state is changed based on whether the contents
  * reflect the result set of the materialized view's query.
  */
-void
+Oid
 ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 				   ParamListInfo params, char *completionTag)
 {
@@ -274,6 +274,8 @@ ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 	}
 	else
 		refresh_by_heap_swap(matviewOid, OIDNewHeap);
+
+	return matviewOid;
 }
 
 /*
diff --git a/src/backend/commands/schemacmds.c b/src/backend/commands/schemacmds.c
index 2599e28..2859ee0 100644
--- a/src/backend/commands/schemacmds.c
+++ b/src/backend/commands/schemacmds.c
@@ -24,6 +24,7 @@
 #include "catalog/objectaccess.h"
 #include "catalog/pg_namespace.h"
 #include "commands/dbcommands.h"
+#include "commands/event_trigger.h"
 #include "commands/schemacmds.h"
 #include "miscadmin.h"
 #include "parser/parse_utilcmd.h"
@@ -130,6 +131,15 @@ CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString)
 	PushOverrideSearchPath(overridePath);
 
 	/*
+	 * Report the new schema to possibly interested event triggers.  Note we
+	 * must do this here and not in ProcessUtilitySlow because otherwise the
+	 * objects created below are reported before the schema, which would be
+	 * wrong.
+	 */
+	EventTriggerStashCreatedObject(namespaceId, OCLASS_SCHEMA,
+								   (Node *) stmt);
+
+	/*
 	 * Examine the list of commands embedded in the CREATE SCHEMA command, and
 	 * reorganize them into a sequentially executable order with no forward
 	 * references.	Note that the result is still a list of raw parsetrees ---
diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index ed696be..564834e 100644
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -1552,7 +1552,42 @@ pg_sequence_parameters(PG_FUNCTION_ARGS)
 	return HeapTupleGetDatum(heap_form_tuple(tupdesc, values, isnull));
 }
 
+/*
+ * Return sequence parameters, detailed
+ */
+Form_pg_sequence
+get_sequence_values(Oid sequenceId)
+{
+	Buffer		buf;
+	SeqTable	elm;
+	Relation	seqrel;
+	HeapTupleData seqtuple;
+	Form_pg_sequence seq;
+	Form_pg_sequence retSeq;
+
+	retSeq = palloc(sizeof(FormData_pg_sequence));
+
+	/* open and AccessShareLock sequence */
+	init_sequence(sequenceId, &elm, &seqrel);
+
+	if (pg_class_aclcheck(sequenceId, GetUserId(),
+						  ACL_SELECT | ACL_UPDATE | ACL_USAGE) != ACLCHECK_OK)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for sequence %s",
+						RelationGetRelationName(seqrel))));
+
+	seq = read_seq_tuple(elm, seqrel, &buf, &seqtuple);
+
+	memcpy(retSeq, seq, sizeof(FormData_pg_sequence));
+
+	UnlockReleaseBuffer(buf);
+	relation_close(seqrel, NoLock);
+
+	return retSeq;
+}
 
+/* definition elements */
 void
 seq_redo(XLogRecPtr lsn, XLogRecord *record)
 {
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 08b037e..a6d38fa 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -43,6 +43,7 @@
 #include "catalog/pg_type_fn.h"
 #include "catalog/storage.h"
 #include "catalog/toasting.h"
+#include "commands/alter_table.h"
 #include "commands/cluster.h"
 #include "commands/comment.h"
 #include "commands/defrem.h"
@@ -112,54 +113,6 @@ typedef struct OnCommitItem
 static List *on_commits = NIL;
 
 
-/*
- * State information for ALTER TABLE
- *
- * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
- * structs, one for each table modified by the operation (the named table
- * plus any child tables that are affected).  We save lists of subcommands
- * to apply to this table (possibly modified by parse transformation steps);
- * these lists will be executed in Phase 2.  If a Phase 3 step is needed,
- * necessary information is stored in the constraints and newvals lists.
- *
- * Phase 2 is divided into multiple passes; subcommands are executed in
- * a pass determined by subcommand type.
- */
-
-#define AT_PASS_UNSET			-1		/* UNSET will cause ERROR */
-#define AT_PASS_DROP			0		/* DROP (all flavors) */
-#define AT_PASS_ALTER_TYPE		1		/* ALTER COLUMN TYPE */
-#define AT_PASS_OLD_INDEX		2		/* re-add existing indexes */
-#define AT_PASS_OLD_CONSTR		3		/* re-add existing constraints */
-#define AT_PASS_COL_ATTRS		4		/* set other column attributes */
-/* We could support a RENAME COLUMN pass here, but not currently used */
-#define AT_PASS_ADD_COL			5		/* ADD COLUMN */
-#define AT_PASS_ADD_INDEX		6		/* ADD indexes */
-#define AT_PASS_ADD_CONSTR		7		/* ADD constraints, defaults */
-#define AT_PASS_MISC			8		/* other stuff */
-#define AT_NUM_PASSES			9
-
-typedef struct AlteredTableInfo
-{
-	/* Information saved before any work commences: */
-	Oid			relid;			/* Relation to work on */
-	char		relkind;		/* Its relkind */
-	TupleDesc	oldDesc;		/* Pre-modification tuple descriptor */
-	/* Information saved by Phase 1 for Phase 2: */
-	List	   *subcmds[AT_NUM_PASSES]; /* Lists of AlterTableCmd */
-	/* Information saved by Phases 1/2 for Phase 3: */
-	List	   *constraints;	/* List of NewConstraint */
-	List	   *newvals;		/* List of NewColumnValue */
-	bool		new_notnull;	/* T if we added new NOT NULL constraints */
-	bool		rewrite;		/* T if a rewrite is forced */
-	Oid			newTableSpace;	/* new tablespace; 0 means no change */
-	/* Objects to rebuild after completing ALTER TYPE operations */
-	List	   *changedConstraintOids;	/* OIDs of constraints to rebuild */
-	List	   *changedConstraintDefs;	/* string definitions of same */
-	List	   *changedIndexOids;		/* OIDs of indexes to rebuild */
-	List	   *changedIndexDefs;		/* string definitions of same */
-} AlteredTableInfo;
-
 /* Struct describing one new constraint to check in Phase 3 scan */
 /* Note: new NOT NULL constraints are handled elsewhere */
 typedef struct NewConstraint
@@ -7762,7 +7715,8 @@ ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
 				if (!list_member_oid(tab->changedConstraintOids,
 									 foundObject.objectId))
 				{
-					char	   *defstring = pg_get_constraintdef_string(foundObject.objectId);
+					char	   *defstring = pg_get_constraintdef_string(foundObject.objectId,
+																		true);
 
 					/*
 					 * Put NORMAL dependencies at the front of the list and
diff --git a/src/backend/tcop/Makefile b/src/backend/tcop/Makefile
index 674302f..34acdce 100644
--- a/src/backend/tcop/Makefile
+++ b/src/backend/tcop/Makefile
@@ -12,7 +12,7 @@ subdir = src/backend/tcop
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS= dest.o fastpath.o postgres.o pquery.o utility.o
+OBJS= dest.o deparse_utility.o fastpath.o postgres.o pquery.o utility.o
 
 ifneq (,$(filter $(PORTNAME),cygwin win32))
 override CPPFLAGS += -DWIN32_STACK_RLIMIT=$(WIN32_STACK_RLIMIT)
diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
new file mode 100644
index 0000000..98b3711
--- /dev/null
+++ b/src/backend/tcop/deparse_utility.c
@@ -0,0 +1,1488 @@
+/*-------------------------------------------------------------------------
+ *
+ * deparse_utility.c
+ *	  Functions to convert utility commands to machine-parseable
+ *	  representation
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * NOTES
+ *
+ * This is intended to provide JSON blobs representing DDL commands, which can
+ * later be re-processed into plain strings by well-defined sprintf-like
+ * expansion.  These JSON objects are intended to allow for machine-editing of
+ * the commands, by replacing certain nodes within the objects.
+ *
+ * Much of the information in the output blob actually comes from system
+ * catalogs, not from the command parse node, as it is impossible to reliably
+ * construct a fully-specified command (i.e. one not dependent on search_path
+ * etc) looking only at the parse node.
+ *
+ * IDENTIFICATION
+ *	  src/backend/tcop/deparse_utility.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "catalog/heap.h"
+#include "catalog/index.h"
+#include "catalog/namespace.h"
+#include "catalog/pg_aggregate.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_constraint.h"
+#include "catalog/pg_depend.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_operator.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_type.h"
+#include "commands/defrem.h"
+#include "commands/sequence.h"
+#include "funcapi.h"
+#include "lib/ilist.h"
+#include "lib/stringinfo.h"
+#include "nodes/makefuncs.h"
+#include "nodes/parsenodes.h"
+#include "parser/analyze.h"
+#include "parser/parse_collate.h"
+#include "parser/parse_expr.h"
+#include "parser/parse_relation.h"
+#include "parser/parse_type.h"
+#include "rewrite/rewriteHandler.h"
+#include "tcop/deparse_utility.h"
+#include "utils/builtins.h"
+#include "utils/fmgroids.h"
+#include "utils/json.h"
+#include "utils/lsyscache.h"
+#include "utils/memutils.h"
+#include "utils/rel.h"
+#include "utils/syscache.h"
+
+
+typedef enum
+{
+	ObjTypeNull,
+	ObjTypeBool,
+	ObjTypeString,
+	ObjTypeArray,
+	ObjTypeObject
+} ObjType;
+
+typedef struct ObjElem
+{
+	char	   *name;
+	ObjType		objtype;
+	bool		bool_value;
+	char	   *str_value;
+	struct ObjTree *obj_value;
+	List	   *array_value;
+	slist_node	node;
+} ObjElem;
+
+typedef struct ObjTree
+{
+	MemoryContext cxt;
+	slist_head	params;
+	int			numParams;
+} ObjTree;
+
+
+static void append_null_object(ObjTree *tree, char *name);
+static void append_bool_object(ObjTree *tree, char *name,
+				   bool value);
+static void append_string_object(ObjTree *tree, char *name,
+					 char *value);
+static void append_object_object(ObjTree *tree, char *name,
+					 ObjTree *value);
+static void append_array_object(ObjTree *tree, char *name,
+					List *array);
+
+/*
+ * Allocate a new object tree to store parameter values.  If parent is NULL, a
+ * new memory context is created for all allocations involving the parameters;
+ * if it's not null, then the memory context from the given object is used.
+ */
+static ObjTree *
+new_objtree(ObjTree *parent)
+{
+	MemoryContext cxt;
+	ObjTree    *params;
+
+	if (parent == NULL)
+	{
+		cxt = AllocSetContextCreate(CurrentMemoryContext,
+									"deparse parameters",
+									ALLOCSET_DEFAULT_MINSIZE,
+									ALLOCSET_DEFAULT_INITSIZE,
+									ALLOCSET_DEFAULT_MAXSIZE);
+	}
+	else
+		cxt = parent->cxt;
+
+	params = MemoryContextAlloc(cxt, sizeof(ObjTree));
+	params->cxt = cxt;
+	params->numParams = 0;
+	slist_init(&params->params);
+
+	return params;
+}
+
+/*
+ * Allocate a new object to store parameters.  As above, if parent is NULL,
+ * a new memory context is created; otherwise the parent is used to extract
+ * the memory context to use.
+ *
+ * The "fmt" argument is used to append as a "fmt" element in the output blob.
+ * numobjs indicates the number of extra elements to append; for each one,
+ * a name, type and value must be supplied.  Note we don't have the luxury of
+ * sprintf-like compiler warnings for malformed argument lists.
+ */
+static ObjTree *
+new_objtree_VA(ObjTree *parent, char *fmt, int numobjs,...)
+{
+	ObjTree    *tree;
+	va_list		args;
+	int			i;
+
+	/* Set up the toplevel object and its "fmt" */
+	tree = new_objtree(parent);
+	append_string_object(tree, "fmt", fmt);
+
+	/* And process the given varargs */
+	va_start(args, numobjs);
+	for (i = 0; i < numobjs; i++)
+	{
+		ObjTree    *value;
+		ObjType		type;
+		char	   *name;
+		char	   *strval;
+		bool		boolval;
+		List	   *list;
+
+		name = va_arg(args, char *);
+		type = va_arg(args, ObjType);
+
+		/* Null params don't have a value (obviously) */
+		if (type == ObjTypeNull)
+		{
+			append_null_object(tree, name);
+			continue;
+		}
+
+		/*
+		 * For all other param types there must be a value in the varargs.
+		 * Fetch it and add the fully formed subobject into the main object.
+		 */
+		switch (type)
+		{
+			case ObjTypeBool:
+				boolval = va_arg(args, int);
+				append_bool_object(tree, name, boolval);
+				break;
+			case ObjTypeString:
+				strval = va_arg(args, char *);
+				append_string_object(tree, name, strval);
+				break;
+			case ObjTypeObject:
+				value = va_arg(args, ObjTree *);
+				append_object_object(tree, name, value);
+				break;
+			case ObjTypeArray:
+				list = va_arg(args, List *);
+				append_array_object(tree, name, list);
+				break;
+			default:
+				elog(ERROR, "invalid parameter type %d", type);
+		}
+	}
+
+	va_end(args);
+	return tree;
+}
+
+/*
+ * Add a new parameter with a NULL value
+ */
+static void
+append_null_object(ObjTree *tree, char *name)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeNull;
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Add a new boolean parameter
+ */
+static void
+append_bool_object(ObjTree *tree, char *name, bool value)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeBool;
+	param->bool_value = value;
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Add a new string parameter.
+ *
+ * Note: we don't pstrdup the source string.  Caller must ensure the
+ * source string lives long enough.
+ */
+static void
+append_string_object(ObjTree *tree, char *name, char *value)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeString;
+	param->str_value = value;	/* XXX not duped */
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Add a new object parameter
+ */
+static void
+append_object_object(ObjTree *tree, char *name, ObjTree *value)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeObject;
+	param->obj_value = value;	/* XXX not duped */
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Add a new array parameter
+ */
+static void
+append_array_object(ObjTree *tree, char *name, List *array)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeArray;
+	param->array_value = array; /* XXX not duped */
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Create a JSON blob from our ad-hoc representation.
+ *
+ * Note this allocates memory in tree->cxt.  This is okay because we don't need
+ * a separate memory context, and the one provided by the tree object has the
+ * right lifetime already.
+ *
+ * XXX this implementation will fail if there are more JSON objects in the tree
+ * than the maximum number of columns in a heap tuple.
+ */
+static char *
+jsonize_objtree(ObjTree *tree)
+{
+	MemoryContext oldcxt;
+	TupleDesc	tupdesc;
+	Datum	   *values;
+	bool	   *nulls;
+	slist_iter	iter;
+	int			i;
+	HeapTuple	htup;
+	Datum		json;
+	char	   *jsonstr;
+
+	/*
+	 * Use the objtree's memory context, so that everything we allocate in
+	 * this routine (other than our return string) can be blown up easily
+	 * by our caller.
+	 */
+	oldcxt = MemoryContextSwitchTo(tree->cxt);
+	tupdesc = CreateTemplateTupleDesc(tree->numParams, false);
+	values = palloc(sizeof(Datum) * tree->numParams);
+	nulls = palloc(sizeof(bool) * tree->numParams);
+
+	i = 1;
+	slist_foreach(iter, &tree->params)
+	{
+		ObjElem    *object = slist_container(ObjElem, node, iter.cur);
+		Oid			typeid;
+
+		switch (object->objtype)
+		{
+			case ObjTypeNull:
+			case ObjTypeString:
+				typeid = TEXTOID;
+				break;
+			case ObjTypeBool:
+				typeid = BOOLOID;
+				break;
+			case ObjTypeArray:
+			case ObjTypeObject:
+				typeid = JSONOID;
+				break;
+			default:
+				elog(ERROR, "unable to determine type id");
+				typeid = InvalidOid;
+		}
+
+		TupleDescInitEntry(tupdesc, i, object->name, typeid, -1, 0);
+
+		nulls[i - 1] = false;
+		switch (object->objtype)
+		{
+			case ObjTypeNull:
+				nulls[i - 1] = true;
+				break;
+			case ObjTypeBool:
+				values[i - 1] = BoolGetDatum(object->bool_value);
+				break;
+			case ObjTypeString:
+				values[i - 1] = CStringGetTextDatum(object->str_value);
+				break;
+			case ObjTypeArray:
+				{
+					ArrayType  *arrayt;
+					Datum	   *arrvals;
+					Datum		jsonary;
+					ListCell   *cell;
+					int			length = list_length(object->array_value);
+					int			j;
+
+					/*
+					 * Arrays are stored as Lists up to this point, with each
+					 * element being a ObjElem; we need to construct an
+					 * ArrayType with them to turn the whole thing into a JSON
+					 * array.
+					 */
+					j = 0;
+					arrvals = palloc(sizeof(Datum) * length);
+					foreach(cell, object->array_value)
+					{
+						ObjTree    *json = lfirst(cell);
+
+						arrvals[j++] =
+							CStringGetTextDatum(jsonize_objtree(json));
+					}
+					arrayt = construct_array(arrvals, length,
+											 JSONOID, -1, false, 'i');
+
+					jsonary = DirectFunctionCall1(array_to_json,
+												  (PointerGetDatum(arrayt)));
+
+					values[i - 1] = jsonary;
+				}
+				break;
+			case ObjTypeObject:
+				values[i - 1] =
+					CStringGetTextDatum(jsonize_objtree(object->obj_value));
+				break;
+		}
+
+		i++;
+	}
+
+	BlessTupleDesc(tupdesc);
+	htup = heap_form_tuple(tupdesc, values, nulls);
+	json = DirectFunctionCall1(row_to_json, HeapTupleGetDatum(htup));
+
+	/* switch to caller's context so that our output is allocated there */
+	MemoryContextSwitchTo(oldcxt);
+
+	jsonstr = TextDatumGetCString(json);
+
+	return jsonstr;
+}
+
+/*
+ * Release all memory used by parameters and their expansion
+ */
+static void
+free_objtree(ObjTree *tree)
+{
+	MemoryContextDelete(tree->cxt);
+}
+
+/*
+ * A helper routine to setup %{}T elements.
+ */
+static ObjTree *
+new_objtree_for_type(ObjTree *parent, Oid typeId, int32 typmod)
+{
+	ObjTree    *typeParam;
+	char	   *typnsp;
+	char	   *typename;
+	char	   *typmodstr;
+	bool		is_array;
+
+	format_type_detailed(typeId, typmod,
+						 &typnsp, &typename, &typmodstr, &is_array);
+
+	/* We don't use new_objtree_VA here because types don't have a "fmt" */
+	typeParam = new_objtree(parent);
+	append_string_object(typeParam, "schemaname", typnsp);
+	append_string_object(typeParam, "typename", typename);
+	append_string_object(typeParam, "typmod", typmodstr);
+	append_bool_object(typeParam, "is_array", is_array);
+
+	return typeParam;
+}
+
+/*
+ * A helper routine to setup %{}D and %{}O elements
+ *
+ * The difference between those two element types is whether the objname will
+ * be quoted as an identifier or not, which is not something that this routine
+ * concerns itself with; that will be up to the expand function.
+ */
+static ObjTree *
+new_objtree_for_qualname(ObjTree *parent, Oid nspid, char *name)
+{
+	ObjTree    *qualified;
+	char	   *namespace;
+
+	/*
+	 * We don't use new_objtree_VA here because these names don't have a "fmt"
+	 */
+	qualified = new_objtree(parent);
+	namespace = get_namespace_name(nspid);
+	append_string_object(qualified, "schemaname", namespace);
+	append_string_object(qualified, "objname", pstrdup(name));
+
+	return qualified;
+}
+
+/*
+ * A helper routine to setup %{}D and %{}O elements, with the object specified
+ * by classId/objId
+ */
+static ObjTree *
+new_objtree_for_qualname_id(ObjTree *parent, Oid classId, Oid objectId)
+{
+	ObjTree    *qualified;
+	Relation	catalog;
+	HeapTuple	catobj;
+	Datum		objnsp;
+	Datum		objname;
+	AttrNumber	Anum_name;
+	AttrNumber	Anum_namespace;
+	bool		isnull;
+
+	catalog = heap_open(classId, AccessShareLock);
+
+	catobj = get_catalog_object_by_oid(catalog, objectId);
+	if (!catobj)
+		elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
+			 objectId, RelationGetRelationName(catalog));
+	Anum_name = get_object_attnum_name(classId);
+	Anum_namespace = get_object_attnum_namespace(classId);
+
+	objnsp = heap_getattr(catobj, Anum_namespace, RelationGetDescr(catalog),
+						  &isnull);
+	if (isnull)
+		elog(ERROR, "unexpected NULL namespace");
+	objname = heap_getattr(catobj, Anum_name, RelationGetDescr(catalog),
+						   &isnull);
+	if (isnull)
+		elog(ERROR, "unexpected NULL name");
+
+	qualified = new_objtree_for_qualname(parent,
+										 DatumGetObjectId(objnsp),
+										 NameStr(*DatumGetName(objname)));
+
+	pfree(catobj);
+	heap_close(catalog, AccessShareLock);
+
+	return qualified;
+}
+
+/*
+ * Return the string representation of the given RELPERSISTENCE value
+ */
+static char *
+get_persistence_str(char persistence)
+{
+	switch (persistence)
+	{
+		case RELPERSISTENCE_TEMP:
+			return "TEMPORARY";
+		case RELPERSISTENCE_UNLOGGED:
+			return "UNLOGGED";
+		case RELPERSISTENCE_PERMANENT:
+			return "";
+		default:
+			return "???";
+	}
+}
+
+/*
+ * deparse_ViewStmt
+ *		deparse a ViewStmt
+ *
+ * Given a view OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ */
+static char *
+deparse_ViewStmt(Oid objectId, Node *parsetree)
+{
+	ObjTree    *viewStmt;
+	ObjTree    *tmp;
+	char	   *command;
+	Relation	relation;
+	OverrideSearchPath *overridePath;
+
+	relation = relation_open(objectId, AccessShareLock);
+
+	viewStmt = new_objtree_VA(NULL,
+					 "CREATE %{persistence}s VIEW %{identity}D AS %{query}s",
+							  1, "persistence", ObjTypeString,
+					  get_persistence_str(relation->rd_rel->relpersistence));
+
+	tmp = new_objtree_for_qualname(viewStmt,
+								   relation->rd_rel->relnamespace,
+								   RelationGetRelationName(relation));
+	append_object_object(viewStmt, "identity", tmp);
+
+	/*
+	 * We want all names to be qualified, so set an empty search path before
+	 * calling ruleutils.c.
+	 */
+	overridePath = GetOverrideSearchPath(CurrentMemoryContext);
+	overridePath->schemas = NIL;
+	PushOverrideSearchPath(overridePath);
+
+	append_string_object(viewStmt, "query",
+						 pg_get_viewdef_internal(objectId));
+	PopOverrideSearchPath();
+
+	command = jsonize_objtree(viewStmt);
+	free_objtree(viewStmt);
+
+	relation_close(relation, AccessShareLock);
+
+	return command;
+}
+
+
+/* ruleutils.c */
+extern char *relation_get_column_default(Relation rel, AttrNumber attno,
+							List *dpcontext);
+
+/*
+ * deparse_ColumnDef
+ *		Subroutine for CREATE TABLE deparsing
+ *
+ * Deparse a ColumnDef node within a regular (non typed) table creation.
+ *
+ * NOT NULL constraints in the column definition are emitted directly in the
+ * column definition by this routine; other constraints must be emitted
+ * elsewhere (the info in the parse node is incomplete anyway.)
+ */
+static ObjTree *
+deparse_ColumnDef(ObjTree *parent, Relation relation, List *dpcontext,
+				  ColumnDef *coldef)
+{
+	ObjTree    *column;
+	ObjTree    *tmp;
+	Oid			relid = RelationGetRelid(relation);
+	HeapTuple	attrTup;
+	Form_pg_attribute attrForm;
+	Oid			typid;
+	int32		typmod;
+	Oid			typcollation;
+	bool		saw_notnull;
+	ListCell   *cell;
+
+	/*
+	 * Inherited columns without local definitions must not be emitted. XXX --
+	 * maybe it is useful to have them with "present = false" or some such?
+	 */
+	if (!coldef->is_local)
+		return NULL;
+
+	attrTup = SearchSysCacheAttName(relid, coldef->colname);
+	if (!HeapTupleIsValid(attrTup))
+		elog(ERROR, "could not find cache entry for column \"%s\" of relation %u",
+			 coldef->colname, relid);
+	attrForm = (Form_pg_attribute) GETSTRUCT(attrTup);
+
+	get_atttypetypmodcoll(relid, attrForm->attnum,
+						  &typid, &typmod, &typcollation);
+
+	column = new_objtree_VA(parent,
+							"%{name}I %{coltype}T %{default}s %{not_null}s %{collation}s",
+							3,
+							"type", ObjTypeString, "column",
+							"name", ObjTypeString, coldef->colname,
+							"coltype", ObjTypeObject,
+							new_objtree_for_type(parent, typid, typmod));
+
+	tmp = new_objtree_VA(parent, "COLLATE %{name}I", 0);
+	if (OidIsValid(typcollation))
+	{
+		char	   *collname;
+
+		collname = get_collation_name(attrForm->attcollation);
+		append_string_object(tmp, "name", collname);
+	}
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(column, "collation", tmp);
+
+	/*
+	 * Emit a NOT NULL declaration if necessary.  Note that we cannot trust
+	 * pg_attribute.attnotnull here, because that bit is also set when primary
+	 * keys are specified; and we must not emit a NOT NULL constraint in that
+	 * case, unless explicitely specified; so we scan the list of constraints
+	 * attached to this column.  (Fortunately, NOT NULL constraints cannot be
+	 * table constraints.)
+	 */
+	saw_notnull = false;
+	foreach(cell, coldef->constraints)
+	{
+		Constraint *constr = (Constraint *) lfirst(cell);
+
+		if (constr->contype == CONSTR_NOTNULL)
+			saw_notnull = true;
+	}
+
+	if (saw_notnull)
+		append_string_object(column, "not_null", "NOT NULL");
+	else
+		append_string_object(column, "not_null", "");
+
+	tmp = new_objtree_VA(parent, "DEFAULT %{default}s", 0);
+	if (attrForm->atthasdef)
+	{
+		char *defstr;
+
+		defstr = relation_get_column_default(relation, attrForm->attnum,
+											 dpcontext);
+
+		append_string_object(tmp, "default", defstr);
+	}
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(column, "default", tmp);
+
+	ReleaseSysCache(attrTup);
+
+	return column;
+}
+
+/*
+ * deparse_ColumnDef_Typed
+ *		Subroutine for CREATE TABLE OF deparsing
+ *
+ * Deparse a ColumnDef node within a typed table creation.	This is simpler
+ * than the regular case, because we don't have to emit the type declaration,
+ * collation, or default.  Here we only return something if the column is being
+ * declared NOT NULL.
+ *
+ * As in deparse_ColumnDef, any other constraint is processed elsewhere.
+ *
+ * FIXME --- actually, what about default values?
+ */
+static ObjTree *
+deparse_ColumnDef_typed(ObjTree *parent, Relation relation, List *dpcontext,
+						ColumnDef *coldef)
+{
+	ObjTree    *column = NULL;
+	Oid			relid = RelationGetRelid(relation);
+	HeapTuple	attrTup;
+	Form_pg_attribute attrForm;
+	Oid			typid;
+	int32		typmod;
+	Oid			typcollation;
+	bool		saw_notnull;
+	ListCell   *cell;
+
+	attrTup = SearchSysCacheAttName(relid, coldef->colname);
+	if (!HeapTupleIsValid(attrTup))
+		elog(ERROR, "could not find cache entry for column \"%s\" of relation %u",
+			 coldef->colname, relid);
+	attrForm = (Form_pg_attribute) GETSTRUCT(attrTup);
+
+	get_atttypetypmodcoll(relid, attrForm->attnum,
+						  &typid, &typmod, &typcollation);
+
+	/*
+	 * Search for a NOT NULL declaration.  As in deparse_ColumnDef, we rely on
+	 * finding a constraint on the column rather than coldef->is_not_null.
+	 */
+	saw_notnull = false;
+	foreach(cell, coldef->constraints)
+	{
+		Constraint *constr = (Constraint *) lfirst(cell);
+
+		if (constr->contype == CONSTR_NOTNULL)
+		{
+			saw_notnull = true;
+			break;
+		}
+	}
+
+	if (saw_notnull)
+		column = new_objtree_VA(parent,
+								"%{name}I WITH OPTIONS NOT NULL", 2,
+								"type", ObjTypeString, "column_notnull",
+								"name", ObjTypeString, coldef->colname);
+
+	ReleaseSysCache(attrTup);
+	return column;
+}
+
+/*
+ * deparseTableElements
+ *		Subroutine for CREATE TABLE deparsing
+ *
+ * Deal with all the table elements (columns and constraints).
+ *
+ * Note we ignore constraints in the parse node here; they are extracted from
+ * system catalogs instead.
+ */
+static List *
+deparseTableElements(List *elements, ObjTree *parent, Relation relation,
+					 List *tableElements, List *dpcontext, bool typed)
+{
+	ListCell   *lc;
+
+	foreach(lc, tableElements)
+	{
+		Node	   *elt = (Node *) lfirst(lc);
+
+		switch (nodeTag(elt))
+		{
+			case T_ColumnDef:
+				{
+					ObjTree    *column;
+
+					column = typed ?
+						deparse_ColumnDef_typed(parent, relation, dpcontext,
+												(ColumnDef *) elt) :
+						deparse_ColumnDef(parent, relation, dpcontext,
+										  (ColumnDef *) elt);
+
+					if (column != NULL)
+						elements = lappend(elements, column);
+				}
+				break;
+			case T_Constraint:
+				break;
+			default:
+				elog(ERROR, "invalid node type %d", nodeTag(elt));
+		}
+	}
+
+	return elements;
+}
+
+/*
+ * obtainTableConstraints
+ *		Subroutine for CREATE TABLE deparsing
+ *
+ * Given a table OID, obtain its constraints and append them to the given
+ * elements list.  The updated list is returned.
+ *
+ * This works for both typed and regular tables.
+ */
+static List *
+obtainTableConstraints(List *elements, Oid objectId, ObjTree *parent)
+{
+	Relation	conRel;
+	ScanKeyData key;
+	SysScanDesc scan;
+	HeapTuple	tuple;
+	ObjTree    *tmp;
+	OverrideSearchPath *overridePath;
+
+	/*
+	 * scan pg_constraint to fetch all constraints linked to the given
+	 * relation.
+	 */
+	conRel = heap_open(ConstraintRelationId, AccessShareLock);
+	ScanKeyInit(&key,
+				Anum_pg_constraint_conrelid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(objectId));
+	scan = systable_beginscan(conRel, ConstraintRelidIndexId,
+							  true, NULL, 1, &key);
+
+	/*
+	 * We need to ensure all names in the constraint definitions are
+	 * qualified, so set an empty search_path for the duration of this loop.
+	 */
+	overridePath = GetOverrideSearchPath(CurrentMemoryContext);
+	overridePath->schemas = NIL;
+	PushOverrideSearchPath(overridePath);
+
+	/*
+	 * For each constraint, add a node to the list of table elements.  In
+	 * these nodes we include not only the printable information ("fmt"), but
+	 * also separate attributes to indicate the type of constraint, for
+	 * automatic processing.
+	 */
+	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+	{
+		Form_pg_constraint constrForm;
+		char	   *contype;
+
+		constrForm = (Form_pg_constraint) GETSTRUCT(tuple);
+
+		switch (constrForm->contype)
+		{
+			case CONSTRAINT_CHECK:
+				contype = "check";
+				break;
+			case CONSTRAINT_FOREIGN:
+				contype = "foreign key";
+				break;
+			case CONSTRAINT_PRIMARY:
+				contype = "primary key";
+				break;
+			case CONSTRAINT_UNIQUE:
+				contype = "unique";
+				break;
+			case CONSTRAINT_TRIGGER:
+				contype = "trigger";
+				break;
+			case CONSTRAINT_EXCLUSION:
+				contype = "exclusion";
+				break;
+			default:
+				elog(ERROR, "unrecognized constraint type");
+		}
+
+		/*
+		 * "type" and "contype" are not part of the printable output, but are
+		 * useful to programmatically distinguish these from columns and among
+		 * different constraint types.
+		 *
+		 * XXX it might be useful to also list the column names in a PK, etc.
+		 */
+		tmp = new_objtree_VA(parent,
+							 "CONSTRAINT %{name}I %{definition}s",
+							 4,
+							 "type", ObjTypeString, "constraint",
+							 "contype", ObjTypeString, contype,
+						 "name", ObjTypeString, NameStr(constrForm->conname),
+							 "definition", ObjTypeString,
+						  pg_get_constraintdef_string(HeapTupleGetOid(tuple),
+													  false));
+		elements = lappend(elements, tmp);
+	}
+
+	PopOverrideSearchPath();
+
+	systable_endscan(scan);
+	heap_close(conRel, AccessShareLock);
+
+	return elements;
+}
+
+/*
+ * deparse_CreateStmt
+ *		Deparse a CreateStmt (CREATE TABLE)
+ *
+ * Given a table OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ */
+static char *
+deparse_CreateStmt(Oid objectId, Node *parsetree)
+{
+	CreateStmt *node = (CreateStmt *) parsetree;
+	Relation	relation = relation_open(objectId, AccessShareLock);
+	List	   *dpcontext;
+	ObjTree    *createStmt;
+	ObjTree    *tmp;
+	char	   *command;
+	char	   *fmtstr;
+
+	/*
+	 * Typed tables use a slightly different format string: we must not put
+	 * table_elements with parents directly in the fmt string, because if
+	 * there are no options the parens must not be emitted; and also, typed
+	 * tables do not allow for inheritance.
+	 */
+	if (node->ofTypename)
+		fmtstr = "CREATE %{persistence}s TABLE %{identity}D %{if_not_exists}s "
+			"OF %{of_type}T %{table_elements}s "
+			"%{on_commit}s %{tablespace}s";
+	else
+		fmtstr = "CREATE %{persistence}s TABLE %{identity}D %{if_not_exists}s "
+			"(%{table_elements:, }s) %{inherits}s "
+			"%{on_commit}s %{tablespace}s";
+
+	createStmt =
+		new_objtree_VA(NULL, fmtstr, 1,
+					   "persistence", ObjTypeString,
+					   get_persistence_str(relation->rd_rel->relpersistence));
+
+	tmp = new_objtree_for_qualname(createStmt,
+								   relation->rd_rel->relnamespace,
+								   RelationGetRelationName(relation));
+	append_object_object(createStmt, "identity", tmp);
+
+	append_string_object(createStmt, "if_not_exists",
+						 node->if_not_exists ? "IF NOT EXISTS" : "");
+
+	dpcontext = deparse_context_for(RelationGetRelationName(relation),
+								  objectId);
+
+	if (node->ofTypename)
+	{
+		List	   *tableelts = NIL;
+
+		/*
+		 * We can't put table elements directly in the fmt string as an array
+		 * surrounded by parens here, because an empty clause would cause a
+		 * syntax error.  Therefore, we use an indirection element and set
+		 * present=false when there are no elements.
+		 */
+		append_string_object(createStmt, "table_kind", "typed");
+
+		tmp = new_objtree_for_type(createStmt, relation->rd_rel->reloftype, -1);
+		append_object_object(createStmt, "of_type", tmp);
+
+		tableelts = deparseTableElements(NIL, createStmt, relation,
+										 node->tableElts, dpcontext, true);
+		tableelts = obtainTableConstraints(tableelts, objectId, createStmt);
+		if (tableelts == NIL)
+			tmp = new_objtree_VA(createStmt, "", 1,
+								 "present", ObjTypeBool, false);
+		else
+			tmp = new_objtree_VA(createStmt, "(%{elements:, }s)", 1,
+								 "elements", ObjTypeArray, tableelts);
+		append_object_object(createStmt, "table_elements", tmp);
+	}
+	else
+	{
+		List	   *tableelts = NIL;
+
+		/*
+		 * There is no need to process LIKE clauses separately; they have
+		 * already been transformed into columns and constraints.
+		 */
+		append_string_object(createStmt, "table_kind", "plain");
+
+		/*
+		 * Process table elements: column definitions and constraints.	Only
+		 * the column definitions are obtained from the parse node itself.	To
+		 * get constraints we rely on pg_constraint, because the parse node
+		 * might be missing some things such as the name of the constraints.
+		 */
+		tableelts = deparseTableElements(NIL, createStmt, relation,
+										 node->tableElts, dpcontext, false);
+		tableelts = obtainTableConstraints(tableelts, objectId, createStmt);
+
+		append_array_object(createStmt, "table_elements", tableelts);
+
+		/*
+		 * Add inheritance specification.  We cannot simply scan the list of
+		 * parents from the parser node, because that may lack the actual
+		 * qualified names of the parent relations.  Rather than trying to
+		 * re-resolve them from the information in the parse node, it seems
+		 * more accurate and convenient to grab it from pg_inherits.
+		 */
+		tmp = new_objtree_VA(createStmt, "INHERITS (%{parents:, }D)", 0);
+		if (list_length(node->inhRelations) > 0)
+		{
+			List	   *parents = NIL;
+			Relation	inhRel;
+			SysScanDesc scan;
+			ScanKeyData key;
+			HeapTuple	tuple;
+
+			inhRel = heap_open(InheritsRelationId, RowExclusiveLock);
+
+			ScanKeyInit(&key,
+						Anum_pg_inherits_inhrelid,
+						BTEqualStrategyNumber, F_OIDEQ,
+						ObjectIdGetDatum(objectId));
+
+			scan = systable_beginscan(inhRel, InheritsRelidSeqnoIndexId,
+									  true, NULL, 1, &key);
+
+			while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+			{
+				ObjTree    *parent;
+				Form_pg_inherits formInh = (Form_pg_inherits) GETSTRUCT(tuple);
+
+				parent = new_objtree_for_qualname_id(createStmt,
+													 RelationRelationId,
+													 formInh->inhparent);
+
+				parents = lappend(parents, parent);
+			}
+
+			systable_endscan(scan);
+			heap_close(inhRel, RowExclusiveLock);
+
+			append_array_object(tmp, "parents", parents);
+		}
+		else
+		{
+			append_null_object(tmp, "parents");
+			append_bool_object(tmp, "present", false);
+		}
+		append_object_object(createStmt, "inherits", tmp);
+	}
+
+	tmp = new_objtree_VA(createStmt, "TABLESPACE %{tablespace}I", 0);
+	if (node->tablespacename)
+		append_string_object(tmp, "tablespace", node->tablespacename);
+	else
+	{
+		append_null_object(tmp, "tablespace");
+		append_bool_object(tmp, "present", false);
+	}
+	append_object_object(createStmt, "tablespace", tmp);
+
+	tmp = new_objtree_VA(createStmt, "ON COMMIT %{on_commit_value}s", 0);
+	switch (node->oncommit)
+	{
+		case ONCOMMIT_DROP:
+			append_string_object(tmp, "on_commit_value", "DROP");
+			break;
+
+		case ONCOMMIT_DELETE_ROWS:
+			append_string_object(tmp, "on_commit_value", "DELETE ROWS");
+			break;
+
+		case ONCOMMIT_PRESERVE_ROWS:
+			append_string_object(tmp, "on_commit_value", "PRESERVE ROWS");
+			break;
+
+		case ONCOMMIT_NOOP:
+			append_null_object(tmp, "on_commit_value");
+			append_bool_object(tmp, "present", false);
+			break;
+	}
+	append_object_object(createStmt, "on_commit", tmp);
+
+	command = jsonize_objtree(createStmt);
+
+	free_objtree(createStmt);
+	relation_close(relation, AccessShareLock);
+
+	return command;
+}
+
+/*
+ * get_sequence_ownedby
+ *		Subroutine for CREATE SEQUENCE deparsing
+ *
+ * Given a sequence OID, obtain its owning column and return it as a
+ * fully-formed OWNED BY ObjTree.  If there's no owning column, an ObjTree is
+ * still returned, but it has the "present" element set to false.
+ */
+static ObjTree *
+get_sequence_ownedby(ObjTree *parent, Oid objectId)
+{
+	ObjTree    *ownedby = NULL;
+	Relation	depRel;
+	SysScanDesc scan;
+	ScanKeyData keys[3];
+	HeapTuple	tuple;
+
+	depRel = heap_open(DependRelationId, AccessShareLock);
+	ScanKeyInit(&keys[0],
+				Anum_pg_depend_classid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(RelationRelationId));
+	ScanKeyInit(&keys[1],
+				Anum_pg_depend_objid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(objectId));
+	ScanKeyInit(&keys[2],
+				Anum_pg_depend_objsubid,
+				BTEqualStrategyNumber, F_INT4EQ,
+				Int32GetDatum(0));
+
+	scan = systable_beginscan(depRel, DependDependerIndexId, true,
+							  NULL, 3, keys);
+	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+	{
+		Oid			ownerId;
+		Form_pg_depend depform;
+		ObjTree    *tmp;
+		char	   *colname;
+
+		depform = (Form_pg_depend) GETSTRUCT(tuple);
+
+		/* only consider AUTO dependencies on pg_class */
+		if (depform->deptype != DEPENDENCY_AUTO)
+			continue;
+		if (depform->refclassid != RelationRelationId)
+			continue;
+		if (depform->refobjsubid <= 0)
+			continue;
+
+		ownerId = depform->refobjid;
+		colname = get_attname(ownerId, depform->refobjsubid);
+		if (colname == NULL)
+			continue;
+
+		tmp = new_objtree_for_qualname_id(parent, RelationRelationId, ownerId);
+		append_string_object(tmp, "attrname", colname);
+		ownedby = new_objtree_VA(parent,
+								 "OWNED BY %{owner}D",
+								 2,
+								 "clause", ObjTypeString, "owned",
+								 "owner", ObjTypeObject, tmp);
+	}
+
+	systable_endscan(scan);
+	relation_close(depRel, AccessShareLock);
+
+	/*
+	 * If there's no owner column, emit an empty OWNED BY element, set up so
+	 * that it won't print anything.
+	 */
+	if (!ownedby)
+		ownedby = new_objtree_VA(parent,
+								 "OWNED BY %{owner}D",
+								 3,
+								 "clause", ObjTypeString, "owned",
+								 "owner", ObjTypeNull,
+								 "present", ObjTypeBool, false);
+
+	return ownedby;
+}
+
+/*
+ * deparse_CreateSeqStmt
+ *		deparse a CreateSeqStmt
+ *
+ * Given a sequence OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ */
+static char *
+deparse_CreateSeqStmt(Oid objectId, Node *parsetree)
+{
+	ObjTree    *createSeqStmt;
+	ObjTree    *tmp;
+	Relation	relation = relation_open(objectId, AccessShareLock);
+	char	   *command;
+	Form_pg_sequence seqdata;
+	char	   *tmpstr;
+	List	   *elems = NIL;
+
+	seqdata = get_sequence_values(objectId);
+
+	createSeqStmt =
+		new_objtree_VA(NULL,
+					   "CREATE %{persistence}s SEQUENCE %{identity}D "
+					   "%{definition: }s",
+					   1,
+					   "persistence", ObjTypeString,
+					   get_persistence_str(relation->rd_rel->relpersistence));
+
+	tmp = new_objtree_for_qualname(createSeqStmt,
+								   relation->rd_rel->relnamespace,
+								   RelationGetRelationName(relation));
+	append_object_object(createSeqStmt, "identity", tmp);
+
+	/* definition elements */
+	tmpstr = psprintf("%lu", seqdata->increment_by);
+	tmp = new_objtree_VA(createSeqStmt, "INCREMENT BY %{value}s",
+						 2,
+						 "clause", ObjTypeString, "increment_by",
+						 "value", ObjTypeString, tmpstr);
+	elems = lappend(elems, tmp);
+
+	tmpstr = psprintf("%lu", seqdata->min_value);
+	tmp = new_objtree_VA(createSeqStmt, "MINVALUE %{value}s",
+						 2,
+						 "clause", ObjTypeString, "minvalue",
+						 "value", ObjTypeString, tmpstr);
+	elems = lappend(elems, tmp);
+
+	tmpstr = psprintf("%lu", seqdata->max_value);
+	tmp = new_objtree_VA(createSeqStmt, "MAXVALUE %{value}s",
+						 2,
+						 "clause", ObjTypeString, "maxvalue",
+						 "value", ObjTypeString, tmpstr);
+	elems = lappend(elems, tmp);
+
+	tmpstr = psprintf("%lu", seqdata->start_value);
+	tmp = new_objtree_VA(createSeqStmt, "START WITH %{value}s",
+						 2,
+						 "clause", ObjTypeString, "start",
+						 "value", ObjTypeString, tmpstr);
+	elems = lappend(elems, tmp);
+
+	tmpstr = psprintf("%lu", seqdata->cache_value);
+	tmp = new_objtree_VA(createSeqStmt, "CACHE %{value}s",
+						 2,
+						 "clause", ObjTypeString, "cache",
+						 "value", ObjTypeString, tmpstr);
+	elems = lappend(elems, tmp);
+
+	tmp = new_objtree_VA(createSeqStmt, "%{no}s CYCLE",
+						 2,
+						 "clause", ObjTypeString, "cycle",
+						 "no", ObjTypeString,
+						 seqdata->is_cycled ? "" : "NO");
+	elems = lappend(elems, tmp);
+
+	tmp = get_sequence_ownedby(createSeqStmt, objectId);
+	if (tmp)
+		elems = lappend(elems, tmp);
+
+	append_array_object(createSeqStmt, "definition", elems);
+
+	command = jsonize_objtree(createSeqStmt);
+
+	free_objtree(createSeqStmt);
+	relation_close(relation, AccessShareLock);
+
+	return command;
+}
+
+/*
+ * deparse_IndexStmt
+ *		deparse an IndexStmt
+ *
+ * Given an index OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ *
+ * If the index corresponds to a constraint, NULL is returned.
+ */
+static char *
+deparse_IndexStmt(Oid objectId, Node *parsetree)
+{
+	IndexStmt  *node = (IndexStmt *) parsetree;
+	ObjTree    *indexStmt;
+	ObjTree    *tmp;
+	Relation	idxrel;
+	Relation	heaprel;
+	OverrideSearchPath *overridePath;
+	char	   *command;
+	char	   *index_am;
+	char	   *definition;
+	char	   *reloptions;
+	char	   *tablespace;
+	char	   *whereClause;
+
+	if (node->primary || node->isconstraint)
+	{
+		/*
+		 * indexes for PRIMARY KEY and other constraints are output
+		 * separately; return empty here.
+		 */
+		return NULL;
+	}
+
+	idxrel = relation_open(objectId, AccessShareLock);
+	heaprel = relation_open(idxrel->rd_index->indrelid, AccessShareLock);
+
+	overridePath = GetOverrideSearchPath(CurrentMemoryContext);
+	overridePath->schemas = NIL;
+	PushOverrideSearchPath(overridePath);
+
+	pg_get_indexdef_detailed(objectId,
+							 &index_am, &definition, &reloptions,
+							 &tablespace, &whereClause);
+	PopOverrideSearchPath();
+
+	indexStmt =
+		new_objtree_VA(NULL,
+					   "CREATE %{unique}s INDEX %{concurrently}s %{name}I "
+					   "ON %{table}D USING %{index_am}s (%{definition}s) "
+					   "%{with}s %{tablespace}s %{where_clause}s",
+					   5,
+					   "unique", ObjTypeString, node->unique ? "UNIQUE" : "",
+					   "concurrently", ObjTypeString,
+					   node->concurrent ? "CONCURRENTLY" : "",
+					   "name", ObjTypeString, RelationGetRelationName(idxrel),
+					   "definition", ObjTypeString, definition,
+					   "index_am", ObjTypeString, index_am);
+
+	tmp = new_objtree_for_qualname(indexStmt,
+								   heaprel->rd_rel->relnamespace,
+								   RelationGetRelationName(heaprel));
+	append_object_object(indexStmt, "table", tmp);
+
+	/* reloptions */
+	tmp = new_objtree_VA(indexStmt, "WITH (%{opts}s)", 0);
+	if (reloptions)
+		append_string_object(tmp, "opts", reloptions);
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(indexStmt, "with", tmp);
+
+	/* tablespace */
+	tmp = new_objtree_VA(indexStmt, "TABLESPACE %{tablespace}s", 0);
+	if (tablespace)
+		append_string_object(tmp, "tablespace", tablespace);
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(indexStmt, "tablespace", tmp);
+
+	/* WHERE clause */
+	tmp = new_objtree_VA(indexStmt, "WHERE %{where}s", 0);
+	if (whereClause)
+		append_string_object(tmp, "where", whereClause);
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(indexStmt, "where_clause", tmp);
+
+	command = jsonize_objtree(indexStmt);
+	free_objtree(indexStmt);
+
+	heap_close(idxrel, AccessShareLock);
+	heap_close(heaprel, AccessShareLock);
+
+	return command;
+}
+
+/*
+ * deparse_CreateSchemaStmt
+ *		deparse a CreateSchemaStmt
+ *
+ * Given a schema OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ *
+ * Note we don't output the schema elements given in the creation command.
+ * They must be output separately.	 (In the current implementation,
+ * CreateSchemaCommand passes them back to ProcessUtility, which will lead to
+ * this file if appropriate.)
+ */
+static char *
+deparse_CreateSchemaStmt(Oid objectId, Node *parsetree)
+{
+	CreateSchemaStmt *node = (CreateSchemaStmt *) parsetree;
+	ObjTree    *createSchema;
+	ObjTree    *auth;
+	char	   *command;
+
+	createSchema =
+		new_objtree_VA(NULL,
+				"CREATE SCHEMA %{if_not_exists}s %{name}I %{authorization}s",
+					   2,
+					   "name", ObjTypeString, node->schemaname,
+					   "if_not_exists", ObjTypeString,
+					   node->if_not_exists ? "IF NOT EXISTS" : "");
+
+	auth = new_objtree_VA(createSchema,
+						  "AUTHORIZATION %{authorization_role}I", 0);
+	if (node->authid)
+		append_string_object(auth, "authorization_role", node->authid);
+	else
+	{
+		append_null_object(auth, "authorization_role");
+		append_bool_object(auth, "present", false);
+	}
+	append_object_object(createSchema, "authorization", auth);
+
+	command = jsonize_objtree(createSchema);
+	free_objtree(createSchema);
+
+	return command;
+}
+
+/*
+ * Given a utility command parsetree and the OID of the corresponding object,
+ * return a JSON representation of the command.
+ *
+ * The command is expanded fully, so that there are no ambiguities even in the
+ * face of search_path changes.
+ *
+ * Note we currently only support commands for which ProcessUtilitySlow saves
+ * objects to create; currently this excludes all forms of ALTER and DROP.
+ */
+char *
+deparse_utility_command(Oid objectId, Node *parsetree)
+{
+	char	   *command;
+
+	switch (nodeTag(parsetree))
+	{
+		case T_CreateSchemaStmt:
+			command = deparse_CreateSchemaStmt(objectId, parsetree);
+			break;
+
+		case T_CreateStmt:
+			command = deparse_CreateStmt(objectId, parsetree);
+			break;
+
+		case T_IndexStmt:
+			command = deparse_IndexStmt(objectId, parsetree);
+			break;
+
+		case T_ViewStmt:
+			command = deparse_ViewStmt(objectId, parsetree);
+			break;
+
+		case T_CreateSeqStmt:
+			command = deparse_CreateSeqStmt(objectId, parsetree);
+			break;
+
+			/* creation of objects hanging off tables */
+		case T_RuleStmt:
+		case T_CreateTrigStmt:
+			command = NULL;
+			break;
+
+			/* FDW-related objects */
+		case T_CreateForeignTableStmt:
+		case T_CreateFdwStmt:
+		case T_CreateForeignServerStmt:
+		case T_CreateUserMappingStmt:
+
+			/* other local objects */
+		case T_DefineStmt:
+		case T_CreateExtensionStmt:
+		case T_CompositeTypeStmt:		/* CREATE TYPE (composite) */
+		case T_CreateEnumStmt:	/* CREATE TYPE AS ENUM */
+		case T_CreateRangeStmt:	/* CREATE TYPE AS RANGE */
+		case T_CreateDomainStmt:
+		case T_CreateFunctionStmt:
+		case T_CreateTableAsStmt:
+		case T_CreatePLangStmt:
+		case T_CreateConversionStmt:
+		case T_CreateCastStmt:
+		case T_CreateOpClassStmt:
+		case T_CreateOpFamilyStmt:
+			command = NULL;
+			break;
+
+			/* matviews */
+		case T_RefreshMatViewStmt:
+			command = NULL;
+			break;
+
+		default:
+			command = NULL;
+			elog(LOG, "unrecognized node type: %d",
+				 (int) nodeTag(parsetree));
+	}
+
+	return command;
+}
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index f4d25bd..328f4a1 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -904,6 +904,7 @@ ProcessUtilitySlow(Node *parsetree,
 	bool		isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL);
 	bool		isCompleteQuery = (context <= PROCESS_UTILITY_QUERY);
 	bool		needCleanup;
+	Oid			objectId;
 
 	/* All event trigger calls are done only when isCompleteQuery is true */
 	needCleanup = isCompleteQuery && EventTriggerBeginCompleteQuery();
@@ -922,6 +923,10 @@ ProcessUtilitySlow(Node *parsetree,
 			case T_CreateSchemaStmt:
 				CreateSchemaCommand((CreateSchemaStmt *) parsetree,
 									queryString);
+				/*
+				 * CreateSchemaCommand calls EventTriggerStashCreatedObject
+				 * internally, for reasons explained there.
+				 */
 				break;
 
 			case T_CreateStmt:
@@ -929,7 +934,6 @@ ProcessUtilitySlow(Node *parsetree,
 				{
 					List	   *stmts;
 					ListCell   *l;
-					Oid			relOid;
 
 					/* Run parse analysis ... */
 					stmts = transformCreateStmt((CreateStmt *) parsetree,
@@ -946,9 +950,12 @@ ProcessUtilitySlow(Node *parsetree,
 							static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
 
 							/* Create the table itself */
-							relOid = DefineRelation((CreateStmt *) stmt,
-													RELKIND_RELATION,
-													InvalidOid);
+							objectId = DefineRelation((CreateStmt *) stmt,
+													  RELKIND_RELATION,
+													  InvalidOid);
+							EventTriggerStashCreatedObject(objectId,
+														   OCLASS_CLASS,
+														   stmt);
 
 							/*
 							 * Let AlterTableCreateToastTable decide if this
@@ -970,20 +977,27 @@ ProcessUtilitySlow(Node *parsetree,
 												   toast_options,
 												   true);
 
-							AlterTableCreateToastTable(relOid, toast_options);
+							AlterTableCreateToastTable(objectId, toast_options);
 						}
 						else if (IsA(stmt, CreateForeignTableStmt))
 						{
 							/* Create the table itself */
-							relOid = DefineRelation((CreateStmt *) stmt,
-													RELKIND_FOREIGN_TABLE,
-													InvalidOid);
+							objectId = DefineRelation((CreateStmt *) stmt,
+													  RELKIND_FOREIGN_TABLE,
+													  InvalidOid);
 							CreateForeignTable((CreateForeignTableStmt *) stmt,
-											   relOid);
+											   objectId);
+							EventTriggerStashCreatedObject(objectId,
+														   OCLASS_CLASS,
+														   stmt);
 						}
 						else
 						{
-							/* Recurse for anything else */
+							/*
+							 * Recurse for anything else.  Note the recursive
+							 * call will stash the objects so created into our
+							 * event trigger context.
+							 */
 							ProcessUtility(stmt,
 										   queryString,
 										   PROCESS_UTILITY_SUBCOMMAND,
@@ -1110,50 +1124,66 @@ ProcessUtilitySlow(Node *parsetree,
 			case T_DefineStmt:
 				{
 					DefineStmt *stmt = (DefineStmt *) parsetree;
+					ObjectClass	class;
 
 					switch (stmt->kind)
 					{
 						case OBJECT_AGGREGATE:
-							DefineAggregate(stmt->defnames, stmt->args,
-											stmt->oldstyle, stmt->definition,
-											queryString);
+							objectId =
+								DefineAggregate(stmt->defnames, stmt->args,
+												stmt->oldstyle,
+												stmt->definition, queryString);
+							class = OCLASS_PROC;
 							break;
 						case OBJECT_OPERATOR:
 							Assert(stmt->args == NIL);
-							DefineOperator(stmt->defnames, stmt->definition);
+							objectId = DefineOperator(stmt->defnames,
+													  stmt->definition);
+							class = OCLASS_OPERATOR;
 							break;
 						case OBJECT_TYPE:
 							Assert(stmt->args == NIL);
-							DefineType(stmt->defnames, stmt->definition);
+							objectId = DefineType(stmt->defnames,
+												  stmt->definition);
+							class = OCLASS_TYPE;
 							break;
 						case OBJECT_TSPARSER:
 							Assert(stmt->args == NIL);
-							DefineTSParser(stmt->defnames, stmt->definition);
+							objectId = DefineTSParser(stmt->defnames,
+													  stmt->definition);
+							class = OCLASS_TSPARSER;
 							break;
 						case OBJECT_TSDICTIONARY:
 							Assert(stmt->args == NIL);
-							DefineTSDictionary(stmt->defnames,
-											   stmt->definition);
+							objectId = DefineTSDictionary(stmt->defnames,
+														  stmt->definition);
+							class = OCLASS_TSDICT;
 							break;
 						case OBJECT_TSTEMPLATE:
 							Assert(stmt->args == NIL);
-							DefineTSTemplate(stmt->defnames,
-											 stmt->definition);
+							objectId = DefineTSTemplate(stmt->defnames,
+														stmt->definition);
+							class = OCLASS_TSTEMPLATE;
 							break;
 						case OBJECT_TSCONFIGURATION:
 							Assert(stmt->args == NIL);
-							DefineTSConfiguration(stmt->defnames,
-												  stmt->definition);
+							objectId = DefineTSConfiguration(stmt->defnames,
+															 stmt->definition);
+							class = OCLASS_TSCONFIG;
 							break;
 						case OBJECT_COLLATION:
 							Assert(stmt->args == NIL);
-							DefineCollation(stmt->defnames, stmt->definition);
+							objectId = DefineCollation(stmt->defnames,
+													   stmt->definition);
+							class = OCLASS_COLLATION;
 							break;
 						default:
 							elog(ERROR, "unrecognized define stmt type: %d",
 								 (int) stmt->kind);
 							break;
 					}
+
+					EventTriggerStashCreatedObject(objectId, class, parsetree);
 				}
 				break;
 
@@ -1171,17 +1201,20 @@ ProcessUtilitySlow(Node *parsetree,
 					stmt = transformIndexStmt(stmt, queryString);
 
 					/* ... and do it */
-					DefineIndex(stmt,
-								InvalidOid,		/* no predefined OID */
-								false,	/* is_alter_table */
-								true,	/* check_rights */
-								false,	/* skip_build */
-								false); /* quiet */
+					objectId = DefineIndex(stmt,
+										   InvalidOid,		/* no predefined OID */
+										   false,	/* is_alter_table */
+										   true,	/* check_rights */
+										   false,	/* skip_build */
+										   false); /* quiet */
+					EventTriggerStashCreatedObject(objectId, OCLASS_CLASS,
+												   parsetree);
 				}
 				break;
 
 			case T_CreateExtensionStmt:
-				CreateExtension((CreateExtensionStmt *) parsetree);
+				objectId = CreateExtension((CreateExtensionStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_EXTENSION, parsetree);
 				break;
 
 			case T_AlterExtensionStmt:
@@ -1193,7 +1226,8 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_CreateFdwStmt:
-				CreateForeignDataWrapper((CreateFdwStmt *) parsetree);
+				objectId = CreateForeignDataWrapper((CreateFdwStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_FDW, parsetree);
 				break;
 
 			case T_AlterFdwStmt:
@@ -1201,7 +1235,9 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_CreateForeignServerStmt:
-				CreateForeignServer((CreateForeignServerStmt *) parsetree);
+				objectId = CreateForeignServer((CreateForeignServerStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_FOREIGN_SERVER,
+										parsetree);
 				break;
 
 			case T_AlterForeignServerStmt:
@@ -1209,7 +1245,9 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_CreateUserMappingStmt:
-				CreateUserMapping((CreateUserMappingStmt *) parsetree);
+				objectId = CreateUserMapping((CreateUserMappingStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_USER_MAPPING,
+										parsetree);
 				break;
 
 			case T_AlterUserMappingStmt:
@@ -1224,16 +1262,19 @@ ProcessUtilitySlow(Node *parsetree,
 				{
 					CompositeTypeStmt *stmt = (CompositeTypeStmt *) parsetree;
 
-					DefineCompositeType(stmt->typevar, stmt->coldeflist);
+					objectId = DefineCompositeType(stmt->typevar, stmt->coldeflist);
+					EventTriggerStashCreatedObject(objectId, OCLASS_TYPE, parsetree);
 				}
 				break;
 
 			case T_CreateEnumStmt:		/* CREATE TYPE AS ENUM */
-				DefineEnum((CreateEnumStmt *) parsetree);
+				objectId = DefineEnum((CreateEnumStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_TYPE, parsetree);
 				break;
 
 			case T_CreateRangeStmt:		/* CREATE TYPE AS RANGE */
-				DefineRange((CreateRangeStmt *) parsetree);
+				objectId = DefineRange((CreateRangeStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_TYPE, parsetree);
 				break;
 
 			case T_AlterEnumStmt:		/* ALTER TYPE (enum) */
@@ -1241,23 +1282,27 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_ViewStmt:	/* CREATE VIEW */
-				DefineView((ViewStmt *) parsetree, queryString);
+				objectId = DefineView((ViewStmt *) parsetree, queryString);
+				EventTriggerStashCreatedObject(objectId, OCLASS_CLASS, parsetree);
 				break;
 
 			case T_CreateFunctionStmt:	/* CREATE FUNCTION */
-				CreateFunction((CreateFunctionStmt *) parsetree, queryString);
+				objectId = CreateFunction((CreateFunctionStmt *) parsetree, queryString);
+				EventTriggerStashCreatedObject(objectId, OCLASS_PROC, parsetree);
 				break;
 
 			case T_AlterFunctionStmt:	/* ALTER FUNCTION */
-				AlterFunction((AlterFunctionStmt *) parsetree);
+				objectId = AlterFunction((AlterFunctionStmt *) parsetree);
 				break;
 
 			case T_RuleStmt:	/* CREATE RULE */
-				DefineRule((RuleStmt *) parsetree, queryString);
+				objectId = DefineRule((RuleStmt *) parsetree, queryString);
+				EventTriggerStashCreatedObject(objectId, OCLASS_REWRITE, parsetree);
 				break;
 
 			case T_CreateSeqStmt:
-				DefineSequence((CreateSeqStmt *) parsetree);
+				objectId = DefineSequence((CreateSeqStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_CLASS, parsetree);
 				break;
 
 			case T_AlterSeqStmt:
@@ -1265,42 +1310,51 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_CreateTableAsStmt:
-				ExecCreateTableAs((CreateTableAsStmt *) parsetree,
+				objectId = ExecCreateTableAs((CreateTableAsStmt *) parsetree,
 								  queryString, params, completionTag);
+				EventTriggerStashCreatedObject(objectId, OCLASS_CLASS, parsetree);
 				break;
 
 			case T_RefreshMatViewStmt:
-				ExecRefreshMatView((RefreshMatViewStmt *) parsetree,
+				objectId = ExecRefreshMatView((RefreshMatViewStmt *) parsetree,
 								   queryString, params, completionTag);
+				EventTriggerStashCreatedObject(objectId, OCLASS_CLASS, parsetree);
 				break;
 
 			case T_CreateTrigStmt:
-				(void) CreateTrigger((CreateTrigStmt *) parsetree, queryString,
+				objectId = CreateTrigger((CreateTrigStmt *) parsetree, queryString,
 									 InvalidOid, InvalidOid, false);
+				EventTriggerStashCreatedObject(objectId, OCLASS_TRIGGER, parsetree);
 				break;
 
 			case T_CreatePLangStmt:
-				CreateProceduralLanguage((CreatePLangStmt *) parsetree);
+				objectId = CreateProceduralLanguage((CreatePLangStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_LANGUAGE, parsetree);
 				break;
 
 			case T_CreateDomainStmt:
-				DefineDomain((CreateDomainStmt *) parsetree);
+				objectId = DefineDomain((CreateDomainStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_TYPE, parsetree);
 				break;
 
 			case T_CreateConversionStmt:
-				CreateConversionCommand((CreateConversionStmt *) parsetree);
+				objectId = CreateConversionCommand((CreateConversionStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_CONVERSION, parsetree);
 				break;
 
 			case T_CreateCastStmt:
-				CreateCast((CreateCastStmt *) parsetree);
+				objectId = CreateCast((CreateCastStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_CAST, parsetree);
 				break;
 
 			case T_CreateOpClassStmt:
-				DefineOpClass((CreateOpClassStmt *) parsetree);
+				objectId = DefineOpClass((CreateOpClassStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_OPCLASS, parsetree);
 				break;
 
 			case T_CreateOpFamilyStmt:
-				DefineOpFamily((CreateOpFamilyStmt *) parsetree);
+				objectId = DefineOpFamily((CreateOpFamilyStmt *) parsetree);
+				EventTriggerStashCreatedObject(objectId, OCLASS_OPFAMILY, parsetree);
 				break;
 
 			case T_AlterOpFamilyStmt:
diff --git a/src/backend/utils/adt/format_type.c b/src/backend/utils/adt/format_type.c
index 5b75d34..f160e98 100644
--- a/src/backend/utils/adt/format_type.c
+++ b/src/backend/utils/adt/format_type.c
@@ -96,6 +96,9 @@ format_type_be(Oid type_oid)
 	return format_type_internal(type_oid, -1, false, false, false);
 }
 
+/*
+ * This version returns a name which is always qualified.
+ */
 char *
 format_type_be_qualified(Oid type_oid)
 {
@@ -111,72 +114,20 @@ format_type_with_typemod(Oid type_oid, int32 typemod)
 	return format_type_internal(type_oid, typemod, true, false, false);
 }
 
+/*
+ * Formats a system type.
+ *
+ * These special cases should all correspond to special productions in gram.y,
+ * to ensure that the type name will be taken as a system type, not a user type
+ * of the same name.
+ *
+ * Returns NULL if not a system type.
+ */
 static char *
-format_type_internal(Oid type_oid, int32 typemod,
-					 bool typemod_given, bool allow_invalid,
-					 bool force_qualify)
+format_special_type(Oid type_oid, Form_pg_type typeform,
+					int32 typemod, bool typemod_given, bool with_typemod)
 {
-	bool		with_typemod = typemod_given && (typemod >= 0);
-	HeapTuple	tuple;
-	Form_pg_type typeform;
-	Oid			array_base_type;
-	bool		is_array;
-	char	   *buf;
-
-	if (type_oid == InvalidOid && allow_invalid)
-		return pstrdup("-");
-
-	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
-	if (!HeapTupleIsValid(tuple))
-	{
-		if (allow_invalid)
-			return pstrdup("???");
-		else
-			elog(ERROR, "cache lookup failed for type %u", type_oid);
-	}
-	typeform = (Form_pg_type) GETSTRUCT(tuple);
-
-	/*
-	 * Check if it's a regular (variable length) array type.  Fixed-length
-	 * array types such as "name" shouldn't get deconstructed.  As of Postgres
-	 * 8.1, rather than checking typlen we check the toast property, and don't
-	 * deconstruct "plain storage" array types --- this is because we don't
-	 * want to show oidvector as oid[].
-	 */
-	array_base_type = typeform->typelem;
-
-	if (array_base_type != InvalidOid &&
-		typeform->typstorage != 'p')
-	{
-		/* Switch our attention to the array element type */
-		ReleaseSysCache(tuple);
-		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
-		if (!HeapTupleIsValid(tuple))
-		{
-			if (allow_invalid)
-				return pstrdup("???[]");
-			else
-				elog(ERROR, "cache lookup failed for type %u", type_oid);
-		}
-		typeform = (Form_pg_type) GETSTRUCT(tuple);
-		type_oid = array_base_type;
-		is_array = true;
-	}
-	else
-		is_array = false;
-
-	/*
-	 * See if we want to special-case the output for certain built-in types.
-	 * Note that these special cases should all correspond to special
-	 * productions in gram.y, to ensure that the type name will be taken as a
-	 * system type, not a user type of the same name.
-	 *
-	 * If we do not provide a special-case output here, the type name will be
-	 * handled the same way as a user type name --- in particular, it will be
-	 * double-quoted if it matches any lexer keyword.  This behavior is
-	 * essential for some cases, such as types "bit" and "char".
-	 */
-	buf = NULL;					/* flag for no special case */
+	char   *buf = NULL;
 
 	switch (type_oid)
 	{
@@ -285,12 +236,90 @@ format_type_internal(Oid type_oid, int32 typemod,
 
 		case VARCHAROID:
 			if (with_typemod)
-				buf = printTypmod("character varying", typemod, typeform->typmodout);
+				buf = printTypmod("character varying", typemod,
+								  typeform->typmodout);
 			else
 				buf = pstrdup("character varying");
 			break;
 	}
 
+	return buf;
+}
+
+/*
+ * Return a formatted typename.
+ *
+ * If qualify is Auto, the type name is qualified if necessary, which means
+ * qualify when not visible to search_path.  If qualify is Always, it is
+ * qualified regardless of visibility.
+ */
+static char *
+format_type_internal(Oid type_oid, int32 typemod,
+					 bool typemod_given, bool allow_invalid,
+					 bool force_qualify)
+{
+	bool		with_typemod = typemod_given && (typemod >= 0);
+	HeapTuple	tuple;
+	Form_pg_type typeform;
+	Oid			array_base_type;
+	bool		is_array;
+	char	   *buf;
+
+	if (type_oid == InvalidOid && allow_invalid)
+		return pstrdup("-");
+
+	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
+	if (!HeapTupleIsValid(tuple))
+	{
+		if (allow_invalid)
+			return pstrdup("???");
+		else
+			elog(ERROR, "cache lookup failed for type %u", type_oid);
+	}
+	typeform = (Form_pg_type) GETSTRUCT(tuple);
+
+	/*
+	 * Check if it's a regular (variable length) array type.  Fixed-length
+	 * array types such as "name" shouldn't get deconstructed.  As of Postgres
+	 * 8.1, rather than checking typlen we check the toast property, and don't
+	 * deconstruct "plain storage" array types --- this is because we don't
+	 * want to show oidvector as oid[].
+	 */
+	array_base_type = typeform->typelem;
+
+	if (array_base_type != InvalidOid &&
+		typeform->typstorage != 'p')
+	{
+		/* Switch our attention to the array element type */
+		ReleaseSysCache(tuple);
+		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
+		if (!HeapTupleIsValid(tuple))
+		{
+			if (allow_invalid)
+				return pstrdup("???[]");
+			else
+				elog(ERROR, "cache lookup failed for type %u", type_oid);
+		}
+		typeform = (Form_pg_type) GETSTRUCT(tuple);
+		type_oid = array_base_type;
+		is_array = true;
+	}
+	else
+		is_array = false;
+
+	/*
+	 * See if we want to special-case the output for certain built-in types.
+	 *
+	 * If we do not provide a special-case output here, the type name will be
+	 * handled the same way as a user type name --- in particular, it will be
+	 * double-quoted if it matches any lexer keyword.  This behavior is
+	 * essential for some cases, such as types "bit" and "char".
+	 */
+	buf = NULL;					/* flag for no special case */
+
+	buf = format_special_type(type_oid, typeform,
+							  typemod, typemod_given, with_typemod);
+
 	if (buf == NULL)
 	{
 		/*
@@ -323,6 +352,73 @@ format_type_internal(Oid type_oid, int32 typemod,
 	return buf;
 }
 
+/*
+ * Similar to format_type_internal, except we return each bit of information
+ * separately:
+ *
+ * - nspname is the schema name, without quotes.  This is NULL if the
+ *   type is a system type.
+ *
+ * - typename is set to the type name, without quotes
+ *
+ * - typmod is set to the typemod, if any, as a string with parens
+ *
+ * - is_array indicates whether []s must be added
+ *
+ * Also, we don't try to decode type names to their standard-mandate names.
+ *
+ * XXX there is a lot of code duplication between this routine and
+ * format_type_internal.  (One thing that doesn't quite match is the whole
+ * allow_invalid business.)
+ */
+void
+format_type_detailed(Oid type_oid, int32 typemod,
+					 char **nspname, char **typname, char **typemodstr,
+					 bool *is_array)
+{
+	HeapTuple	tuple;
+	Form_pg_type typeform;
+	Oid			array_base_type;
+
+	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
+	if (!HeapTupleIsValid(tuple))
+		elog(ERROR, "cache lookup failed for type %u", type_oid);
+
+	typeform = (Form_pg_type) GETSTRUCT(tuple);
+
+	/*
+	 * Check if it's a regular (variable length) array type.  As above,
+	 * fixed-length array types such as "name" shouldn't get deconstructed.
+	 */
+	array_base_type = typeform->typelem;
+
+	if (array_base_type != InvalidOid &&
+		typeform->typstorage != 'p')
+	{
+		/* Switch our attention to the array element type */
+		ReleaseSysCache(tuple);
+		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for type %u", type_oid);
+
+		typeform = (Form_pg_type) GETSTRUCT(tuple);
+		type_oid = array_base_type;
+		*is_array = true;
+	}
+	else
+		*is_array = false;
+
+	*nspname = get_namespace_name(typeform->typnamespace);
+	*typname = pstrdup(NameStr(typeform->typname));
+
+	if (typemod > 0)
+		*typemodstr = printTypmod(NULL, typemod, typeform->typmodout);
+	else
+		*typemodstr = pstrdup("");	/* XXX ?? */
+
+	ReleaseSysCache(tuple);
+}
+
 
 /*
  * Add typmod decoration to the basic type name
@@ -338,7 +434,10 @@ printTypmod(const char *typname, int32 typmod, Oid typmodout)
 	if (typmodout == InvalidOid)
 	{
 		/* Default behavior: just print the integer typmod with parens */
-		res = psprintf("%s(%d)", typname, (int) typmod);
+		if (typname == NULL)
+			res = psprintf("(%d)", (int) typmod);
+		else
+			res = psprintf("%s(%d)", typname, (int) typmod);
 	}
 	else
 	{
@@ -347,13 +446,15 @@ printTypmod(const char *typname, int32 typmod, Oid typmodout)
 
 		tmstr = DatumGetCString(OidFunctionCall1(typmodout,
 												 Int32GetDatum(typmod)));
-		res = psprintf("%s%s", typname, tmstr);
+		if (typname == NULL)
+			res = psprintf("%s", tmstr);
+		else
+			res = psprintf("%s%s", typname, tmstr);
 	}
 
 	return res;
 }
 
-
 /*
  * type_maximum_size --- determine maximum width of a variable-width column
  *
diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
index 7c07554..11b1e00 100644
--- a/src/backend/utils/adt/jsonfuncs.c
+++ b/src/backend/utils/adt/jsonfuncs.c
@@ -226,13 +226,13 @@ typedef struct PopulateRecordsetState
 } PopulateRecordsetState;
 
 /*
- * SQL function json_object-keys
+ * SQL function json_object_keys
  *
  * Returns the set of keys for the object argument.
  *
  * This SRF operates in value-per-call mode. It processes the
  * object during the first call, and the keys are simply stashed
- * in an array, whise size is expanded as necessary. This is probably
+ * in an array, whose size is expanded as necessary. This is probably
  * safe enough for a list of keys of a single object, since they are
  * limited in size to NAMEDATALEN and the number of keys is unlikely to
  * be so huge that it has major memory implications.
@@ -972,7 +972,7 @@ each_worker(PG_FUNCTION_ARGS, bool as_text)
 
 	pg_parse_json(lex, sem);
 
-	MemoryContextDelete(state->tmp_cxt); 
+	MemoryContextDelete(state->tmp_cxt);
 
 	rsi->setResult = state->tuple_store;
 	rsi->setDesc = state->ret_tdesc;
@@ -1156,7 +1156,7 @@ elements_worker(PG_FUNCTION_ARGS, bool as_text)
 
 	pg_parse_json(lex, sem);
 
-	MemoryContextDelete(state->tmp_cxt); 
+	MemoryContextDelete(state->tmp_cxt);
 
 	rsi->setResult = state->tuple_store;
 	rsi->setDesc = state->ret_tdesc;
@@ -1193,7 +1193,7 @@ elements_array_element_end(void *state, bool isnull)
 	text	   *val;
 	HeapTuple	tuple;
 	Datum		values[1];
-	bool nulls[1] = {false};
+	bool		nulls[1] = {false};
 
 	/* skip over nested objects */
 	if (_state->lex->lex_level != 1)
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index add5cd1..fafe3bf 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -587,6 +587,13 @@ pg_get_viewdef_name_ext(PG_FUNCTION_ARGS)
 	PG_RETURN_TEXT_P(string_to_text(pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT)));
 }
 
+char *
+pg_get_viewdef_internal(Oid viewoid)
+{
+	return pg_get_viewdef_worker(viewoid, 0, WRAP_COLUMN_DEFAULT);
+}
+
+
 /*
  * Common code for by-OID and by-name variants of pg_get_viewdef
  */
@@ -966,6 +973,8 @@ pg_get_indexdef_columns(Oid indexrelid, bool pretty)
  *
  * This is now used for exclusion constraints as well: if excludeOps is not
  * NULL then it points to an array of exclusion operator OIDs.
+ *
+ * XXX if you change this function, see pg_get_indexdef_detailed too.
  */
 static char *
 pg_get_indexdef_worker(Oid indexrelid, int colno,
@@ -1144,7 +1153,7 @@ pg_get_indexdef_worker(Oid indexrelid, int colno,
 
 			/* Add collation, if not default for column */
 			indcoll = indcollation->values[keyno];
-			if (OidIsValid(indcoll) && indcoll != keycolcollation)
+			if (OidIsValid(indcoll))
 				appendStringInfo(&buf, " COLLATE %s",
 								 generate_collation_name((indcoll)));
 
@@ -1245,6 +1254,245 @@ pg_get_indexdef_worker(Oid indexrelid, int colno,
 	return buf.data;
 }
 
+/*
+ * Return an index definition, split in several pieces.
+ *
+ * There is a huge lot of code that's a dupe of pg_get_indexdef_worker, but
+ * control flow is different enough that it doesn't seem worth keeping them
+ * together.
+ */
+void
+pg_get_indexdef_detailed(Oid indexrelid,
+						 char **index_am,
+						 char **definition,
+						 char **reloptions,
+						 char **tablespace,
+						 char **whereClause)
+{
+	HeapTuple	ht_idx;
+	HeapTuple	ht_idxrel;
+	HeapTuple	ht_am;
+	Form_pg_index idxrec;
+	Form_pg_class idxrelrec;
+	Form_pg_am	amrec;
+	List	   *indexprs;
+	ListCell   *indexpr_item;
+	List	   *context;
+	Oid			indrelid;
+	int			keyno;
+	Datum		indcollDatum;
+	Datum		indclassDatum;
+	Datum		indoptionDatum;
+	bool		isnull;
+	oidvector  *indcollation;
+	oidvector  *indclass;
+	int2vector *indoption;
+	StringInfoData definitionBuf;
+	char	   *sep;
+
+	/*
+	 * Fetch the pg_index tuple by the Oid of the index
+	 */
+	ht_idx = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexrelid));
+	if (!HeapTupleIsValid(ht_idx))
+		elog(ERROR, "cache lookup failed for index %u", indexrelid);
+	idxrec = (Form_pg_index) GETSTRUCT(ht_idx);
+
+	indrelid = idxrec->indrelid;
+	Assert(indexrelid == idxrec->indexrelid);
+
+	/* Must get indcollation, indclass, and indoption the hard way */
+	indcollDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+								   Anum_pg_index_indcollation, &isnull);
+	Assert(!isnull);
+	indcollation = (oidvector *) DatumGetPointer(indcollDatum);
+
+	indclassDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+									Anum_pg_index_indclass, &isnull);
+	Assert(!isnull);
+	indclass = (oidvector *) DatumGetPointer(indclassDatum);
+
+	indoptionDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+									 Anum_pg_index_indoption, &isnull);
+	Assert(!isnull);
+	indoption = (int2vector *) DatumGetPointer(indoptionDatum);
+
+	/*
+	 * Fetch the pg_class tuple of the index relation
+	 */
+	ht_idxrel = SearchSysCache1(RELOID, ObjectIdGetDatum(indexrelid));
+	if (!HeapTupleIsValid(ht_idxrel))
+		elog(ERROR, "cache lookup failed for relation %u", indexrelid);
+	idxrelrec = (Form_pg_class) GETSTRUCT(ht_idxrel);
+
+	/*
+	 * Fetch the pg_am tuple of the index' access method
+	 */
+	ht_am = SearchSysCache1(AMOID, ObjectIdGetDatum(idxrelrec->relam));
+	if (!HeapTupleIsValid(ht_am))
+		elog(ERROR, "cache lookup failed for access method %u",
+			 idxrelrec->relam);
+	amrec = (Form_pg_am) GETSTRUCT(ht_am);
+
+	/*
+	 * Get the index expressions, if any.  (NOTE: we do not use the relcache
+	 * versions of the expressions and predicate, because we want to display
+	 * non-const-folded expressions.)
+	 */
+	if (!heap_attisnull(ht_idx, Anum_pg_index_indexprs))
+	{
+		Datum		exprsDatum;
+		bool		isnull;
+		char	   *exprsString;
+
+		exprsDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+									 Anum_pg_index_indexprs, &isnull);
+		Assert(!isnull);
+		exprsString = TextDatumGetCString(exprsDatum);
+		indexprs = (List *) stringToNode(exprsString);
+		pfree(exprsString);
+	}
+	else
+		indexprs = NIL;
+
+	indexpr_item = list_head(indexprs);
+
+	context = deparse_context_for(get_relation_name(indrelid), indrelid);
+
+	initStringInfo(&definitionBuf);
+
+	/* output index AM */
+	*index_am = pstrdup(quote_identifier(NameStr(amrec->amname)));
+
+	/*
+	 * Output index definition.  Note the outer parens must be supplied by
+	 * caller.
+	 */
+	sep = "";
+	for (keyno = 0; keyno < idxrec->indnatts; keyno++)
+	{
+		AttrNumber	attnum = idxrec->indkey.values[keyno];
+		int16		opt = indoption->values[keyno];
+		Oid			keycoltype;
+		Oid			keycolcollation;
+		Oid			indcoll;
+
+		appendStringInfoString(&definitionBuf, sep);
+		sep = ", ";
+
+		if (attnum != 0)
+		{
+			/* Simple index column */
+			char	   *attname;
+			int32		keycoltypmod;
+
+			attname = get_relid_attribute_name(indrelid, attnum);
+			appendStringInfoString(&definitionBuf, quote_identifier(attname));
+			get_atttypetypmodcoll(indrelid, attnum,
+								  &keycoltype, &keycoltypmod,
+								  &keycolcollation);
+		}
+		else
+		{
+			/* expressional index */
+			Node	   *indexkey;
+			char	   *str;
+
+			if (indexpr_item == NULL)
+				elog(ERROR, "too few entries in indexprs list");
+			indexkey = (Node *) lfirst(indexpr_item);
+			indexpr_item = lnext(indexpr_item);
+			/* Deparse */
+			str = deparse_expression_pretty(indexkey, context, false, false,
+											0, 0);
+
+			/* Need parens if it's not a bare function call */
+			if (indexkey && IsA(indexkey, FuncExpr) &&
+				((FuncExpr *) indexkey)->funcformat == COERCE_EXPLICIT_CALL)
+				appendStringInfoString(&definitionBuf, str);
+			else
+				appendStringInfo(&definitionBuf, "(%s)", str);
+
+			keycoltype = exprType(indexkey);
+			keycolcollation = exprCollation(indexkey);
+		}
+
+		/* Add collation, even if default */
+		indcoll = indcollation->values[keyno];
+		if (OidIsValid(indcoll))
+			appendStringInfo(&definitionBuf, " COLLATE %s",
+							 generate_collation_name((indcoll)));
+
+		/* Add the operator class name, even if default */
+		get_opclass_name(indclass->values[keyno], InvalidOid, &definitionBuf);
+
+		/* Add options if relevant */
+		if (amrec->amcanorder)
+		{
+			/* if it supports sort ordering, report DESC and NULLS opts */
+			if (opt & INDOPTION_DESC)
+			{
+				appendStringInfoString(&definitionBuf, " DESC");
+				/* NULLS FIRST is the default in this case */
+				if (!(opt & INDOPTION_NULLS_FIRST))
+					appendStringInfoString(&definitionBuf, " NULLS LAST");
+			}
+			else
+			{
+				if (opt & INDOPTION_NULLS_FIRST)
+					appendStringInfoString(&definitionBuf, " NULLS FIRST");
+			}
+		}
+
+		/* XXX excludeOps thingy was here; do we need anything? */
+	}
+	*definition = definitionBuf.data;
+
+	/* output reloptions */
+	*reloptions = flatten_reloptions(indexrelid);
+
+	/* output tablespace */
+	{
+		Oid			tblspc;
+
+		tblspc = get_rel_tablespace(indexrelid);
+		if (OidIsValid(tblspc))
+			*tablespace = pstrdup(quote_identifier(get_tablespace_name(tblspc)));
+		else
+			*tablespace = NULL;
+	}
+
+	/* report index predicate, if any */
+	if (!heap_attisnull(ht_idx, Anum_pg_index_indpred))
+	{
+		Node	   *node;
+		Datum		predDatum;
+		bool		isnull;
+		char	   *predString;
+
+		/* Convert text string to node tree */
+		predDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+									Anum_pg_index_indpred, &isnull);
+		Assert(!isnull);
+		predString = TextDatumGetCString(predDatum);
+		node = (Node *) stringToNode(predString);
+		pfree(predString);
+
+		/* Deparse */
+		*whereClause =
+			deparse_expression_pretty(node, context, false, false,
+									  0, 0);
+	}
+	else
+		*whereClause = NULL;
+
+	/* Clean up */
+	ReleaseSysCache(ht_idx);
+	ReleaseSysCache(ht_idxrel);
+	ReleaseSysCache(ht_am);
+
+	/* all done */
+}
 
 /*
  * pg_get_constraintdef
@@ -1279,9 +1527,9 @@ pg_get_constraintdef_ext(PG_FUNCTION_ARGS)
 
 /* Internal version that returns a palloc'd C string; no pretty-printing */
 char *
-pg_get_constraintdef_string(Oid constraintId)
+pg_get_constraintdef_string(Oid constraintId, bool fullCommand)
 {
-	return pg_get_constraintdef_worker(constraintId, true, 0);
+	return pg_get_constraintdef_worker(constraintId, fullCommand, 0);
 }
 
 static char *
@@ -2368,8 +2616,10 @@ pg_get_function_arg_default(PG_FUNCTION_ARGS)
 
 	proc = (Form_pg_proc) GETSTRUCT(proctup);
 
-	/* Calculate index into proargdefaults: proargdefaults corresponds to the
-	 * last N input arguments, where N = pronargdefaults. */
+	/*
+	 * Calculate index into proargdefaults: proargdefaults corresponds to the
+	 * last N input arguments, where N = pronargdefaults.
+	 */
 	nth_default = nth_inputarg - 1 - (proc->pronargs - proc->pronargdefaults);
 
 	if (nth_default < 0 || nth_default >= list_length(argdefaults))
@@ -4156,6 +4406,20 @@ get_query_def(Query *query, StringInfo buf, List *parentnamespace,
 	}
 }
 
+char *
+pg_get_viewstmt_definition(Query *viewParse)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	get_query_def(viewParse, &buf, NIL, NULL, 0,
+				  WRAP_COLUMN_DEFAULT, 1);
+
+	return buf.data;
+}
+
+
 /* ----------
  * get_values_def			- Parse back a VALUES list
  * ----------
@@ -9096,3 +9360,19 @@ flatten_reloptions(Oid relid)
 
 	return result;
 }
+
+extern char *relation_get_column_default(Relation rel, AttrNumber attno,
+							List *dpcontext);
+
+char *
+relation_get_column_default(Relation rel, AttrNumber attno, List *dpcontext)
+{
+	Node *defval;
+	char *defstr;
+
+	defval = build_column_default(rel, attno);
+	defstr = deparse_expression_pretty(defval, dpcontext, false, false,
+									   0, 0);
+
+	return defstr;
+}
diff --git a/src/include/catalog/dependency.h b/src/include/catalog/dependency.h
index 8948589..41660be 100644
--- a/src/include/catalog/dependency.h
+++ b/src/include/catalog/dependency.h
@@ -176,6 +176,8 @@ extern void recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
 
 extern ObjectClass getObjectClass(const ObjectAddress *object);
 
+extern Oid get_class_catalog(ObjectClass oclass);
+
 extern ObjectAddresses *new_object_addresses(void);
 
 extern void add_exact_object_address(const ObjectAddress *object,
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index e6713a6..66ab6f1 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -4793,6 +4793,10 @@ DESCR("information about replication slots currently in use");
 /* event triggers */
 DATA(insert OID = 3566 (  pg_event_trigger_dropped_objects		PGNSP PGUID 12 10 100 0 0 f f f f t t s 0 0 2249 "" "{26,26,23,25,25,25,25}" "{o,o,o,o,o,o,o}" "{classid, objid, objsubid, object_type, schema_name, object_name, object_identity}" _null_ pg_event_trigger_dropped_objects _null_ _null_ _null_ ));
 DESCR("list objects dropped by the current command");
+DATA(insert OID = 3567 (  pg_event_trigger_get_creation_commands PGNSP PGUID 12 10 100 0 0 f f f f t t s 0 0 2249 "" "{25,114}" "{o,o}" "{identity,command}" _null_ pg_event_trigger_get_creation_commands _null_ _null_ _null_ ));
+DESCR("list objects created by the current command");
+DATA(insert OID = 3568 (  pg_event_trigger_expand_command PGNSP PGUID 12 10 1 0 0 f f f f t f s 1 0 25 "114" _null_ _null_ _null_ _null_ pg_event_trigger_expand_command _null_ _null_ _null_ ));
+DESCR("format JSON message");
 
 /* generic transition functions for ordered-set aggregates */
 DATA(insert OID = 3970 ( ordered_set_transition			PGNSP PGUID 12 1 0 0 0 f f f f f f i 2 0 2281 "2281 2276" _null_ _null_ _null_ _null_ ordered_set_transition _null_ _null_ _null_ ));
diff --git a/src/include/commands/alter_table.h b/src/include/commands/alter_table.h
new file mode 100644
index 0000000..0974098
--- /dev/null
+++ b/src/include/commands/alter_table.h
@@ -0,0 +1,53 @@
+#ifndef ALTER_TABLE_H
+#define ALTER_TABLE_H
+
+/*
+ * State information for ALTER TABLE
+ *
+ * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
+ * structs, one for each table modified by the operation (the named table
+ * plus any child tables that are affected).  We save lists of subcommands
+ * to apply to this table (possibly modified by parse transformation steps);
+ * these lists will be executed in Phase 2.  If a Phase 3 step is needed,
+ * necessary information is stored in the constraints and newvals lists.
+ *
+ * Phase 2 is divided into multiple passes; subcommands are executed in
+ * a pass determined by subcommand type.
+ */
+
+#define AT_PASS_UNSET			-1		/* UNSET will cause ERROR */
+#define AT_PASS_DROP			0		/* DROP (all flavors) */
+#define AT_PASS_ALTER_TYPE		1		/* ALTER COLUMN TYPE */
+#define AT_PASS_OLD_INDEX		2		/* re-add existing indexes */
+#define AT_PASS_OLD_CONSTR		3		/* re-add existing constraints */
+#define AT_PASS_COL_ATTRS		4		/* set other column attributes */
+/* We could support a RENAME COLUMN pass here, but not currently used */
+#define AT_PASS_ADD_COL			5		/* ADD COLUMN */
+#define AT_PASS_ADD_INDEX		6		/* ADD indexes */
+#define AT_PASS_ADD_CONSTR		7		/* ADD constraints, defaults */
+#define AT_PASS_MISC			8		/* other stuff */
+#define AT_NUM_PASSES			9
+
+typedef struct AlteredTableInfo
+{
+	/* Information saved before any work commences: */
+	Oid			relid;			/* Relation to work on */
+	char		relkind;		/* Its relkind */
+	TupleDesc	oldDesc;		/* Pre-modification tuple descriptor */
+	/* Information saved by Phase 1 for Phase 2: */
+	List	   *subcmds[AT_NUM_PASSES]; /* Lists of AlterTableCmd */
+	/* Information saved by Phases 1/2 for Phase 3: */
+	List	   *constraints;	/* List of NewConstraint */
+	List	   *newvals;		/* List of NewColumnValue */
+	bool		new_notnull;	/* T if we added new NOT NULL constraints */
+	bool		rewrite;		/* T if a rewrite is forced */
+	Oid			newTableSpace;	/* new tablespace; 0 means no change */
+	/* Objects to rebuild after completing ALTER TYPE operations */
+	List	   *changedConstraintOids;	/* OIDs of constraints to rebuild */
+	List	   *changedConstraintDefs;	/* string definitions of same */
+	List	   *changedIndexOids;		/* OIDs of indexes to rebuild */
+	List	   *changedIndexDefs;		/* string definitions of same */
+} AlteredTableInfo;
+
+
+#endif	/* ALTER_TABLE_H */
diff --git a/src/include/commands/createas.h b/src/include/commands/createas.h
index c17d829..477339d 100644
--- a/src/include/commands/createas.h
+++ b/src/include/commands/createas.h
@@ -19,7 +19,7 @@
 #include "tcop/dest.h"
 
 
-extern void ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
+extern Oid	ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 				  ParamListInfo params, char *completionTag);
 
 extern int	GetIntoRelEFlags(IntoClause *intoClause);
diff --git a/src/include/commands/event_trigger.h b/src/include/commands/event_trigger.h
index 0233f4c..3505e2b 100644
--- a/src/include/commands/event_trigger.h
+++ b/src/include/commands/event_trigger.h
@@ -49,6 +49,8 @@ extern void EventTriggerSQLDrop(Node *parsetree);
 
 extern bool EventTriggerBeginCompleteQuery(void);
 extern void EventTriggerEndCompleteQuery(void);
+extern void EventTriggerStashCreatedObject(Oid objectId, Oid classId,
+							   Node *parsetree);
 extern bool trackDroppedObjectsNeeded(void);
 extern void EventTriggerSQLDropAddObject(ObjectAddress *object);
 
diff --git a/src/include/commands/matview.h b/src/include/commands/matview.h
index 476b285..2c468b2 100644
--- a/src/include/commands/matview.h
+++ b/src/include/commands/matview.h
@@ -22,7 +22,7 @@
 
 extern void SetMatViewPopulatedState(Relation relation, bool newstate);
 
-extern void ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
+extern Oid ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 				   ParamListInfo params, char *completionTag);
 
 extern DestReceiver *CreateTransientRelDestReceiver(Oid oid);
diff --git a/src/include/commands/sequence.h b/src/include/commands/sequence.h
index 7d8a370..b7a5db4 100644
--- a/src/include/commands/sequence.h
+++ b/src/include/commands/sequence.h
@@ -70,6 +70,7 @@ extern Datum setval3_oid(PG_FUNCTION_ARGS);
 extern Datum lastval(PG_FUNCTION_ARGS);
 
 extern Datum pg_sequence_parameters(PG_FUNCTION_ARGS);
+extern Form_pg_sequence get_sequence_values(Oid sequenceId);
 
 extern Oid	DefineSequence(CreateSeqStmt *stmt);
 extern Oid	AlterSequence(AlterSeqStmt *stmt);
diff --git a/src/include/tcop/deparse_utility.h b/src/include/tcop/deparse_utility.h
new file mode 100644
index 0000000..7e63f52
--- /dev/null
+++ b/src/include/tcop/deparse_utility.h
@@ -0,0 +1,17 @@
+/*-------------------------------------------------------------------------
+ *
+ * deparse_utility.h
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/tcop/deparse_utility.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DEPARSE_UTILITY_H
+#define DEPARSE_UTILITY_H
+
+extern char *deparse_utility_command(Oid objectId, Node *parsetree);
+
+#endif	/* DEPARSE_UTILITY_H */
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index b90d88d..9b6d31f 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -663,15 +663,25 @@ extern Datum pg_get_viewdef_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_viewdef_wrap(PG_FUNCTION_ARGS);
 extern Datum pg_get_viewdef_name(PG_FUNCTION_ARGS);
 extern Datum pg_get_viewdef_name_ext(PG_FUNCTION_ARGS);
+extern char *pg_get_viewdef_internal(Oid viewoid);
 extern Datum pg_get_indexdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_indexdef_ext(PG_FUNCTION_ARGS);
 extern char *pg_get_indexdef_string(Oid indexrelid);
 extern char *pg_get_indexdef_columns(Oid indexrelid, bool pretty);
+extern char *pg_get_indexdef_internal(Oid indexrelid);
+extern void pg_get_indexdef_detailed(Oid indexrelid,
+						 char **index_am,
+						 char **definition,
+						 char **reloptions,
+						 char **tablespace,
+						 char **whereClause);
+
 extern Datum pg_get_triggerdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_triggerdef_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_constraintdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_constraintdef_ext(PG_FUNCTION_ARGS);
-extern char *pg_get_constraintdef_string(Oid constraintId);
+extern char *pg_get_constraintdef_string(Oid constraintId, bool fullCommand);
+extern char *pg_get_viewstmt_definition(Query *viewParse);
 extern Datum pg_get_expr(PG_FUNCTION_ARGS);
 extern Datum pg_get_expr_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_userbyid(PG_FUNCTION_ARGS);
@@ -1057,6 +1067,9 @@ extern char *format_type_be_qualified(Oid type_oid);
 extern char *format_type_with_typemod(Oid type_oid, int32 typemod);
 extern Datum oidvectortypes(PG_FUNCTION_ARGS);
 extern int32 type_maximum_size(Oid type_oid, int32 typemod);
+extern void format_type_detailed(Oid type_oid, int32 typemod,
+					 char **nspname, char **typname,
+					 char **typemodstr, bool *is_array);
 
 /* quote.c */
 extern Datum quote_ident(PG_FUNCTION_ARGS);
@@ -1177,6 +1190,8 @@ extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
 /* commands/event_trigger.c */
 extern Datum pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS);
+extern Datum pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS);
+extern Datum pg_event_trigger_expand_command(PG_FUNCTION_ARGS);
 
 /* commands/extension.c */
 extern Datum pg_available_extensions(PG_FUNCTION_ARGS);

diff --git a/src/backend/catalog/objectaddress.c b/src/backend/catalog/objectaddress.c
index ea81223..a2ad07f 100644
--- a/src/backend/catalog/objectaddress.c
+++ b/src/backend/catalog/objectaddress.c
@@ -708,6 +708,122 @@ get_object_address(ObjectType objtype, List *objname, List *objargs,
 }
 
 /*
+ * Return the OID of the catalog corresponding to the given object type
+ */
+Oid
+get_objtype_catalog_oid(ObjectType objtype)
+{
+	Oid		catalog_id;
+
+	switch (objtype)
+	{
+		case OBJECT_INDEX:
+		case OBJECT_SEQUENCE:
+		case OBJECT_TABLE:
+		case OBJECT_VIEW:
+		case OBJECT_MATVIEW:
+		case OBJECT_FOREIGN_TABLE:
+			catalog_id = RelationRelationId;
+			break;
+		case OBJECT_COLUMN:
+			catalog_id = AttributeRelationId;
+			break;
+		case OBJECT_RULE:
+			catalog_id = RewriteRelationId;
+			break;
+		case OBJECT_TRIGGER:
+			catalog_id = TriggerRelationId;
+			break;
+		case OBJECT_CONSTRAINT:
+			catalog_id = ConstraintRelationId;
+			break;
+		case OBJECT_DATABASE:
+			catalog_id = DatabaseRelationId;
+			break;
+		case OBJECT_EXTENSION:
+			catalog_id = ExtensionRelationId;
+			break;
+		case OBJECT_TABLESPACE:
+			catalog_id = TableSpaceRelationId;
+			break;
+		case OBJECT_ROLE:
+			catalog_id = AuthIdRelationId;
+			break;
+		case OBJECT_SCHEMA:
+			catalog_id = NamespaceRelationId;
+			break;
+		case OBJECT_LANGUAGE:
+			catalog_id = LanguageRelationId;
+			break;
+		case OBJECT_FDW:
+			catalog_id = ForeignDataWrapperRelationId;
+			break;
+		case OBJECT_FOREIGN_SERVER:
+			catalog_id = ForeignServerRelationId;
+			break;
+		case OBJECT_USER_MAPPING:
+			catalog_id = UserMappingRelationId;
+			break;
+		case OBJECT_EVENT_TRIGGER:
+			catalog_id = EventTriggerRelationId;
+			break;
+		case OBJECT_TYPE:
+		case OBJECT_DOMAIN:
+			catalog_id = TypeRelationId;
+			break;
+		case OBJECT_ATTRIBUTE:
+			catalog_id = TypeRelationId;	/* XXX? */
+			break;
+		case OBJECT_AGGREGATE:
+			catalog_id = ProcedureRelationId;
+			break;
+		case OBJECT_FUNCTION:
+			catalog_id = ProcedureRelationId;
+			break;
+		case OBJECT_OPERATOR:
+			catalog_id = OperatorRelationId;
+			break;
+		case OBJECT_COLLATION:
+			catalog_id = CollationRelationId;
+			break;
+		case OBJECT_CONVERSION:
+			catalog_id = ConversionRelationId;
+			break;
+		case OBJECT_OPCLASS:
+			catalog_id = OperatorClassRelationId;
+			break;
+		case OBJECT_OPFAMILY:
+			catalog_id = OperatorFamilyRelationId;
+			break;
+		case OBJECT_LARGEOBJECT:
+			catalog_id = LargeObjectRelationId;
+			break;
+		case OBJECT_CAST:
+			catalog_id = CastRelationId;
+			break;
+		case OBJECT_TSPARSER:
+			catalog_id = TSParserRelationId;
+			break;
+		case OBJECT_TSDICTIONARY:
+			catalog_id = TSDictionaryRelationId;
+			break;
+		case OBJECT_TSTEMPLATE:
+			catalog_id = TSTemplateRelationId;
+			break;
+		case OBJECT_TSCONFIGURATION:
+			catalog_id = TSConfigRelationId;
+			break;
+		default:
+				elog(ERROR, "unrecognized objtype: %d", (int) objtype);
+				/* placate compiler, in case it thinks elog might return */
+				catalog_id = InvalidOid;
+	}
+
+	/* Return the object address and the relation. */
+	return catalog_id;
+}
+
+/*
  * Find an ObjectAddress for a type of object that is identified by an
  * unqualified name.
  */
diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 73e6e20..bdc15f1 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -55,6 +55,9 @@ typedef struct
 	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);
@@ -64,7 +67,7 @@ static void intorel_destroy(DestReceiver *self);
 /*
  * ExecCreateTableAs -- execute a CREATE TABLE AS command
  */
-void
+Oid
 ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 				  ParamListInfo params, char *completionTag)
 {
@@ -75,6 +78,7 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 	Oid			save_userid = InvalidOid;
 	int			save_sec_context = 0;
 	int			save_nestlevel = 0;
+	Oid			relOid;
 	List	   *rewritten;
 	PlannedStmt *plan;
 	QueryDesc  *queryDesc;
@@ -98,7 +102,9 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		Assert(!is_matview);	/* excluded by syntax */
 		ExecuteQuery(estmt, into, queryString, params, dest, completionTag);
 
-		return;
+		relOid = CreateAsRelid;
+		CreateAsRelid = InvalidOid;
+		return relOid;
 	}
 	Assert(query->commandType == CMD_SELECT);
 
@@ -190,6 +196,11 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		/* Restore userid and security context */
 		SetUserIdAndSecContext(save_userid, save_sec_context);
 	}
+
+	relOid = CreateAsRelid;
+	CreateAsRelid = InvalidOid;
+
+	return relOid;
 }
 
 /*
@@ -421,6 +432,9 @@ intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
 	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.
diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index 59f0842..77952d4 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -31,10 +31,12 @@
 #include "pgstat.h"
 #include "lib/ilist.h"
 #include "miscadmin.h"
+#include "tcop/deparse_utility.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/evtcache.h"
 #include "utils/fmgroids.h"
+#include "utils/json.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/rel.h"
@@ -48,6 +50,7 @@ typedef struct EventTriggerQueryState
 	slist_head	SQLDropList;
 	bool		in_sql_drop;
 	MemoryContext cxt;
+	List	   *stash;
 	struct EventTriggerQueryState *previous;
 } EventTriggerQueryState;
 
@@ -491,7 +494,7 @@ AlterEventTriggerOwner(const char *name, Oid newOwnerId)
 }
 
 /*
- * Change extension owner, by OID
+ * Change event trigger owner, by OID
  */
 void
 AlterEventTriggerOwner_oid(Oid trigOid, Oid newOwnerId)
@@ -946,6 +949,7 @@ EventTriggerSupportsObjectType(ObjectType obtype)
 		case OBJECT_TSPARSER:
 		case OBJECT_TSTEMPLATE:
 		case OBJECT_TYPE:
+		case OBJECT_USER_MAPPING:
 		case OBJECT_VIEW:
 			return true;
 	}
@@ -1022,13 +1026,6 @@ EventTriggerBeginCompleteQuery(void)
 	EventTriggerQueryState *state;
 	MemoryContext cxt;
 
-	/*
-	 * Currently, sql_drop 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_MINSIZE,
@@ -1036,8 +1033,10 @@ EventTriggerBeginCompleteQuery(void)
 								ALLOCSET_DEFAULT_MAXSIZE);
 	state = MemoryContextAlloc(cxt, sizeof(EventTriggerQueryState));
 	state->cxt = cxt;
-	slist_init(&(state->SQLDropList));
+	if (trackDroppedObjectsNeeded())
+		slist_init(&(state->SQLDropList));
 	state->in_sql_drop = false;
+	state->stash = NIL;
 
 	state->previous = currentEventTriggerState;
 	currentEventTriggerState = state;
@@ -1217,7 +1216,7 @@ pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 		 errmsg("%s can only be called in a sql_drop event trigger function",
-				"pg_event_trigger_dropped_objects()")));
+				PG_FUNCNAME_MACRO)));
 
 	/* check to see if caller supports us returning a tuplestore */
 	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
@@ -1294,3 +1293,776 @@ pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)
 
 	return (Datum) 0;
 }
+
+/*
+ * Support for tracking of objects created during command run.
+ *
+ * When a command is run that creates some SQL objects, we collect the
+ * classid/objid of the objects being created, as well as the parsetree of the
+ * creation command; later, when event triggers are run for that command, they
+ * can use pg_event_trigger_get_creation_commands which computes and returns a
+ * usable representation of the creation commands for the objects.
+ */
+typedef struct stashedObject
+{
+	Oid			objectId;
+	ObjectType	objtype;
+	Node	   *parsetree;
+} stashedObject;
+
+void
+EventTriggerStashCommand(Oid objectId, ObjectType objtype, Node *parsetree)
+{
+	MemoryContext oldcxt;
+	stashedObject *stashed;
+
+	oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
+
+	stashed = palloc(sizeof(stashedObject));
+
+	stashed->objectId = objectId;
+	stashed->objtype = objtype;
+	stashed->parsetree = copyObject(parsetree);
+
+	currentEventTriggerState->stash = lappend(currentEventTriggerState->stash,
+											  stashed);
+
+	MemoryContextSwitchTo(oldcxt);
+}
+
+Datum
+pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+	TupleDesc	tupdesc;
+	Tuplestorestate *tupstore;
+	MemoryContext per_query_ctx;
+	MemoryContext oldcontext;
+	ListCell   *lc;
+
+	/*
+	 * Protect this function from being called out of context
+	 */
+	if (!currentEventTriggerState)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("%s can only be called in an event trigger function",
+						PG_FUNCNAME_MACRO)));
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	/* Build a tuple descriptor for our result type */
+	if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
+		elog(ERROR, "return type must be a row type");
+
+	/* Build tuplestore to hold the result rows */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupstore = tuplestore_begin_heap(true, false, work_mem);
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	MemoryContextSwitchTo(oldcontext);
+
+	foreach(lc, currentEventTriggerState->stash)
+	{
+		stashedObject *obj = lfirst(lc);
+		char	   *command;
+
+		command = deparse_utility_command(obj->objectId, obj->parsetree);
+
+		/*
+		 * Some parse trees return NULL when deparse is attempted; we don't
+		 * emit anything for them.
+		 */
+		if (command != NULL)
+		{
+			Datum		values[2];
+			bool		nulls[2];
+			ObjectAddress addr;
+			char	   *identity;
+			int			i = 0;
+
+			addr.classId = get_objtype_catalog_oid(obj->objtype);
+			addr.objectId = obj->objectId;
+			addr.objectSubId = 0;
+			identity = getObjectIdentity(&addr);
+
+			MemSet(nulls, 0, sizeof(nulls));
+
+			/* identity */
+			values[i++] = CStringGetTextDatum(identity);
+			/* command */
+			values[i++] = CStringGetTextDatum(command);
+
+			tuplestore_putvalues(tupstore, tupdesc, values, nulls);
+			pfree(identity);
+		}
+	}
+
+	/* clean up and return the tuplestore */
+	tuplestore_donestoring(tupstore);
+
+	PG_RETURN_VOID();
+}
+
+/* ************************* JSON STUFF FROM HERE ************************* *
+ *	Code below is used to decode blobs returned by deparse_utility_command	*
+ *																			*/
+
+/*
+ * Note we only support types that are valid in command representation from
+ * deparse_utility_command.
+ */
+typedef enum
+{
+	JsonIsArray,
+	JsonIsObject,
+	JsonIsString
+} JsonType;
+
+typedef enum
+{
+	SpecTypename,
+	SpecOperatorname,
+	SpecDottedName,
+	SpecString,
+	SpecIdentifier
+} convSpecifier;
+
+/*
+ * Extract the named json field, which must be of type string, from the given
+ * JSON datum, which must be of type object.  If the field doesn't exist,
+ * NULL is returned.  Otherwise the string value is returned.
+ */
+static char *
+expand_get_strval(Datum json, char *field_name)
+{
+	FunctionCallInfoData fcinfo;
+	Datum		result;
+	char	   *value_str;
+
+	InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+
+	fcinfo.arg[0] = json;
+	fcinfo.argnull[0] = false;
+	fcinfo.arg[1] = CStringGetTextDatum(field_name);
+	fcinfo.argnull[1] = false;
+
+	result = (*json_object_field_text) (&fcinfo);
+
+	if (fcinfo.isnull)
+		return NULL;
+
+	value_str = TextDatumGetCString(result);
+
+	pfree(DatumGetPointer(result));
+
+	return value_str;
+}
+
+/*
+ * Extract the named json field, which must be of type boolean, from the given
+ * JSON datum, which must be of type object.  If the field doesn't exist,
+ * isnull is set to TRUE and the return value should not be consulted.
+ * Otherwise the boolean value is returned.
+ */
+static bool
+expand_get_boolval(Datum json, char *field_name, bool *isnull)
+{
+	FunctionCallInfoData fcinfo;
+	Datum		result;
+	char	   *value_str;
+
+	InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+
+	fcinfo.arg[0] = json;
+	fcinfo.argnull[0] = false;
+	fcinfo.arg[1] = CStringGetTextDatum(field_name);
+	fcinfo.argnull[1] = false;
+
+	result = (*json_object_field_text) (&fcinfo);
+
+	if (fcinfo.isnull)
+	{
+		*isnull = true;
+		return false;
+	}
+
+	value_str = TextDatumGetCString(result);
+
+	if (strcmp(value_str, "true") == 0)
+		return true;
+
+	Assert(strcmp(value_str, "false") == 0);
+	return false;
+}
+
+/*
+ * Given a JSON value, return its type.
+ *
+ * We return both a JsonType (for easy control flow), and a string name (for
+ * error reporting).
+ */
+static JsonType
+jsonval_get_type(Datum jsonval, char **typename)
+{
+	JsonType	json_elt_type;
+	Datum		paramtype_datum;
+	char	   *paramtype;
+
+	paramtype_datum = DirectFunctionCall1(json_typeof, jsonval);
+	paramtype = TextDatumGetCString(paramtype_datum);
+
+	if (strcmp(paramtype, "array") == 0)
+		json_elt_type = JsonIsArray;
+	else if (strcmp(paramtype, "object") == 0)
+		json_elt_type = JsonIsObject;
+	else if (strcmp(paramtype, "string") == 0)
+		json_elt_type = JsonIsString;
+	else
+		/* XXX improve this; need to specify array index or param name */
+		elog(ERROR, "unexpected JSON element type %s",
+			 paramtype);
+
+	if (typename)
+		*typename = pstrdup(paramtype);
+
+	return json_elt_type;
+}
+
+/*
+ * dequote_jsonval
+ *		Take a string value extracted from a JSON object, and return a copy of it
+ *		with the quoting removed.
+ *
+ * Another alternative to this would be to run the extraction routine again,
+ * using the "_text" variant which returns the value without quotes; but this
+ * is expensive, and moreover it complicates the logic a lot because not all
+ * values are extracted in the same way (some are extracted using
+ * json_object_field, others using json_array_element).  Dequoting the object
+ * already at hand is a lot easier.
+ */
+static char *
+dequote_jsonval(char *jsonval)
+{
+	char	   *result;
+	int			inputlen = strlen(jsonval);
+	int			i;
+	int			j = 0;
+
+	result = palloc(strlen(jsonval) + 1);
+
+	/* skip the start and end quotes right away */
+	for (i = 1; i < inputlen - 1; i++)
+	{
+		/*
+		 * XXX this skips the \ in a \" sequence but leaves other escaped
+		 * sequences in place.	Are there other cases we need to handle
+		 * specially?
+		 */
+		if (jsonval[i] == '\\' &&
+			jsonval[i + 1] == '"')
+		{
+			i++;
+			continue;
+		}
+
+		result[j++] = jsonval[i];
+	}
+	result[j] = '\0';
+
+	return result;
+}
+
+/*
+ * Expand a json value as an identifier.  The value must be of type string.
+ */
+static void
+expand_jsonval_identifier(StringInfo buf, Datum jsonval)
+{
+	char	   *unquoted;
+
+	unquoted = dequote_jsonval(TextDatumGetCString(jsonval));
+	appendStringInfo(buf, "%s", quote_identifier(unquoted));
+
+	pfree(unquoted);
+}
+
+/*
+ * Expand a json value as a dotted-name.  The value must be of type object
+ * and must contain elements "schemaname" (optional), "objname" (mandatory),
+ * "attrname" (optional).
+ *
+ * XXX do we need a "catalogname" as well?
+ */
+static void
+expand_jsonval_dottedname(StringInfo buf, Datum jsonval)
+{
+	char	   *schema;
+	char	   *objname;
+	char	   *attrname;
+	const char *qschema;
+	const char *qname;
+
+	schema = expand_get_strval(jsonval, "schemaname");
+	objname = expand_get_strval(jsonval, "objname");
+	if (objname == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid NULL object name in %%D element")));
+	qname = quote_identifier(objname);
+	if (schema == NULL)
+	{
+		appendStringInfo(buf, "%s", qname);
+	}
+	else
+	{
+		qschema = quote_identifier(schema);
+		appendStringInfo(buf, "%s.%s",
+						 qschema, qname);
+		if (qschema != schema)
+			pfree((char *) qschema);
+		pfree(schema);
+	}
+
+	attrname = expand_get_strval(jsonval, "attrname");
+	if (attrname)
+	{
+		const char *qattr;
+
+		qattr = quote_identifier(attrname);
+		appendStringInfo(buf, ".%s", qattr);
+		if (qattr != attrname)
+			pfree((char *) qattr);
+		pfree(attrname);
+	}
+
+	if (qname != objname)
+		pfree((char *) qname);
+	pfree(objname);
+}
+
+/*
+ * expand a json value as a type name.
+ */
+static void
+expand_jsonval_typename(StringInfo buf, Datum jsonval)
+{
+	char	   *schema = NULL;
+	char	   *typename;
+	char	   *typmodstr;
+	bool		array_isnull;
+	bool		is_array;
+
+	typename = expand_get_strval(jsonval, "typename");
+	if (typename == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid NULL type name in %%T element")));
+	typmodstr = expand_get_strval(jsonval, "typmod");	/* OK if null */
+	is_array = expand_get_boolval(jsonval, "is_array", &array_isnull);
+	schema = expand_get_strval(jsonval, "schemaname");
+
+	/* schema might be NULL or empty here, beware */
+	if (schema == NULL || schema[0] == '\0')
+		appendStringInfo(buf, "%s%s%s",
+						 quote_identifier(typename),
+						 typmodstr ? typmodstr : "",
+						 is_array ? "[]" : "");
+	else
+		appendStringInfo(buf, "%s.%s%s%s",
+						 quote_identifier(schema),
+						 quote_identifier(typename),
+						 typmodstr ? typmodstr : "",
+						 is_array ? "[]" : "");
+}
+
+/*
+ * Expand a json value as an operator name
+ */
+static void
+expand_jsonval_operator(StringInfo buf, Datum jsonval)
+{
+	char	   *schema = NULL;
+	char	   *operator;
+
+	operator = expand_get_strval(jsonval, "objname");
+	if (operator == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid NULL operator name in %%O element")));
+	schema = expand_get_strval(jsonval, "schemaname");
+
+	/* schema might be NULL or empty */
+	if (schema == NULL || schema[0] == '\0')
+		appendStringInfo(buf, "%s", operator);
+	else
+		appendStringInfo(buf, "%s.%s",
+						 quote_identifier(schema),
+						 operator);
+}
+
+/*
+ * Expand a json value as a string.  The value must be of type string or of
+ * type object, in which case it must contain a "fmt" element which will be
+ * recursively expanded; also, if the object contains an element "present"
+ * and it is set to false, the expansion is the empty string.
+ */
+static void
+expand_jsonval_string(StringInfo buf, Datum jsonval, JsonType json_elt_type)
+{
+	if (json_elt_type == JsonIsString)
+	{
+		char	   *str;
+		char	   *unquoted;
+
+		str = TextDatumGetCString(jsonval);
+		unquoted = dequote_jsonval(str);
+		appendStringInfo(buf, "%s", unquoted);
+		pfree(str);
+		pfree(unquoted);
+	}
+	else if (json_elt_type == JsonIsObject)
+	{
+		bool		present;
+		bool		isnull;
+
+		present = expand_get_boolval(jsonval, "present", &isnull);
+
+		if (isnull || present)
+		{
+			Datum		inner;
+			char	   *str;
+
+			inner = DirectFunctionCall1(pg_event_trigger_expand_command,
+										jsonval);
+			str = TextDatumGetCString(inner);
+
+			appendStringInfoString(buf, str);
+			pfree(DatumGetPointer(inner));
+			pfree(str);
+		}
+	}
+}
+
+/*
+ * Expand one json element according to rules.
+ */
+static void
+expand_one_element(StringInfo buf, char *param,
+				   Datum jsonval, char *valtype, JsonType json_elt_type,
+				   convSpecifier specifier)
+{
+	/*
+	 * Validate the parameter type.  If dotted-name was specified, then a JSON
+	 * object element is expected; if an identifier was specified, then a JSON
+	 * string is expected.	If a string was specified, then either a JSON
+	 * object or a string is expected.
+	 */
+	if (specifier == SpecDottedName && json_elt_type != JsonIsObject)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON object for %%D element \"%s\", got %s",
+						param, valtype)));
+	if (specifier == SpecTypename && json_elt_type != JsonIsObject)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON object for %%T element \"%s\", got %s",
+						param, valtype)));
+	if (specifier == SpecOperatorname && json_elt_type != JsonIsObject)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON object for %%O element \"%s\", got %s",
+						param, valtype)));
+	if (specifier == SpecIdentifier && json_elt_type != JsonIsString)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON string for %%I element \"%s\", got %s",
+						param, valtype)));
+	if (specifier == SpecString &&
+		json_elt_type != JsonIsString && json_elt_type != JsonIsObject)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("expected JSON string or object for %%s element \"%s\", got %s",
+						param, valtype)));
+
+	switch (specifier)
+	{
+		case SpecIdentifier:
+			expand_jsonval_identifier(buf, jsonval);
+			break;
+
+		case SpecDottedName:
+			expand_jsonval_dottedname(buf, jsonval);
+			break;
+
+		case SpecString:
+			expand_jsonval_string(buf, jsonval, json_elt_type);
+			break;
+
+		case SpecTypename:
+			expand_jsonval_typename(buf, jsonval);
+			break;
+
+		case SpecOperatorname:
+			expand_jsonval_operator(buf, jsonval);
+			break;
+	}
+}
+
+/*
+ * Expand one JSON array element according to rules.
+ */
+static void
+expand_one_array_element(StringInfo buf, Datum array, int idx, char *param,
+						 convSpecifier specifier)
+{
+	Datum		elemval;
+	JsonType	json_elt_type;
+	char	   *elemtype;
+
+	elemval = DirectFunctionCall2(json_array_element,
+								  PointerGetDatum(array),
+								  Int32GetDatum(idx));
+	json_elt_type = jsonval_get_type(elemval, &elemtype);
+
+	expand_one_element(buf, param,
+					   elemval, elemtype, json_elt_type,
+					   specifier);
+}
+
+#define ADVANCE_PARSE_POINTER(ptr,end_ptr) \
+	do { \
+		if (++(ptr) >= (end_ptr)) \
+			ereport(ERROR, \
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+					 errmsg("unterminated format specifier"))); \
+	} while (0)
+
+/*------
+ * Returns a formatted string from a JSON object.
+ *
+ * The starting point is the element named "fmt" (which must be a string).
+ * This format string may contain zero or more %-escapes, which consist of an
+ * element name enclosed in { }, possibly followed by a conversion modifier,
+ * followed by a conversion specifier.	Possible conversion specifiers are:
+ *
+ * %		expand to a literal %.
+ * I		expand as a single, non-qualified identifier
+ * D		expand as a possibly-qualified identifier
+ * T		expand as a type name
+ * O		expand as an operator name
+ * s		expand as a simple string (no quoting)
+ *
+ * The element name may have an optional separator specification preceded
+ * by a colon.	Its presence indicates that the element is expected to be
+ * an array; the specified separator is used to join the array elements.
+ *
+ * XXX the current implementation works fine, but is likely to be slow: for
+ * each element found in the fmt string we parse the JSON object once.	It
+ * might be better to use jsonapi.h directly so that we build a hash or tree of
+ * elements and their values once before parsing the fmt string, and later scan
+ * fmt using the tree.
+ *------
+ */
+Datum
+pg_event_trigger_expand_command(PG_FUNCTION_ARGS)
+{
+	text	   *json = PG_GETARG_TEXT_P(0);
+	char	   *fmt_str;
+	int			fmt_len;
+	const char *cp;
+	const char *start_ptr;
+	const char *end_ptr;
+	StringInfoData str;
+
+	fmt_str = expand_get_strval(PointerGetDatum(json), "fmt");
+	if (fmt_str == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid NULL format string")));
+	fmt_len = strlen(fmt_str);
+
+	start_ptr = fmt_str;
+	end_ptr = start_ptr + fmt_len;
+	initStringInfo(&str);
+
+	for (cp = start_ptr; cp < end_ptr; cp++)
+	{
+		convSpecifier specifier;
+		bool		is_array;
+		char	   *param = NULL;
+		char	   *arraysep = NULL;
+		Datum		paramval;
+		char	   *paramtype;
+		JsonType	json_elt_type;
+
+		if (*cp != '%')
+		{
+			appendStringInfoCharMacro(&str, *cp);
+			continue;
+		}
+
+		is_array = false;
+
+		ADVANCE_PARSE_POINTER(cp, end_ptr);
+
+		/* Easy case: %% outputs a single % */
+		if (*cp == '%')
+		{
+			appendStringInfoCharMacro(&str, *cp);
+			continue;
+		}
+
+		/*
+		 * Scan the mandatory element name.  Allow for an array separator
+		 * (which may be the empty string) to be specified after colon.
+		 */
+		if (*cp == '{')
+		{
+			StringInfoData parbuf;
+			StringInfoData arraysepbuf;
+			StringInfo	appendTo;
+
+			initStringInfo(&parbuf);
+			appendTo = &parbuf;
+
+			ADVANCE_PARSE_POINTER(cp, end_ptr);
+			for (; cp < end_ptr;)
+			{
+				if (*cp == ':')
+				{
+					/*
+					 * found array separator delimiter; element name is now
+					 * complete, start filling the separator.
+					 */
+					initStringInfo(&arraysepbuf);
+					appendTo = &arraysepbuf;
+					is_array = true;
+					ADVANCE_PARSE_POINTER(cp, end_ptr);
+					continue;
+				}
+
+				if (*cp == '}')
+				{
+					ADVANCE_PARSE_POINTER(cp, end_ptr);
+					break;
+				}
+				appendStringInfoCharMacro(appendTo, *cp);
+				ADVANCE_PARSE_POINTER(cp, end_ptr);
+			}
+			param = parbuf.data;
+			if (is_array)
+				arraysep = arraysepbuf.data;
+		}
+		if (param == NULL)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("missing conversion name in conversion specifier")));
+
+		/*------
+		 * The following conversion specifiers are currently recognized:
+		 * 'I' -- expand as an identifier, adding quotes if necessary
+		 * 'D' -- expand as a dotted-name, for qualified names; each element is
+		 *		  quoted if necessary
+		 * 'O' -- expand as an operator name. Same as 'D', but the objname
+		 *		  element is not quoted.
+		 * 's' -- expand as a simple string; no quoting.
+		 * 'T' -- expand as a typename, with ad-hoc rules
+		 */
+		switch (*cp)
+		{
+			case 'I':
+				specifier = SpecIdentifier;
+				break;
+			case 'D':
+				specifier = SpecDottedName;
+				break;
+			case 's':
+				specifier = SpecString;
+				break;
+			case 'T':
+				specifier = SpecTypename;
+				break;
+			case 'O':
+				specifier = SpecOperatorname;
+				break;
+			default:
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("invalid conversion specifier \"%c\"", *cp)));
+		}
+
+		/*
+		 * Obtain the element to be expanded.  Note we cannot use
+		 * DirectFunctionCall here, because the element might not exist.
+		 */
+		{
+			FunctionCallInfoData fcinfo;
+
+			InitFunctionCallInfoData(fcinfo, NULL, 2, InvalidOid, NULL, NULL);
+
+			fcinfo.arg[0] = PointerGetDatum(json);
+			fcinfo.argnull[0] = false;
+			fcinfo.arg[1] = CStringGetTextDatum(param);
+			fcinfo.argnull[1] = false;
+
+			paramval = (*json_object_field) (&fcinfo);
+
+			if (fcinfo.isnull)
+			{
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("non-existant element \"%s\" in JSON formatting object",
+								param)));
+			}
+		}
+
+		/* figure out its type */
+		json_elt_type = jsonval_get_type(paramval, &paramtype);
+
+		/* Validate that we got an array if the format string specified one. */
+		if (is_array && json_elt_type != JsonIsArray)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("expected JSON array for element \"%s\", got %s",
+							param, paramtype)));
+
+		/* And finally print out the data */
+		if (is_array)
+		{
+			int			count;
+			bool		putsep = false;
+			int			i;
+
+			count = DatumGetInt32(DirectFunctionCall1(json_array_length,
+													  paramval));
+			for (i = 0; i < count; i++)
+			{
+				if (putsep)
+					appendStringInfoString(&str, arraysep);
+				putsep = true;
+
+				expand_one_array_element(&str, paramval, i, param, specifier);
+			}
+		}
+		else
+		{
+			expand_one_element(&str, param, paramval, paramtype, json_elt_type,
+							   specifier);
+		}
+	}
+
+	PG_RETURN_TEXT_P(CStringGetTextDatum(str.data));
+}
diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c
index a331f3e..0f0ecbe 100644
--- a/src/backend/commands/matview.c
+++ b/src/backend/commands/matview.c
@@ -132,7 +132,7 @@ SetMatViewPopulatedState(Relation relation, bool newstate)
  * The matview's "populated" state is changed based on whether the contents
  * reflect the result set of the materialized view's query.
  */
-void
+Oid
 ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 				   ParamListInfo params, char *completionTag)
 {
@@ -274,6 +274,8 @@ ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 	}
 	else
 		refresh_by_heap_swap(matviewOid, OIDNewHeap);
+
+	return matviewOid;
 }
 
 /*
diff --git a/src/backend/commands/schemacmds.c b/src/backend/commands/schemacmds.c
index 2599e28..0862aee 100644
--- a/src/backend/commands/schemacmds.c
+++ b/src/backend/commands/schemacmds.c
@@ -24,6 +24,7 @@
 #include "catalog/objectaccess.h"
 #include "catalog/pg_namespace.h"
 #include "commands/dbcommands.h"
+#include "commands/event_trigger.h"
 #include "commands/schemacmds.h"
 #include "miscadmin.h"
 #include "parser/parse_utilcmd.h"
@@ -130,6 +131,14 @@ CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString)
 	PushOverrideSearchPath(overridePath);
 
 	/*
+	 * Report the new schema to possibly interested event triggers.  Note we
+	 * must do this here and not in ProcessUtilitySlow because otherwise the
+	 * objects created below are reported before the schema, which would be
+	 * wrong.
+	 */
+	EventTriggerStashCommand(namespaceId, OBJECT_SCHEMA, (Node *) stmt);
+
+	/*
 	 * Examine the list of commands embedded in the CREATE SCHEMA command, and
 	 * reorganize them into a sequentially executable order with no forward
 	 * references.	Note that the result is still a list of raw parsetrees ---
diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index ed696be..564834e 100644
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -1552,7 +1552,42 @@ pg_sequence_parameters(PG_FUNCTION_ARGS)
 	return HeapTupleGetDatum(heap_form_tuple(tupdesc, values, isnull));
 }
 
+/*
+ * Return sequence parameters, detailed
+ */
+Form_pg_sequence
+get_sequence_values(Oid sequenceId)
+{
+	Buffer		buf;
+	SeqTable	elm;
+	Relation	seqrel;
+	HeapTupleData seqtuple;
+	Form_pg_sequence seq;
+	Form_pg_sequence retSeq;
+
+	retSeq = palloc(sizeof(FormData_pg_sequence));
+
+	/* open and AccessShareLock sequence */
+	init_sequence(sequenceId, &elm, &seqrel);
+
+	if (pg_class_aclcheck(sequenceId, GetUserId(),
+						  ACL_SELECT | ACL_UPDATE | ACL_USAGE) != ACLCHECK_OK)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for sequence %s",
+						RelationGetRelationName(seqrel))));
+
+	seq = read_seq_tuple(elm, seqrel, &buf, &seqtuple);
+
+	memcpy(retSeq, seq, sizeof(FormData_pg_sequence));
+
+	UnlockReleaseBuffer(buf);
+	relation_close(seqrel, NoLock);
+
+	return retSeq;
+}
 
+/* definition elements */
 void
 seq_redo(XLogRecPtr lsn, XLogRecord *record)
 {
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 08b037e..a6d38fa 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -43,6 +43,7 @@
 #include "catalog/pg_type_fn.h"
 #include "catalog/storage.h"
 #include "catalog/toasting.h"
+#include "commands/alter_table.h"
 #include "commands/cluster.h"
 #include "commands/comment.h"
 #include "commands/defrem.h"
@@ -112,54 +113,6 @@ typedef struct OnCommitItem
 static List *on_commits = NIL;
 
 
-/*
- * State information for ALTER TABLE
- *
- * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
- * structs, one for each table modified by the operation (the named table
- * plus any child tables that are affected).  We save lists of subcommands
- * to apply to this table (possibly modified by parse transformation steps);
- * these lists will be executed in Phase 2.  If a Phase 3 step is needed,
- * necessary information is stored in the constraints and newvals lists.
- *
- * Phase 2 is divided into multiple passes; subcommands are executed in
- * a pass determined by subcommand type.
- */
-
-#define AT_PASS_UNSET			-1		/* UNSET will cause ERROR */
-#define AT_PASS_DROP			0		/* DROP (all flavors) */
-#define AT_PASS_ALTER_TYPE		1		/* ALTER COLUMN TYPE */
-#define AT_PASS_OLD_INDEX		2		/* re-add existing indexes */
-#define AT_PASS_OLD_CONSTR		3		/* re-add existing constraints */
-#define AT_PASS_COL_ATTRS		4		/* set other column attributes */
-/* We could support a RENAME COLUMN pass here, but not currently used */
-#define AT_PASS_ADD_COL			5		/* ADD COLUMN */
-#define AT_PASS_ADD_INDEX		6		/* ADD indexes */
-#define AT_PASS_ADD_CONSTR		7		/* ADD constraints, defaults */
-#define AT_PASS_MISC			8		/* other stuff */
-#define AT_NUM_PASSES			9
-
-typedef struct AlteredTableInfo
-{
-	/* Information saved before any work commences: */
-	Oid			relid;			/* Relation to work on */
-	char		relkind;		/* Its relkind */
-	TupleDesc	oldDesc;		/* Pre-modification tuple descriptor */
-	/* Information saved by Phase 1 for Phase 2: */
-	List	   *subcmds[AT_NUM_PASSES]; /* Lists of AlterTableCmd */
-	/* Information saved by Phases 1/2 for Phase 3: */
-	List	   *constraints;	/* List of NewConstraint */
-	List	   *newvals;		/* List of NewColumnValue */
-	bool		new_notnull;	/* T if we added new NOT NULL constraints */
-	bool		rewrite;		/* T if a rewrite is forced */
-	Oid			newTableSpace;	/* new tablespace; 0 means no change */
-	/* Objects to rebuild after completing ALTER TYPE operations */
-	List	   *changedConstraintOids;	/* OIDs of constraints to rebuild */
-	List	   *changedConstraintDefs;	/* string definitions of same */
-	List	   *changedIndexOids;		/* OIDs of indexes to rebuild */
-	List	   *changedIndexDefs;		/* string definitions of same */
-} AlteredTableInfo;
-
 /* Struct describing one new constraint to check in Phase 3 scan */
 /* Note: new NOT NULL constraints are handled elsewhere */
 typedef struct NewConstraint
@@ -7762,7 +7715,8 @@ ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
 				if (!list_member_oid(tab->changedConstraintOids,
 									 foundObject.objectId))
 				{
-					char	   *defstring = pg_get_constraintdef_string(foundObject.objectId);
+					char	   *defstring = pg_get_constraintdef_string(foundObject.objectId,
+																		true);
 
 					/*
 					 * Put NORMAL dependencies at the front of the list and
diff --git a/src/backend/tcop/Makefile b/src/backend/tcop/Makefile
index 674302f..34acdce 100644
--- a/src/backend/tcop/Makefile
+++ b/src/backend/tcop/Makefile
@@ -12,7 +12,7 @@ subdir = src/backend/tcop
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS= dest.o fastpath.o postgres.o pquery.o utility.o
+OBJS= dest.o deparse_utility.o fastpath.o postgres.o pquery.o utility.o
 
 ifneq (,$(filter $(PORTNAME),cygwin win32))
 override CPPFLAGS += -DWIN32_STACK_RLIMIT=$(WIN32_STACK_RLIMIT)
diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
new file mode 100644
index 0000000..912d0a6
--- /dev/null
+++ b/src/backend/tcop/deparse_utility.c
@@ -0,0 +1,1620 @@
+/*-------------------------------------------------------------------------
+ *
+ * deparse_utility.c
+ *	  Functions to convert utility commands to machine-parseable
+ *	  representation
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * NOTES
+ *
+ * This is intended to provide JSON blobs representing DDL commands, which can
+ * later be re-processed into plain strings by well-defined sprintf-like
+ * expansion.  These JSON objects are intended to allow for machine-editing of
+ * the commands, by replacing certain nodes within the objects.
+ *
+ * Much of the information in the output blob actually comes from system
+ * catalogs, not from the command parse node, as it is impossible to reliably
+ * construct a fully-specified command (i.e. one not dependent on search_path
+ * etc) looking only at the parse node.
+ *
+ * IDENTIFICATION
+ *	  src/backend/tcop/deparse_utility.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "catalog/heap.h"
+#include "catalog/index.h"
+#include "catalog/namespace.h"
+#include "catalog/pg_aggregate.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_collation.h"
+#include "catalog/pg_constraint.h"
+#include "catalog/pg_depend.h"
+#include "catalog/pg_inherits.h"
+#include "catalog/pg_operator.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_type.h"
+#include "commands/defrem.h"
+#include "commands/sequence.h"
+#include "funcapi.h"
+#include "lib/ilist.h"
+#include "lib/stringinfo.h"
+#include "nodes/makefuncs.h"
+#include "nodes/parsenodes.h"
+#include "parser/analyze.h"
+#include "parser/parse_collate.h"
+#include "parser/parse_expr.h"
+#include "parser/parse_relation.h"
+#include "parser/parse_type.h"
+#include "rewrite/rewriteHandler.h"
+#include "tcop/deparse_utility.h"
+#include "utils/builtins.h"
+#include "utils/fmgroids.h"
+#include "utils/json.h"
+#include "utils/lsyscache.h"
+#include "utils/memutils.h"
+#include "utils/rel.h"
+#include "utils/syscache.h"
+
+
+typedef enum
+{
+	ObjTypeNull,
+	ObjTypeBool,
+	ObjTypeString,
+	ObjTypeArray,
+	ObjTypeObject
+} ObjType;
+
+typedef struct ObjElem
+{
+	char	   *name;
+	ObjType		objtype;
+	bool		bool_value;
+	char	   *str_value;
+	struct ObjTree *obj_value;
+	List	   *array_value;
+	slist_node	node;
+} ObjElem;
+
+typedef struct ObjTree
+{
+	MemoryContext cxt;
+	slist_head	params;
+	int			numParams;
+} ObjTree;
+
+
+static void append_null_object(ObjTree *tree, char *name);
+static void append_bool_object(ObjTree *tree, char *name,
+				   bool value);
+static void append_string_object(ObjTree *tree, char *name,
+					 char *value);
+static void append_object_object(ObjTree *tree, char *name,
+					 ObjTree *value);
+static void append_array_object(ObjTree *tree, char *name,
+					List *array);
+
+/*
+ * Allocate a new object tree to store parameter values.  If parent is NULL, a
+ * new memory context is created for all allocations involving the parameters;
+ * if it's not null, then the memory context from the given object is used.
+ */
+static ObjTree *
+new_objtree(ObjTree *parent)
+{
+	MemoryContext cxt;
+	ObjTree    *params;
+
+	if (parent == NULL)
+	{
+		cxt = AllocSetContextCreate(CurrentMemoryContext,
+									"deparse parameters",
+									ALLOCSET_DEFAULT_MINSIZE,
+									ALLOCSET_DEFAULT_INITSIZE,
+									ALLOCSET_DEFAULT_MAXSIZE);
+	}
+	else
+		cxt = parent->cxt;
+
+	params = MemoryContextAlloc(cxt, sizeof(ObjTree));
+	params->cxt = cxt;
+	params->numParams = 0;
+	slist_init(&params->params);
+
+	return params;
+}
+
+/*
+ * Allocate a new object to store parameters.  As above, if parent is NULL,
+ * a new memory context is created; otherwise the parent is used to extract
+ * the memory context to use.
+ *
+ * The "fmt" argument is used to append as a "fmt" element in the output blob.
+ * numobjs indicates the number of extra elements to append; for each one,
+ * a name, type and value must be supplied.  Note we don't have the luxury of
+ * sprintf-like compiler warnings for malformed argument lists.
+ */
+static ObjTree *
+new_objtree_VA(ObjTree *parent, char *fmt, int numobjs,...)
+{
+	ObjTree    *tree;
+	va_list		args;
+	int			i;
+
+	/* Set up the toplevel object and its "fmt" */
+	tree = new_objtree(parent);
+	append_string_object(tree, "fmt", fmt);
+
+	/* And process the given varargs */
+	va_start(args, numobjs);
+	for (i = 0; i < numobjs; i++)
+	{
+		ObjTree    *value;
+		ObjType		type;
+		char	   *name;
+		char	   *strval;
+		bool		boolval;
+		List	   *list;
+
+		name = va_arg(args, char *);
+		type = va_arg(args, ObjType);
+
+		/* Null params don't have a value (obviously) */
+		if (type == ObjTypeNull)
+		{
+			append_null_object(tree, name);
+			continue;
+		}
+
+		/*
+		 * For all other param types there must be a value in the varargs.
+		 * Fetch it and add the fully formed subobject into the main object.
+		 */
+		switch (type)
+		{
+			case ObjTypeBool:
+				boolval = va_arg(args, int);
+				append_bool_object(tree, name, boolval);
+				break;
+			case ObjTypeString:
+				strval = va_arg(args, char *);
+				append_string_object(tree, name, strval);
+				break;
+			case ObjTypeObject:
+				value = va_arg(args, ObjTree *);
+				append_object_object(tree, name, value);
+				break;
+			case ObjTypeArray:
+				list = va_arg(args, List *);
+				append_array_object(tree, name, list);
+				break;
+			default:
+				elog(ERROR, "invalid parameter type %d", type);
+		}
+	}
+
+	va_end(args);
+	return tree;
+}
+
+/*
+ * Add a new parameter with a NULL value
+ */
+static void
+append_null_object(ObjTree *tree, char *name)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeNull;
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Add a new boolean parameter
+ */
+static void
+append_bool_object(ObjTree *tree, char *name, bool value)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeBool;
+	param->bool_value = value;
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Add a new string parameter.
+ *
+ * Note: we don't pstrdup the source string.  Caller must ensure the
+ * source string lives long enough.
+ */
+static void
+append_string_object(ObjTree *tree, char *name, char *value)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeString;
+	param->str_value = value;	/* XXX not duped */
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Add a new object parameter
+ */
+static void
+append_object_object(ObjTree *tree, char *name, ObjTree *value)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeObject;
+	param->obj_value = value;	/* XXX not duped */
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Add a new array parameter
+ */
+static void
+append_array_object(ObjTree *tree, char *name, List *array)
+{
+	ObjElem    *param;
+
+	param = MemoryContextAllocZero(tree->cxt, sizeof(ObjElem));
+
+	param->name = MemoryContextStrdup(tree->cxt, name);
+	param->objtype = ObjTypeArray;
+	param->array_value = array; /* XXX not duped */
+
+	slist_push_head(&tree->params, &param->node);
+	tree->numParams++;
+}
+
+/*
+ * Create a JSON blob from our ad-hoc representation.
+ *
+ * Note this allocates memory in tree->cxt.  This is okay because we don't need
+ * a separate memory context, and the one provided by the tree object has the
+ * right lifetime already.
+ *
+ * XXX this implementation will fail if there are more JSON objects in the tree
+ * than the maximum number of columns in a heap tuple.  To fix we would first call
+ * construct_md_array and then json_object.
+ */
+static char *
+jsonize_objtree(ObjTree *tree)
+{
+	MemoryContext oldcxt;
+	TupleDesc	tupdesc;
+	Datum	   *values;
+	bool	   *nulls;
+	slist_iter	iter;
+	int			i;
+	HeapTuple	htup;
+	Datum		json;
+	char	   *jsonstr;
+
+	/*
+	 * Use the objtree's memory context, so that everything we allocate in
+	 * this routine (other than our return string) can be blown up easily
+	 * by our caller.
+	 */
+	oldcxt = MemoryContextSwitchTo(tree->cxt);
+	tupdesc = CreateTemplateTupleDesc(tree->numParams, false);
+	values = palloc(sizeof(Datum) * tree->numParams);
+	nulls = palloc(sizeof(bool) * tree->numParams);
+
+	i = 1;
+	slist_foreach(iter, &tree->params)
+	{
+		ObjElem    *object = slist_container(ObjElem, node, iter.cur);
+		Oid			typeid;
+
+		switch (object->objtype)
+		{
+			case ObjTypeNull:
+			case ObjTypeString:
+				typeid = TEXTOID;
+				break;
+			case ObjTypeBool:
+				typeid = BOOLOID;
+				break;
+			case ObjTypeArray:
+			case ObjTypeObject:
+				typeid = JSONOID;
+				break;
+			default:
+				elog(ERROR, "unable to determine type id");
+				typeid = InvalidOid;
+		}
+
+		TupleDescInitEntry(tupdesc, i, object->name, typeid, -1, 0);
+
+		nulls[i - 1] = false;
+		switch (object->objtype)
+		{
+			case ObjTypeNull:
+				nulls[i - 1] = true;
+				break;
+			case ObjTypeBool:
+				values[i - 1] = BoolGetDatum(object->bool_value);
+				break;
+			case ObjTypeString:
+				values[i - 1] = CStringGetTextDatum(object->str_value);
+				break;
+			case ObjTypeArray:
+				{
+					ArrayType  *arrayt;
+					Datum	   *arrvals;
+					Datum		jsonary;
+					ListCell   *cell;
+					int			length = list_length(object->array_value);
+					int			j;
+
+					/*
+					 * Arrays are stored as Lists up to this point, with each
+					 * element being a ObjElem; we need to construct an
+					 * ArrayType with them to turn the whole thing into a JSON
+					 * array.
+					 */
+					j = 0;
+					arrvals = palloc(sizeof(Datum) * length);
+					foreach(cell, object->array_value)
+					{
+						ObjTree    *json = lfirst(cell);
+
+						arrvals[j++] =
+							CStringGetTextDatum(jsonize_objtree(json));
+					}
+					arrayt = construct_array(arrvals, length,
+											 JSONOID, -1, false, 'i');
+
+					jsonary = DirectFunctionCall1(array_to_json,
+												  (PointerGetDatum(arrayt)));
+
+					values[i - 1] = jsonary;
+				}
+				break;
+			case ObjTypeObject:
+				values[i - 1] =
+					CStringGetTextDatum(jsonize_objtree(object->obj_value));
+				break;
+		}
+
+		i++;
+	}
+
+	BlessTupleDesc(tupdesc);
+	htup = heap_form_tuple(tupdesc, values, nulls);
+	json = DirectFunctionCall1(row_to_json, HeapTupleGetDatum(htup));
+
+	/* switch to caller's context so that our output is allocated there */
+	MemoryContextSwitchTo(oldcxt);
+
+	jsonstr = TextDatumGetCString(json);
+
+	return jsonstr;
+}
+
+/*
+ * Release all memory used by parameters and their expansion
+ */
+static void
+free_objtree(ObjTree *tree)
+{
+	MemoryContextDelete(tree->cxt);
+}
+
+/*
+ * A helper routine to setup %{}T elements.
+ */
+static ObjTree *
+new_objtree_for_type(ObjTree *parent, Oid typeId, int32 typmod)
+{
+	ObjTree    *typeParam;
+	char	   *typnsp;
+	char	   *typename;
+	char	   *typmodstr;
+	bool		is_array;
+
+	format_type_detailed(typeId, typmod,
+						 &typnsp, &typename, &typmodstr, &is_array);
+
+	/*
+	 * XXX We need this kludge to support types whose typmods include extra
+	 * verbiage after the parenthised value.  Really, this only applies to
+	 * timestamp and timestamptz, whose the typmod takes the form "(N)
+	 * with[out] time zone", which causes a syntax error with schema-qualified
+	 * names extracted from pg_type (as opposed to specialized type names
+	 * defined by the SQL standard).
+	 */
+	if (typmodstr)
+	{
+		char	*clpar;
+
+		clpar = strchr(typmodstr, ')');
+		if (clpar)
+			*(clpar + 1) = '\0';
+	}
+
+	/* We don't use new_objtree_VA here because types don't have a "fmt" */
+	typeParam = new_objtree(parent);
+	append_string_object(typeParam, "schemaname", typnsp);
+	append_string_object(typeParam, "typename", typename);
+	append_string_object(typeParam, "typmod", typmodstr);
+	append_bool_object(typeParam, "is_array", is_array);
+
+	return typeParam;
+}
+
+/*
+ * A helper routine to setup %{}D and %{}O elements
+ *
+ * The difference between those two element types is whether the objname will
+ * be quoted as an identifier or not, which is not something that this routine
+ * concerns itself with; that will be up to the expand function.
+ */
+static ObjTree *
+new_objtree_for_qualname(ObjTree *parent, Oid nspid, char *name)
+{
+	ObjTree    *qualified;
+	char	   *namespace;
+
+	/*
+	 * We don't use new_objtree_VA here because these names don't have a "fmt"
+	 */
+	qualified = new_objtree(parent);
+	namespace = get_namespace_name(nspid);
+	append_string_object(qualified, "schemaname", namespace);
+	append_string_object(qualified, "objname", pstrdup(name));
+
+	return qualified;
+}
+
+/*
+ * A helper routine to setup %{}D and %{}O elements, with the object specified
+ * by classId/objId
+ */
+static ObjTree *
+new_objtree_for_qualname_id(ObjTree *parent, Oid classId, Oid objectId)
+{
+	ObjTree    *qualified;
+	Relation	catalog;
+	HeapTuple	catobj;
+	Datum		objnsp;
+	Datum		objname;
+	AttrNumber	Anum_name;
+	AttrNumber	Anum_namespace;
+	bool		isnull;
+
+	catalog = heap_open(classId, AccessShareLock);
+
+	catobj = get_catalog_object_by_oid(catalog, objectId);
+	if (!catobj)
+		elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
+			 objectId, RelationGetRelationName(catalog));
+	Anum_name = get_object_attnum_name(classId);
+	Anum_namespace = get_object_attnum_namespace(classId);
+
+	objnsp = heap_getattr(catobj, Anum_namespace, RelationGetDescr(catalog),
+						  &isnull);
+	if (isnull)
+		elog(ERROR, "unexpected NULL namespace");
+	objname = heap_getattr(catobj, Anum_name, RelationGetDescr(catalog),
+						   &isnull);
+	if (isnull)
+		elog(ERROR, "unexpected NULL name");
+
+	qualified = new_objtree_for_qualname(parent,
+										 DatumGetObjectId(objnsp),
+										 NameStr(*DatumGetName(objname)));
+
+	pfree(catobj);
+	heap_close(catalog, AccessShareLock);
+
+	return qualified;
+}
+
+/*
+ * Return the string representation of the given RELPERSISTENCE value
+ */
+static char *
+get_persistence_str(char persistence)
+{
+	switch (persistence)
+	{
+		case RELPERSISTENCE_TEMP:
+			return "TEMPORARY";
+		case RELPERSISTENCE_UNLOGGED:
+			return "UNLOGGED";
+		case RELPERSISTENCE_PERMANENT:
+			return "";
+		default:
+			return "???";
+	}
+}
+
+/*
+ * deparse_ViewStmt
+ *		deparse a ViewStmt
+ *
+ * Given a view OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ */
+static char *
+deparse_ViewStmt(Oid objectId, Node *parsetree)
+{
+	ObjTree    *viewStmt;
+	ObjTree    *tmp;
+	char	   *command;
+	Relation	relation;
+	OverrideSearchPath *overridePath;
+
+	relation = relation_open(objectId, AccessShareLock);
+
+	viewStmt = new_objtree_VA(NULL,
+					 "CREATE %{persistence}s VIEW %{identity}D AS %{query}s",
+							  1, "persistence", ObjTypeString,
+					  get_persistence_str(relation->rd_rel->relpersistence));
+
+	tmp = new_objtree_for_qualname(viewStmt,
+								   relation->rd_rel->relnamespace,
+								   RelationGetRelationName(relation));
+	append_object_object(viewStmt, "identity", tmp);
+
+	/*
+	 * We want all names to be qualified, so set an empty search path before
+	 * calling ruleutils.c.
+	 */
+	overridePath = GetOverrideSearchPath(CurrentMemoryContext);
+	overridePath->schemas = NIL;
+	PushOverrideSearchPath(overridePath);
+
+	append_string_object(viewStmt, "query",
+						 pg_get_viewdef_internal(objectId));
+	PopOverrideSearchPath();
+
+	command = jsonize_objtree(viewStmt);
+	free_objtree(viewStmt);
+
+	relation_close(relation, AccessShareLock);
+
+	return command;
+}
+
+/*
+ * deparse_ColumnDef
+ *		Subroutine for CREATE TABLE deparsing
+ *
+ * Deparse a ColumnDef node within a regular (non typed) table creation.
+ *
+ * NOT NULL constraints in the column definition are emitted directly in the
+ * column definition by this routine; other constraints must be emitted
+ * elsewhere (the info in the parse node is incomplete anyway.)
+ */
+static ObjTree *
+deparse_ColumnDef(ObjTree *parent, Relation relation, List *dpcontext,
+				  ColumnDef *coldef)
+{
+	ObjTree    *column;
+	ObjTree    *tmp;
+	Oid			relid = RelationGetRelid(relation);
+	HeapTuple	attrTup;
+	Form_pg_attribute attrForm;
+	Oid			typid;
+	int32		typmod;
+	Oid			typcollation;
+	bool		saw_notnull;
+	ListCell   *cell;
+
+	/*
+	 * Inherited columns without local definitions must not be emitted. XXX --
+	 * maybe it is useful to have them with "present = false" or some such?
+	 */
+	if (!coldef->is_local)
+		return NULL;
+
+	attrTup = SearchSysCacheAttName(relid, coldef->colname);
+	if (!HeapTupleIsValid(attrTup))
+		elog(ERROR, "could not find cache entry for column \"%s\" of relation %u",
+			 coldef->colname, relid);
+	attrForm = (Form_pg_attribute) GETSTRUCT(attrTup);
+
+	get_atttypetypmodcoll(relid, attrForm->attnum,
+						  &typid, &typmod, &typcollation);
+
+	column = new_objtree_VA(parent,
+							"%{name}I %{coltype}T %{default}s %{not_null}s %{collation}s",
+							3,
+							"type", ObjTypeString, "column",
+							"name", ObjTypeString, coldef->colname,
+							"coltype", ObjTypeObject,
+							new_objtree_for_type(parent, typid, typmod));
+
+	tmp = new_objtree_VA(parent, "COLLATE %{name}D", 0);
+	if (OidIsValid(typcollation))
+	{
+		ObjTree *collname;
+
+		collname = new_objtree_for_qualname_id(parent,
+											   CollationRelationId,
+											   typcollation);
+		append_object_object(tmp, "name", collname);
+	}
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(column, "collation", tmp);
+
+	/*
+	 * Emit a NOT NULL declaration if necessary.  Note that we cannot trust
+	 * pg_attribute.attnotnull here, because that bit is also set when primary
+	 * keys are specified; and we must not emit a NOT NULL constraint in that
+	 * case, unless explicitely specified; so we scan the list of constraints
+	 * attached to this column.  (Fortunately, NOT NULL constraints cannot be
+	 * table constraints.)
+	 */
+	saw_notnull = false;
+	foreach(cell, coldef->constraints)
+	{
+		Constraint *constr = (Constraint *) lfirst(cell);
+
+		if (constr->contype == CONSTR_NOTNULL)
+			saw_notnull = true;
+	}
+
+	if (saw_notnull)
+		append_string_object(column, "not_null", "NOT NULL");
+	else
+		append_string_object(column, "not_null", "");
+
+	tmp = new_objtree_VA(parent, "DEFAULT %{default}s", 0);
+	if (attrForm->atthasdef)
+	{
+		char *defstr;
+
+		defstr = RelationGetColumnDefault(relation, attrForm->attnum,
+										  dpcontext);
+
+		append_string_object(tmp, "default", defstr);
+	}
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(column, "default", tmp);
+
+	ReleaseSysCache(attrTup);
+
+	return column;
+}
+
+/*
+ * deparse_ColumnDef_Typed
+ *		Subroutine for CREATE TABLE OF deparsing
+ *
+ * Deparse a ColumnDef node within a typed table creation.	This is simpler
+ * than the regular case, because we don't have to emit the type declaration,
+ * collation, or default.  Here we only return something if the column is being
+ * declared NOT NULL.
+ *
+ * As in deparse_ColumnDef, any other constraint is processed elsewhere.
+ *
+ * FIXME --- actually, what about default values?
+ */
+static ObjTree *
+deparse_ColumnDef_typed(ObjTree *parent, Relation relation, List *dpcontext,
+						ColumnDef *coldef)
+{
+	ObjTree    *column = NULL;
+	Oid			relid = RelationGetRelid(relation);
+	HeapTuple	attrTup;
+	Form_pg_attribute attrForm;
+	Oid			typid;
+	int32		typmod;
+	Oid			typcollation;
+	bool		saw_notnull;
+	ListCell   *cell;
+
+	attrTup = SearchSysCacheAttName(relid, coldef->colname);
+	if (!HeapTupleIsValid(attrTup))
+		elog(ERROR, "could not find cache entry for column \"%s\" of relation %u",
+			 coldef->colname, relid);
+	attrForm = (Form_pg_attribute) GETSTRUCT(attrTup);
+
+	get_atttypetypmodcoll(relid, attrForm->attnum,
+						  &typid, &typmod, &typcollation);
+
+	/*
+	 * Search for a NOT NULL declaration.  As in deparse_ColumnDef, we rely on
+	 * finding a constraint on the column rather than coldef->is_not_null.
+	 */
+	saw_notnull = false;
+	foreach(cell, coldef->constraints)
+	{
+		Constraint *constr = (Constraint *) lfirst(cell);
+
+		if (constr->contype == CONSTR_NOTNULL)
+		{
+			saw_notnull = true;
+			break;
+		}
+	}
+
+	if (saw_notnull)
+		column = new_objtree_VA(parent,
+								"%{name}I WITH OPTIONS NOT NULL", 2,
+								"type", ObjTypeString, "column_notnull",
+								"name", ObjTypeString, coldef->colname);
+
+	ReleaseSysCache(attrTup);
+	return column;
+}
+
+/*
+ * deparseTableElements
+ *		Subroutine for CREATE TABLE deparsing
+ *
+ * Deal with all the table elements (columns and constraints).
+ *
+ * Note we ignore constraints in the parse node here; they are extracted from
+ * system catalogs instead.
+ */
+static List *
+deparseTableElements(List *elements, ObjTree *parent, Relation relation,
+					 List *tableElements, List *dpcontext, bool typed)
+{
+	ListCell   *lc;
+
+	foreach(lc, tableElements)
+	{
+		Node	   *elt = (Node *) lfirst(lc);
+
+		switch (nodeTag(elt))
+		{
+			case T_ColumnDef:
+				{
+					ObjTree    *column;
+
+					column = typed ?
+						deparse_ColumnDef_typed(parent, relation, dpcontext,
+												(ColumnDef *) elt) :
+						deparse_ColumnDef(parent, relation, dpcontext,
+										  (ColumnDef *) elt);
+
+					if (column != NULL)
+						elements = lappend(elements, column);
+				}
+				break;
+			case T_Constraint:
+				break;
+			default:
+				elog(ERROR, "invalid node type %d", nodeTag(elt));
+		}
+	}
+
+	return elements;
+}
+
+/*
+ * obtainTableConstraints
+ *		Subroutine for CREATE TABLE deparsing
+ *
+ * Given a table OID, obtain its constraints and append them to the given
+ * elements list.  The updated list is returned.
+ *
+ * This works for both typed and regular tables.
+ */
+static List *
+obtainTableConstraints(List *elements, Oid objectId, ObjTree *parent)
+{
+	Relation	conRel;
+	ScanKeyData key;
+	SysScanDesc scan;
+	HeapTuple	tuple;
+	ObjTree    *tmp;
+	OverrideSearchPath *overridePath;
+
+	/*
+	 * scan pg_constraint to fetch all constraints linked to the given
+	 * relation.
+	 */
+	conRel = heap_open(ConstraintRelationId, AccessShareLock);
+	ScanKeyInit(&key,
+				Anum_pg_constraint_conrelid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(objectId));
+	scan = systable_beginscan(conRel, ConstraintRelidIndexId,
+							  true, NULL, 1, &key);
+
+	/*
+	 * We need to ensure all names in the constraint definitions are
+	 * qualified, so set an empty search_path for the duration of this loop.
+	 */
+	overridePath = GetOverrideSearchPath(CurrentMemoryContext);
+	overridePath->schemas = NIL;
+	PushOverrideSearchPath(overridePath);
+
+	/*
+	 * For each constraint, add a node to the list of table elements.  In
+	 * these nodes we include not only the printable information ("fmt"), but
+	 * also separate attributes to indicate the type of constraint, for
+	 * automatic processing.
+	 */
+	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+	{
+		Form_pg_constraint constrForm;
+		char	   *contype;
+
+		constrForm = (Form_pg_constraint) GETSTRUCT(tuple);
+
+		switch (constrForm->contype)
+		{
+			case CONSTRAINT_CHECK:
+				contype = "check";
+				break;
+			case CONSTRAINT_FOREIGN:
+				contype = "foreign key";
+				break;
+			case CONSTRAINT_PRIMARY:
+				contype = "primary key";
+				break;
+			case CONSTRAINT_UNIQUE:
+				contype = "unique";
+				break;
+			case CONSTRAINT_TRIGGER:
+				contype = "trigger";
+				break;
+			case CONSTRAINT_EXCLUSION:
+				contype = "exclusion";
+				break;
+			default:
+				elog(ERROR, "unrecognized constraint type");
+		}
+
+		/*
+		 * "type" and "contype" are not part of the printable output, but are
+		 * useful to programmatically distinguish these from columns and among
+		 * different constraint types.
+		 *
+		 * XXX it might be useful to also list the column names in a PK, etc.
+		 */
+		tmp = new_objtree_VA(parent,
+							 "CONSTRAINT %{name}I %{definition}s",
+							 4,
+							 "type", ObjTypeString, "constraint",
+							 "contype", ObjTypeString, contype,
+						 "name", ObjTypeString, NameStr(constrForm->conname),
+							 "definition", ObjTypeString,
+						  pg_get_constraintdef_string(HeapTupleGetOid(tuple),
+													  false));
+		elements = lappend(elements, tmp);
+	}
+
+	PopOverrideSearchPath();
+
+	systable_endscan(scan);
+	heap_close(conRel, AccessShareLock);
+
+	return elements;
+}
+
+/*
+ * deparse_CreateStmt
+ *		Deparse a CreateStmt (CREATE TABLE)
+ *
+ * Given a table OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ */
+static char *
+deparse_CreateStmt(Oid objectId, Node *parsetree)
+{
+	CreateStmt *node = (CreateStmt *) parsetree;
+	Relation	relation = relation_open(objectId, AccessShareLock);
+	List	   *dpcontext;
+	ObjTree    *createStmt;
+	ObjTree    *tmp;
+	char	   *command;
+	char	   *fmtstr;
+
+	/*
+	 * Typed tables use a slightly different format string: we must not put
+	 * table_elements with parents directly in the fmt string, because if
+	 * there are no options the parens must not be emitted; and also, typed
+	 * tables do not allow for inheritance.
+	 */
+	if (node->ofTypename)
+		fmtstr = "CREATE %{persistence}s TABLE %{identity}D %{if_not_exists}s "
+			"OF %{of_type}T %{table_elements}s "
+			"%{on_commit}s %{tablespace}s";
+	else
+		fmtstr = "CREATE %{persistence}s TABLE %{identity}D %{if_not_exists}s "
+			"(%{table_elements:, }s) %{inherits}s "
+			"%{on_commit}s %{tablespace}s";
+
+	createStmt =
+		new_objtree_VA(NULL, fmtstr, 1,
+					   "persistence", ObjTypeString,
+					   get_persistence_str(relation->rd_rel->relpersistence));
+
+	tmp = new_objtree_for_qualname(createStmt,
+								   relation->rd_rel->relnamespace,
+								   RelationGetRelationName(relation));
+	append_object_object(createStmt, "identity", tmp);
+
+	append_string_object(createStmt, "if_not_exists",
+						 node->if_not_exists ? "IF NOT EXISTS" : "");
+
+	dpcontext = deparse_context_for(RelationGetRelationName(relation),
+								  objectId);
+
+	if (node->ofTypename)
+	{
+		List	   *tableelts = NIL;
+
+		/*
+		 * We can't put table elements directly in the fmt string as an array
+		 * surrounded by parens here, because an empty clause would cause a
+		 * syntax error.  Therefore, we use an indirection element and set
+		 * present=false when there are no elements.
+		 */
+		append_string_object(createStmt, "table_kind", "typed");
+
+		tmp = new_objtree_for_type(createStmt, relation->rd_rel->reloftype, -1);
+		append_object_object(createStmt, "of_type", tmp);
+
+		tableelts = deparseTableElements(NIL, createStmt, relation,
+										 node->tableElts, dpcontext, true);
+		tableelts = obtainTableConstraints(tableelts, objectId, createStmt);
+		if (tableelts == NIL)
+			tmp = new_objtree_VA(createStmt, "", 1,
+								 "present", ObjTypeBool, false);
+		else
+			tmp = new_objtree_VA(createStmt, "(%{elements:, }s)", 1,
+								 "elements", ObjTypeArray, tableelts);
+		append_object_object(createStmt, "table_elements", tmp);
+	}
+	else
+	{
+		List	   *tableelts = NIL;
+
+		/*
+		 * There is no need to process LIKE clauses separately; they have
+		 * already been transformed into columns and constraints.
+		 */
+		append_string_object(createStmt, "table_kind", "plain");
+
+		/*
+		 * Process table elements: column definitions and constraints.	Only
+		 * the column definitions are obtained from the parse node itself.	To
+		 * get constraints we rely on pg_constraint, because the parse node
+		 * might be missing some things such as the name of the constraints.
+		 */
+		tableelts = deparseTableElements(NIL, createStmt, relation,
+										 node->tableElts, dpcontext, false);
+		tableelts = obtainTableConstraints(tableelts, objectId, createStmt);
+
+		append_array_object(createStmt, "table_elements", tableelts);
+
+		/*
+		 * Add inheritance specification.  We cannot simply scan the list of
+		 * parents from the parser node, because that may lack the actual
+		 * qualified names of the parent relations.  Rather than trying to
+		 * re-resolve them from the information in the parse node, it seems
+		 * more accurate and convenient to grab it from pg_inherits.
+		 */
+		tmp = new_objtree_VA(createStmt, "INHERITS (%{parents:, }D)", 0);
+		if (list_length(node->inhRelations) > 0)
+		{
+			List	   *parents = NIL;
+			Relation	inhRel;
+			SysScanDesc scan;
+			ScanKeyData key;
+			HeapTuple	tuple;
+
+			inhRel = heap_open(InheritsRelationId, RowExclusiveLock);
+
+			ScanKeyInit(&key,
+						Anum_pg_inherits_inhrelid,
+						BTEqualStrategyNumber, F_OIDEQ,
+						ObjectIdGetDatum(objectId));
+
+			scan = systable_beginscan(inhRel, InheritsRelidSeqnoIndexId,
+									  true, NULL, 1, &key);
+
+			while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+			{
+				ObjTree    *parent;
+				Form_pg_inherits formInh = (Form_pg_inherits) GETSTRUCT(tuple);
+
+				parent = new_objtree_for_qualname_id(createStmt,
+													 RelationRelationId,
+													 formInh->inhparent);
+
+				parents = lappend(parents, parent);
+			}
+
+			systable_endscan(scan);
+			heap_close(inhRel, RowExclusiveLock);
+
+			append_array_object(tmp, "parents", parents);
+		}
+		else
+		{
+			append_null_object(tmp, "parents");
+			append_bool_object(tmp, "present", false);
+		}
+		append_object_object(createStmt, "inherits", tmp);
+	}
+
+	tmp = new_objtree_VA(createStmt, "TABLESPACE %{tablespace}I", 0);
+	if (node->tablespacename)
+		append_string_object(tmp, "tablespace", node->tablespacename);
+	else
+	{
+		append_null_object(tmp, "tablespace");
+		append_bool_object(tmp, "present", false);
+	}
+	append_object_object(createStmt, "tablespace", tmp);
+
+	tmp = new_objtree_VA(createStmt, "ON COMMIT %{on_commit_value}s", 0);
+	switch (node->oncommit)
+	{
+		case ONCOMMIT_DROP:
+			append_string_object(tmp, "on_commit_value", "DROP");
+			break;
+
+		case ONCOMMIT_DELETE_ROWS:
+			append_string_object(tmp, "on_commit_value", "DELETE ROWS");
+			break;
+
+		case ONCOMMIT_PRESERVE_ROWS:
+			append_string_object(tmp, "on_commit_value", "PRESERVE ROWS");
+			break;
+
+		case ONCOMMIT_NOOP:
+			append_null_object(tmp, "on_commit_value");
+			append_bool_object(tmp, "present", false);
+			break;
+	}
+	append_object_object(createStmt, "on_commit", tmp);
+
+	command = jsonize_objtree(createStmt);
+
+	free_objtree(createStmt);
+	relation_close(relation, AccessShareLock);
+
+	return command;
+}
+
+static inline ObjTree *
+deparse_Seq_Cache(ObjTree *parent, Form_pg_sequence seqdata)
+{
+	ObjTree	   *tmp;
+	char	   *tmpstr;
+
+	tmpstr = psprintf("%lu", seqdata->cache_value);
+	tmp = new_objtree_VA(parent, "CACHE %{value}s",
+						 2,
+						 "clause", ObjTypeString, "cache",
+						 "value", ObjTypeString, tmpstr);
+	return tmp;
+}
+
+static inline ObjTree *
+deparse_Seq_Cycle(ObjTree *parent, Form_pg_sequence seqdata)
+{
+	ObjTree	   *tmp;
+
+	tmp = new_objtree_VA(parent, "%{no}s CYCLE",
+						 2,
+						 "clause", ObjTypeString, "cycle",
+						 "no", ObjTypeString,
+						 seqdata->is_cycled ? "" : "NO");
+	return tmp;
+}
+
+static inline ObjTree *
+deparse_Seq_IncrementBy(ObjTree *parent, Form_pg_sequence seqdata)
+{
+	ObjTree	   *tmp;
+	char	   *tmpstr;
+
+	tmpstr = psprintf("%lu", seqdata->increment_by);
+	tmp = new_objtree_VA(parent, "INCREMENT BY %{value}s",
+						 2,
+						 "clause", ObjTypeString, "increment_by",
+						 "value", ObjTypeString, tmpstr);
+	return tmp;
+}
+
+static inline ObjTree *
+deparse_Seq_Minvalue(ObjTree *parent, Form_pg_sequence seqdata)
+{
+	ObjTree	   *tmp;
+	char	   *tmpstr;
+
+	tmpstr = psprintf("%lu", seqdata->min_value);
+	tmp = new_objtree_VA(parent, "MINVALUE %{value}s",
+						 2,
+						 "clause", ObjTypeString, "minvalue",
+						 "value", ObjTypeString, tmpstr);
+	return tmp;
+}
+
+static inline ObjTree *
+deparse_Seq_Maxvalue(ObjTree *parent, Form_pg_sequence seqdata)
+{
+	ObjTree	   *tmp;
+	char	   *tmpstr;
+
+	tmpstr = psprintf("%lu", seqdata->max_value);
+	tmp = new_objtree_VA(parent, "MAXVALUE %{value}s",
+						 2,
+						 "clause", ObjTypeString, "maxvalue",
+						 "value", ObjTypeString, tmpstr);
+
+	return tmp;
+}
+
+static inline ObjTree *
+deparse_Seq_Startwith(ObjTree *parent, Form_pg_sequence seqdata)
+{
+	ObjTree	   *tmp;
+	char	   *tmpstr;
+
+	tmpstr = psprintf("%lu", seqdata->start_value);
+	tmp = new_objtree_VA(parent, "START WITH %{value}s",
+						 2,
+						 "clause", ObjTypeString, "start",
+						 "value", ObjTypeString, tmpstr);
+	return tmp;
+}
+
+static inline ObjTree *
+deparse_Seq_Restart(ObjTree *parent, Form_pg_sequence seqdata)
+{
+	ObjTree	   *tmp;
+	char	   *tmpstr;
+
+	tmpstr = psprintf("%lu", seqdata->last_value);
+	tmp = new_objtree_VA(parent, "RESTART %{value}s",
+						 2,
+						 "clause", ObjTypeString, "restart",
+						 "value", ObjTypeString, tmpstr);
+	return tmp;
+}
+
+static ObjTree *
+deparse_Seq_OwnedBy(ObjTree *parent, Oid sequenceId)
+{
+	ObjTree    *ownedby = NULL;
+	Relation	depRel;
+	SysScanDesc scan;
+	ScanKeyData keys[3];
+	HeapTuple	tuple;
+
+	depRel = heap_open(DependRelationId, AccessShareLock);
+	ScanKeyInit(&keys[0],
+				Anum_pg_depend_classid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(RelationRelationId));
+	ScanKeyInit(&keys[1],
+				Anum_pg_depend_objid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(sequenceId));
+	ScanKeyInit(&keys[2],
+				Anum_pg_depend_objsubid,
+				BTEqualStrategyNumber, F_INT4EQ,
+				Int32GetDatum(0));
+
+	scan = systable_beginscan(depRel, DependDependerIndexId, true,
+							  NULL, 3, keys);
+	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+	{
+		Oid			ownerId;
+		Form_pg_depend depform;
+		ObjTree    *tmp;
+		char	   *colname;
+
+		depform = (Form_pg_depend) GETSTRUCT(tuple);
+
+		/* only consider AUTO dependencies on pg_class */
+		if (depform->deptype != DEPENDENCY_AUTO)
+			continue;
+		if (depform->refclassid != RelationRelationId)
+			continue;
+		if (depform->refobjsubid <= 0)
+			continue;
+
+		ownerId = depform->refobjid;
+		colname = get_attname(ownerId, depform->refobjsubid);
+		if (colname == NULL)
+			continue;
+
+		tmp = new_objtree_for_qualname_id(parent, RelationRelationId, ownerId);
+		append_string_object(tmp, "attrname", colname);
+		ownedby = new_objtree_VA(parent,
+								 "OWNED BY %{owner}D",
+								 2,
+								 "clause", ObjTypeString, "owned",
+								 "owner", ObjTypeObject, tmp);
+	}
+
+	systable_endscan(scan);
+	relation_close(depRel, AccessShareLock);
+
+	/*
+	 * If there's no owner column, emit an empty OWNED BY element, set up so
+	 * that it won't print anything.
+	 */
+	if (!ownedby)
+		/* XXX this shouldn't happen ... */
+		ownedby = new_objtree_VA(parent,
+								 "OWNED BY %{owner}D",
+								 3,
+								 "clause", ObjTypeString, "owned",
+								 "owner", ObjTypeNull,
+								 "present", ObjTypeBool, false);
+
+	return ownedby;
+}
+
+
+/*
+ * deparse_CreateSeqStmt
+ *		deparse a CreateSeqStmt
+ *
+ * Given a sequence OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ */
+static char *
+deparse_CreateSeqStmt(Oid objectId, Node *parsetree)
+{
+	ObjTree    *createSeq;
+	ObjTree    *tmp;
+	Relation	relation = relation_open(objectId, AccessShareLock);
+	char	   *command;
+	Form_pg_sequence seqdata;
+	List	   *elems = NIL;
+
+	seqdata = get_sequence_values(objectId);
+
+	createSeq =
+		new_objtree_VA(NULL,
+					   "CREATE %{persistence}s SEQUENCE %{identity}D "
+					   "%{definition: }s",
+					   1,
+					   "persistence", ObjTypeString,
+					   get_persistence_str(relation->rd_rel->relpersistence));
+
+	tmp = new_objtree_for_qualname(createSeq,
+								   relation->rd_rel->relnamespace,
+								   RelationGetRelationName(relation));
+	append_object_object(createSeq, "identity", tmp);
+
+	/* definition elements */
+	elems = lappend(elems, deparse_Seq_Cache(createSeq, seqdata));
+	elems = lappend(elems, deparse_Seq_Cycle(createSeq, seqdata));
+	elems = lappend(elems, deparse_Seq_IncrementBy(createSeq, seqdata));
+	elems = lappend(elems, deparse_Seq_Minvalue(createSeq, seqdata));
+	elems = lappend(elems, deparse_Seq_Maxvalue(createSeq, seqdata));
+	elems = lappend(elems, deparse_Seq_Startwith(createSeq, seqdata));
+	elems = lappend(elems, deparse_Seq_Restart(createSeq, seqdata));
+	/* we purposefully do not emit OWNED BY here */
+
+	append_array_object(createSeq, "definition", elems);
+
+	command = jsonize_objtree(createSeq);
+
+	free_objtree(createSeq);
+	relation_close(relation, AccessShareLock);
+
+	return command;
+}
+
+static char *
+deparse_AlterSeqStmt(Oid objectId, Node *parsetree)
+{
+	ObjTree	   *alterSeq;
+	ObjTree	   *tmp;
+	Relation	relation = relation_open(objectId, AccessShareLock);
+	char	   *command;
+	Form_pg_sequence seqdata;
+	List	   *elems = NIL;
+	ListCell   *cell;
+
+	seqdata = get_sequence_values(objectId);
+
+	alterSeq =
+		new_objtree_VA(NULL,
+					   "ALTER SEQUENCE %{identity}D %{definition: }s", 0);
+	tmp = new_objtree_for_qualname(alterSeq,
+								   relation->rd_rel->relnamespace,
+								   RelationGetRelationName(relation));
+	append_object_object(alterSeq, "identity", tmp);
+
+	foreach(cell, ((AlterSeqStmt *) parsetree)->options)
+	{
+		DefElem *elem = (DefElem *) lfirst(cell);
+		ObjTree *newelm;
+
+		if (strcmp(elem->defname, "cache") == 0)
+			newelm = deparse_Seq_Cache(alterSeq, seqdata);
+		else if (strcmp(elem->defname, "cycle") == 0)
+			newelm = deparse_Seq_Cycle(alterSeq, seqdata);
+		else if (strcmp(elem->defname, "increment_by") == 0)
+			newelm = deparse_Seq_IncrementBy(alterSeq, seqdata);
+		else if (strcmp(elem->defname, "minvalue") == 0)
+			newelm = deparse_Seq_Minvalue(alterSeq, seqdata);
+		else if (strcmp(elem->defname, "maxvalue") == 0)
+			newelm = deparse_Seq_Maxvalue(alterSeq, seqdata);
+		else if (strcmp(elem->defname, "start") == 0)
+			newelm = deparse_Seq_Startwith(alterSeq, seqdata);
+		else if (strcmp(elem->defname, "restart") == 0)
+			newelm = deparse_Seq_Restart(alterSeq, seqdata);
+		else if (strcmp(elem->defname, "owned_by") == 0)
+			newelm = deparse_Seq_OwnedBy(alterSeq, objectId);
+		else
+			elog(ERROR, "invalid sequence option %s", elem->defname);
+
+		elems = lappend(elems, newelm);
+	}
+
+	append_array_object(alterSeq, "definition", elems);
+
+	command = jsonize_objtree(alterSeq);
+
+	free_objtree(alterSeq);
+	relation_close(relation, AccessShareLock);
+
+	return command;
+}
+
+/*
+ * deparse_IndexStmt
+ *		deparse an IndexStmt
+ *
+ * Given an index OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ *
+ * If the index corresponds to a constraint, NULL is returned.
+ */
+static char *
+deparse_IndexStmt(Oid objectId, Node *parsetree)
+{
+	IndexStmt  *node = (IndexStmt *) parsetree;
+	ObjTree    *indexStmt;
+	ObjTree    *tmp;
+	Relation	idxrel;
+	Relation	heaprel;
+	OverrideSearchPath *overridePath;
+	char	   *command;
+	char	   *index_am;
+	char	   *definition;
+	char	   *reloptions;
+	char	   *tablespace;
+	char	   *whereClause;
+
+	if (node->primary || node->isconstraint)
+	{
+		/*
+		 * indexes for PRIMARY KEY and other constraints are output
+		 * separately; return empty here.
+		 */
+		return NULL;
+	}
+
+	idxrel = relation_open(objectId, AccessShareLock);
+	heaprel = relation_open(idxrel->rd_index->indrelid, AccessShareLock);
+
+	overridePath = GetOverrideSearchPath(CurrentMemoryContext);
+	overridePath->schemas = NIL;
+	PushOverrideSearchPath(overridePath);
+
+	pg_get_indexdef_detailed(objectId,
+							 &index_am, &definition, &reloptions,
+							 &tablespace, &whereClause);
+	PopOverrideSearchPath();
+
+	indexStmt =
+		new_objtree_VA(NULL,
+					   "CREATE %{unique}s INDEX %{concurrently}s %{name}I "
+					   "ON %{table}D USING %{index_am}s (%{definition}s) "
+					   "%{with}s %{tablespace}s %{where_clause}s",
+					   5,
+					   "unique", ObjTypeString, node->unique ? "UNIQUE" : "",
+					   "concurrently", ObjTypeString,
+					   node->concurrent ? "CONCURRENTLY" : "",
+					   "name", ObjTypeString, RelationGetRelationName(idxrel),
+					   "definition", ObjTypeString, definition,
+					   "index_am", ObjTypeString, index_am);
+
+	tmp = new_objtree_for_qualname(indexStmt,
+								   heaprel->rd_rel->relnamespace,
+								   RelationGetRelationName(heaprel));
+	append_object_object(indexStmt, "table", tmp);
+
+	/* reloptions */
+	tmp = new_objtree_VA(indexStmt, "WITH (%{opts}s)", 0);
+	if (reloptions)
+		append_string_object(tmp, "opts", reloptions);
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(indexStmt, "with", tmp);
+
+	/* tablespace */
+	tmp = new_objtree_VA(indexStmt, "TABLESPACE %{tablespace}s", 0);
+	if (tablespace)
+		append_string_object(tmp, "tablespace", tablespace);
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(indexStmt, "tablespace", tmp);
+
+	/* WHERE clause */
+	tmp = new_objtree_VA(indexStmt, "WHERE %{where}s", 0);
+	if (whereClause)
+		append_string_object(tmp, "where", whereClause);
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(indexStmt, "where_clause", tmp);
+
+	command = jsonize_objtree(indexStmt);
+	free_objtree(indexStmt);
+
+	heap_close(idxrel, AccessShareLock);
+	heap_close(heaprel, AccessShareLock);
+
+	return command;
+}
+
+/*
+ * deparse_CreateSchemaStmt
+ *		deparse a CreateSchemaStmt
+ *
+ * Given a schema OID and the parsetree that created it, return the JSON blob
+ * representing the creation command.
+ *
+ * Note we don't output the schema elements given in the creation command.
+ * They must be output separately.	 (In the current implementation,
+ * CreateSchemaCommand passes them back to ProcessUtility, which will lead to
+ * this file if appropriate.)
+ */
+static char *
+deparse_CreateSchemaStmt(Oid objectId, Node *parsetree)
+{
+	CreateSchemaStmt *node = (CreateSchemaStmt *) parsetree;
+	ObjTree    *createSchema;
+	ObjTree    *auth;
+	char	   *command;
+
+	createSchema =
+		new_objtree_VA(NULL,
+				"CREATE SCHEMA %{if_not_exists}s %{name}I %{authorization}s",
+					   2,
+					   "name", ObjTypeString, node->schemaname,
+					   "if_not_exists", ObjTypeString,
+					   node->if_not_exists ? "IF NOT EXISTS" : "");
+
+	auth = new_objtree_VA(createSchema,
+						  "AUTHORIZATION %{authorization_role}I", 0);
+	if (node->authid)
+		append_string_object(auth, "authorization_role", node->authid);
+	else
+	{
+		append_null_object(auth, "authorization_role");
+		append_bool_object(auth, "present", false);
+	}
+	append_object_object(createSchema, "authorization", auth);
+
+	command = jsonize_objtree(createSchema);
+	free_objtree(createSchema);
+
+	return command;
+}
+
+/*
+ * Given a utility command parsetree and the OID of the corresponding object,
+ * return a JSON representation of the command.
+ *
+ * The command is expanded fully, so that there are no ambiguities even in the
+ * face of search_path changes.
+ *
+ * Note we currently only support commands for which ProcessUtilitySlow saves
+ * objects to create; currently this excludes all forms of ALTER and DROP.
+ */
+char *
+deparse_utility_command(Oid objectId, Node *parsetree)
+{
+	char	   *command;
+
+	switch (nodeTag(parsetree))
+	{
+		case T_CreateSchemaStmt:
+			command = deparse_CreateSchemaStmt(objectId, parsetree);
+			break;
+
+		case T_CreateStmt:
+			command = deparse_CreateStmt(objectId, parsetree);
+			break;
+
+		case T_IndexStmt:
+			command = deparse_IndexStmt(objectId, parsetree);
+			break;
+
+		case T_ViewStmt:
+			command = deparse_ViewStmt(objectId, parsetree);
+			break;
+
+		case T_CreateSeqStmt:
+			command = deparse_CreateSeqStmt(objectId, parsetree);
+			break;
+
+		case T_AlterSeqStmt:
+			command = deparse_AlterSeqStmt(objectId, parsetree);
+			break;
+
+			/* creation of objects hanging off tables */
+		case T_RuleStmt:
+		case T_CreateTrigStmt:
+			command = NULL;
+			break;
+
+			/* FDW-related objects */
+		case T_CreateForeignTableStmt:
+		case T_CreateFdwStmt:
+		case T_CreateForeignServerStmt:
+		case T_CreateUserMappingStmt:
+
+			/* other local objects */
+		case T_DefineStmt:
+		case T_CreateExtensionStmt:
+		case T_CompositeTypeStmt:		/* CREATE TYPE (composite) */
+		case T_CreateEnumStmt:	/* CREATE TYPE AS ENUM */
+		case T_CreateRangeStmt:	/* CREATE TYPE AS RANGE */
+		case T_CreateDomainStmt:
+		case T_CreateFunctionStmt:
+		case T_CreateTableAsStmt:
+		case T_CreatePLangStmt:
+		case T_CreateConversionStmt:
+		case T_CreateCastStmt:
+		case T_CreateOpClassStmt:
+		case T_CreateOpFamilyStmt:
+			command = NULL;
+			break;
+
+			/* matviews */
+		case T_RefreshMatViewStmt:
+			command = NULL;
+			break;
+
+		default:
+			command = NULL;
+			elog(LOG, "unrecognized node type: %d",
+				 (int) nodeTag(parsetree));
+	}
+
+	return command;
+}
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index f4d25bd..5bac81e 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -904,6 +904,7 @@ ProcessUtilitySlow(Node *parsetree,
 	bool		isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL);
 	bool		isCompleteQuery = (context <= PROCESS_UTILITY_QUERY);
 	bool		needCleanup;
+	Oid			objectId;
 
 	/* All event trigger calls are done only when isCompleteQuery is true */
 	needCleanup = isCompleteQuery && EventTriggerBeginCompleteQuery();
@@ -922,6 +923,10 @@ ProcessUtilitySlow(Node *parsetree,
 			case T_CreateSchemaStmt:
 				CreateSchemaCommand((CreateSchemaStmt *) parsetree,
 									queryString);
+				/*
+				 * CreateSchemaCommand calls EventTriggerStashCommand
+				 * internally, for reasons explained there.
+				 */
 				break;
 
 			case T_CreateStmt:
@@ -929,7 +934,6 @@ ProcessUtilitySlow(Node *parsetree,
 				{
 					List	   *stmts;
 					ListCell   *l;
-					Oid			relOid;
 
 					/* Run parse analysis ... */
 					stmts = transformCreateStmt((CreateStmt *) parsetree,
@@ -946,9 +950,11 @@ ProcessUtilitySlow(Node *parsetree,
 							static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
 
 							/* Create the table itself */
-							relOid = DefineRelation((CreateStmt *) stmt,
-													RELKIND_RELATION,
-													InvalidOid);
+							objectId = DefineRelation((CreateStmt *) stmt,
+													  RELKIND_RELATION,
+													  InvalidOid);
+							EventTriggerStashCommand(objectId, OBJECT_TABLE,
+													 stmt);
 
 							/*
 							 * Let AlterTableCreateToastTable decide if this
@@ -970,20 +976,27 @@ ProcessUtilitySlow(Node *parsetree,
 												   toast_options,
 												   true);
 
-							AlterTableCreateToastTable(relOid, toast_options);
+							AlterTableCreateToastTable(objectId, toast_options);
 						}
 						else if (IsA(stmt, CreateForeignTableStmt))
 						{
 							/* Create the table itself */
-							relOid = DefineRelation((CreateStmt *) stmt,
-													RELKIND_FOREIGN_TABLE,
-													InvalidOid);
+							objectId = DefineRelation((CreateStmt *) stmt,
+													  RELKIND_FOREIGN_TABLE,
+													  InvalidOid);
 							CreateForeignTable((CreateForeignTableStmt *) stmt,
-											   relOid);
+											   objectId);
+							EventTriggerStashCommand(objectId,
+													 OBJECT_FOREIGN_TABLE,
+													 stmt);
 						}
 						else
 						{
-							/* Recurse for anything else */
+							/*
+							 * Recurse for anything else.  Note the recursive
+							 * call will stash the objects so created into our
+							 * event trigger context.
+							 */
 							ProcessUtility(stmt,
 										   queryString,
 										   PROCESS_UTILITY_SUBCOMMAND,
@@ -1114,46 +1127,53 @@ ProcessUtilitySlow(Node *parsetree,
 					switch (stmt->kind)
 					{
 						case OBJECT_AGGREGATE:
-							DefineAggregate(stmt->defnames, stmt->args,
-											stmt->oldstyle, stmt->definition,
-											queryString);
+							objectId =
+								DefineAggregate(stmt->defnames, stmt->args,
+												stmt->oldstyle,
+												stmt->definition, queryString);
 							break;
 						case OBJECT_OPERATOR:
 							Assert(stmt->args == NIL);
-							DefineOperator(stmt->defnames, stmt->definition);
+							objectId = DefineOperator(stmt->defnames,
+													  stmt->definition);
 							break;
 						case OBJECT_TYPE:
 							Assert(stmt->args == NIL);
-							DefineType(stmt->defnames, stmt->definition);
+							objectId = DefineType(stmt->defnames,
+												  stmt->definition);
 							break;
 						case OBJECT_TSPARSER:
 							Assert(stmt->args == NIL);
-							DefineTSParser(stmt->defnames, stmt->definition);
+							objectId = DefineTSParser(stmt->defnames,
+													  stmt->definition);
 							break;
 						case OBJECT_TSDICTIONARY:
 							Assert(stmt->args == NIL);
-							DefineTSDictionary(stmt->defnames,
-											   stmt->definition);
+							objectId = DefineTSDictionary(stmt->defnames,
+														  stmt->definition);
 							break;
 						case OBJECT_TSTEMPLATE:
 							Assert(stmt->args == NIL);
-							DefineTSTemplate(stmt->defnames,
-											 stmt->definition);
+							objectId = DefineTSTemplate(stmt->defnames,
+														stmt->definition);
 							break;
 						case OBJECT_TSCONFIGURATION:
 							Assert(stmt->args == NIL);
-							DefineTSConfiguration(stmt->defnames,
-												  stmt->definition);
+							objectId = DefineTSConfiguration(stmt->defnames,
+															 stmt->definition);
 							break;
 						case OBJECT_COLLATION:
 							Assert(stmt->args == NIL);
-							DefineCollation(stmt->defnames, stmt->definition);
+							objectId = DefineCollation(stmt->defnames,
+													   stmt->definition);
 							break;
 						default:
 							elog(ERROR, "unrecognized define stmt type: %d",
 								 (int) stmt->kind);
 							break;
 					}
+
+					EventTriggerStashCommand(objectId, stmt->kind, parsetree);
 				}
 				break;
 
@@ -1171,17 +1191,20 @@ ProcessUtilitySlow(Node *parsetree,
 					stmt = transformIndexStmt(stmt, queryString);
 
 					/* ... and do it */
-					DefineIndex(stmt,
-								InvalidOid,		/* no predefined OID */
-								false,	/* is_alter_table */
-								true,	/* check_rights */
-								false,	/* skip_build */
-								false); /* quiet */
+					objectId = DefineIndex(stmt,
+										   InvalidOid,		/* no predefined OID */
+										   false,	/* is_alter_table */
+										   true,	/* check_rights */
+										   false,	/* skip_build */
+										   false); /* quiet */
+					EventTriggerStashCommand(objectId, OBJECT_INDEX,
+											 parsetree);
 				}
 				break;
 
 			case T_CreateExtensionStmt:
-				CreateExtension((CreateExtensionStmt *) parsetree);
+				objectId = CreateExtension((CreateExtensionStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_EXTENSION, parsetree);
 				break;
 
 			case T_AlterExtensionStmt:
@@ -1193,7 +1216,8 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_CreateFdwStmt:
-				CreateForeignDataWrapper((CreateFdwStmt *) parsetree);
+				objectId = CreateForeignDataWrapper((CreateFdwStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_FDW, parsetree);
 				break;
 
 			case T_AlterFdwStmt:
@@ -1201,7 +1225,9 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_CreateForeignServerStmt:
-				CreateForeignServer((CreateForeignServerStmt *) parsetree);
+				objectId = CreateForeignServer((CreateForeignServerStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_FOREIGN_SERVER,
+										 parsetree);
 				break;
 
 			case T_AlterForeignServerStmt:
@@ -1209,7 +1235,9 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_CreateUserMappingStmt:
-				CreateUserMapping((CreateUserMappingStmt *) parsetree);
+				objectId = CreateUserMapping((CreateUserMappingStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_USER_MAPPING,
+										 parsetree);
 				break;
 
 			case T_AlterUserMappingStmt:
@@ -1224,16 +1252,20 @@ ProcessUtilitySlow(Node *parsetree,
 				{
 					CompositeTypeStmt *stmt = (CompositeTypeStmt *) parsetree;
 
-					DefineCompositeType(stmt->typevar, stmt->coldeflist);
+					objectId = DefineCompositeType(stmt->typevar,
+												   stmt->coldeflist);
+					EventTriggerStashCommand(objectId, OBJECT_TYPE, parsetree);
 				}
 				break;
 
 			case T_CreateEnumStmt:		/* CREATE TYPE AS ENUM */
-				DefineEnum((CreateEnumStmt *) parsetree);
+				objectId = DefineEnum((CreateEnumStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_TYPE, parsetree);
 				break;
 
 			case T_CreateRangeStmt:		/* CREATE TYPE AS RANGE */
-				DefineRange((CreateRangeStmt *) parsetree);
+				objectId = DefineRange((CreateRangeStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_TYPE, parsetree);
 				break;
 
 			case T_AlterEnumStmt:		/* ALTER TYPE (enum) */
@@ -1241,66 +1273,80 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_ViewStmt:	/* CREATE VIEW */
-				DefineView((ViewStmt *) parsetree, queryString);
+				objectId = DefineView((ViewStmt *) parsetree, queryString);
+				EventTriggerStashCommand(objectId, OBJECT_VIEW, parsetree);
 				break;
 
 			case T_CreateFunctionStmt:	/* CREATE FUNCTION */
-				CreateFunction((CreateFunctionStmt *) parsetree, queryString);
+				objectId = CreateFunction((CreateFunctionStmt *) parsetree, queryString);
+				EventTriggerStashCommand(objectId, OBJECT_FUNCTION, parsetree);
 				break;
 
 			case T_AlterFunctionStmt:	/* ALTER FUNCTION */
-				AlterFunction((AlterFunctionStmt *) parsetree);
+				objectId = AlterFunction((AlterFunctionStmt *) parsetree);
 				break;
 
 			case T_RuleStmt:	/* CREATE RULE */
-				DefineRule((RuleStmt *) parsetree, queryString);
+				objectId = DefineRule((RuleStmt *) parsetree, queryString);
+				EventTriggerStashCommand(objectId, OBJECT_RULE, parsetree);
 				break;
 
 			case T_CreateSeqStmt:
-				DefineSequence((CreateSeqStmt *) parsetree);
+				objectId = DefineSequence((CreateSeqStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_SEQUENCE, parsetree);
 				break;
 
 			case T_AlterSeqStmt:
-				AlterSequence((AlterSeqStmt *) parsetree);
+				objectId = AlterSequence((AlterSeqStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_SEQUENCE, parsetree);
 				break;
 
 			case T_CreateTableAsStmt:
-				ExecCreateTableAs((CreateTableAsStmt *) parsetree,
+				objectId = ExecCreateTableAs((CreateTableAsStmt *) parsetree,
 								  queryString, params, completionTag);
+				EventTriggerStashCommand(objectId, OBJECT_TABLE, parsetree);
 				break;
 
 			case T_RefreshMatViewStmt:
-				ExecRefreshMatView((RefreshMatViewStmt *) parsetree,
+				objectId = ExecRefreshMatView((RefreshMatViewStmt *) parsetree,
 								   queryString, params, completionTag);
+				EventTriggerStashCommand(objectId, OBJECT_MATVIEW, parsetree);
 				break;
 
 			case T_CreateTrigStmt:
-				(void) CreateTrigger((CreateTrigStmt *) parsetree, queryString,
+				objectId = CreateTrigger((CreateTrigStmt *) parsetree, queryString,
 									 InvalidOid, InvalidOid, false);
+				EventTriggerStashCommand(objectId, OBJECT_TRIGGER, parsetree);
 				break;
 
 			case T_CreatePLangStmt:
-				CreateProceduralLanguage((CreatePLangStmt *) parsetree);
+				objectId = CreateProceduralLanguage((CreatePLangStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_LANGUAGE, parsetree);
 				break;
 
 			case T_CreateDomainStmt:
-				DefineDomain((CreateDomainStmt *) parsetree);
+				objectId = DefineDomain((CreateDomainStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_DOMAIN, parsetree);
 				break;
 
 			case T_CreateConversionStmt:
-				CreateConversionCommand((CreateConversionStmt *) parsetree);
+				objectId = CreateConversionCommand((CreateConversionStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_CONVERSION, parsetree);
 				break;
 
 			case T_CreateCastStmt:
-				CreateCast((CreateCastStmt *) parsetree);
+				objectId = CreateCast((CreateCastStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_CAST, parsetree);
 				break;
 
 			case T_CreateOpClassStmt:
-				DefineOpClass((CreateOpClassStmt *) parsetree);
+				objectId = DefineOpClass((CreateOpClassStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_OPCLASS, parsetree);
 				break;
 
 			case T_CreateOpFamilyStmt:
-				DefineOpFamily((CreateOpFamilyStmt *) parsetree);
+				objectId = DefineOpFamily((CreateOpFamilyStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_OPFAMILY, parsetree);
 				break;
 
 			case T_AlterOpFamilyStmt:
diff --git a/src/backend/utils/adt/format_type.c b/src/backend/utils/adt/format_type.c
index 5b75d34..b0d77aa 100644
--- a/src/backend/utils/adt/format_type.c
+++ b/src/backend/utils/adt/format_type.c
@@ -96,6 +96,9 @@ format_type_be(Oid type_oid)
 	return format_type_internal(type_oid, -1, false, false, false);
 }
 
+/*
+ * This version returns a name which is always qualified.
+ */
 char *
 format_type_be_qualified(Oid type_oid)
 {
@@ -285,7 +288,8 @@ format_type_internal(Oid type_oid, int32 typemod,
 
 		case VARCHAROID:
 			if (with_typemod)
-				buf = printTypmod("character varying", typemod, typeform->typmodout);
+				buf = printTypmod("character varying", typemod,
+								  typeform->typmodout);
 			else
 				buf = pstrdup("character varying");
 			break;
@@ -323,6 +327,72 @@ format_type_internal(Oid type_oid, int32 typemod,
 	return buf;
 }
 
+/*
+ * Similar to format_type_internal, except we return each bit of information
+ * separately:
+ *
+ * - nspname is the schema name, without quotes.
+ *
+ * - typename is set to the type name, without quotes
+ *
+ * - typmod is set to the typemod, if any, as a string with parens
+ *
+ * - is_array indicates whether []s must be added
+ *
+ * Also, we don't try to decode type names to their standard-mandated names.
+ *
+ * XXX there is a lot of code duplication between this routine and
+ * format_type_internal.  (One thing that doesn't quite match is the whole
+ * allow_invalid business.)
+ */
+void
+format_type_detailed(Oid type_oid, int32 typemod,
+					 char **nspname, char **typname, char **typemodstr,
+					 bool *is_array)
+{
+	HeapTuple	tuple;
+	Form_pg_type typeform;
+	Oid			array_base_type;
+
+	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
+	if (!HeapTupleIsValid(tuple))
+		elog(ERROR, "cache lookup failed for type %u", type_oid);
+
+	typeform = (Form_pg_type) GETSTRUCT(tuple);
+
+	/*
+	 * Check if it's a regular (variable length) array type.  As above,
+	 * fixed-length array types such as "name" shouldn't get deconstructed.
+	 */
+	array_base_type = typeform->typelem;
+
+	if (array_base_type != InvalidOid &&
+		typeform->typstorage != 'p')
+	{
+		/* Switch our attention to the array element type */
+		ReleaseSysCache(tuple);
+		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for type %u", type_oid);
+
+		typeform = (Form_pg_type) GETSTRUCT(tuple);
+		type_oid = array_base_type;
+		*is_array = true;
+	}
+	else
+		*is_array = false;
+
+	*nspname = get_namespace_name(typeform->typnamespace);
+	*typname = pstrdup(NameStr(typeform->typname));
+
+	if (typemod > 0)
+		*typemodstr = printTypmod(NULL, typemod, typeform->typmodout);
+	else
+		*typemodstr = pstrdup("");	/* XXX ?? */
+
+	ReleaseSysCache(tuple);
+}
+
 
 /*
  * Add typmod decoration to the basic type name
@@ -338,7 +408,10 @@ printTypmod(const char *typname, int32 typmod, Oid typmodout)
 	if (typmodout == InvalidOid)
 	{
 		/* Default behavior: just print the integer typmod with parens */
-		res = psprintf("%s(%d)", typname, (int) typmod);
+		if (typname == NULL)
+			res = psprintf("(%d)", (int) typmod);
+		else
+			res = psprintf("%s(%d)", typname, (int) typmod);
 	}
 	else
 	{
@@ -347,13 +420,15 @@ printTypmod(const char *typname, int32 typmod, Oid typmodout)
 
 		tmstr = DatumGetCString(OidFunctionCall1(typmodout,
 												 Int32GetDatum(typmod)));
-		res = psprintf("%s%s", typname, tmstr);
+		if (typname == NULL)
+			res = psprintf("%s", tmstr);
+		else
+			res = psprintf("%s%s", typname, tmstr);
 	}
 
 	return res;
 }
 
-
 /*
  * type_maximum_size --- determine maximum width of a variable-width column
  *
diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c
index e1d8aae..11b1e00 100644
--- a/src/backend/utils/adt/jsonfuncs.c
+++ b/src/backend/utils/adt/jsonfuncs.c
@@ -226,13 +226,13 @@ typedef struct PopulateRecordsetState
 } PopulateRecordsetState;
 
 /*
- * SQL function json_object-keys
+ * SQL function json_object_keys
  *
  * Returns the set of keys for the object argument.
  *
  * This SRF operates in value-per-call mode. It processes the
  * object during the first call, and the keys are simply stashed
- * in an array, whise size is expanded as necessary. This is probably
+ * in an array, whose size is expanded as necessary. This is probably
  * safe enough for a list of keys of a single object, since they are
  * limited in size to NAMEDATALEN and the number of keys is unlikely to
  * be so huge that it has major memory implications.
@@ -1193,7 +1193,7 @@ elements_array_element_end(void *state, bool isnull)
 	text	   *val;
 	HeapTuple	tuple;
 	Datum		values[1];
-	bool nulls[1] = {false};
+	bool		nulls[1] = {false};
 
 	/* skip over nested objects */
 	if (_state->lex->lex_level != 1)
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index add5cd1..21ca679 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -587,6 +587,13 @@ pg_get_viewdef_name_ext(PG_FUNCTION_ARGS)
 	PG_RETURN_TEXT_P(string_to_text(pg_get_viewdef_worker(viewoid, prettyFlags, WRAP_COLUMN_DEFAULT)));
 }
 
+char *
+pg_get_viewdef_internal(Oid viewoid)
+{
+	return pg_get_viewdef_worker(viewoid, 0, WRAP_COLUMN_DEFAULT);
+}
+
+
 /*
  * Common code for by-OID and by-name variants of pg_get_viewdef
  */
@@ -966,6 +973,8 @@ pg_get_indexdef_columns(Oid indexrelid, bool pretty)
  *
  * This is now used for exclusion constraints as well: if excludeOps is not
  * NULL then it points to an array of exclusion operator OIDs.
+ *
+ * XXX if you change this function, see pg_get_indexdef_detailed too.
  */
 static char *
 pg_get_indexdef_worker(Oid indexrelid, int colno,
@@ -1245,6 +1254,245 @@ pg_get_indexdef_worker(Oid indexrelid, int colno,
 	return buf.data;
 }
 
+/*
+ * Return an index definition, split in several pieces.
+ *
+ * There is a huge lot of code that's a dupe of pg_get_indexdef_worker, but
+ * control flow is different enough that it doesn't seem worth keeping them
+ * together.
+ */
+void
+pg_get_indexdef_detailed(Oid indexrelid,
+						 char **index_am,
+						 char **definition,
+						 char **reloptions,
+						 char **tablespace,
+						 char **whereClause)
+{
+	HeapTuple	ht_idx;
+	HeapTuple	ht_idxrel;
+	HeapTuple	ht_am;
+	Form_pg_index idxrec;
+	Form_pg_class idxrelrec;
+	Form_pg_am	amrec;
+	List	   *indexprs;
+	ListCell   *indexpr_item;
+	List	   *context;
+	Oid			indrelid;
+	int			keyno;
+	Datum		indcollDatum;
+	Datum		indclassDatum;
+	Datum		indoptionDatum;
+	bool		isnull;
+	oidvector  *indcollation;
+	oidvector  *indclass;
+	int2vector *indoption;
+	StringInfoData definitionBuf;
+	char	   *sep;
+
+	/*
+	 * Fetch the pg_index tuple by the Oid of the index
+	 */
+	ht_idx = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexrelid));
+	if (!HeapTupleIsValid(ht_idx))
+		elog(ERROR, "cache lookup failed for index %u", indexrelid);
+	idxrec = (Form_pg_index) GETSTRUCT(ht_idx);
+
+	indrelid = idxrec->indrelid;
+	Assert(indexrelid == idxrec->indexrelid);
+
+	/* Must get indcollation, indclass, and indoption the hard way */
+	indcollDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+								   Anum_pg_index_indcollation, &isnull);
+	Assert(!isnull);
+	indcollation = (oidvector *) DatumGetPointer(indcollDatum);
+
+	indclassDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+									Anum_pg_index_indclass, &isnull);
+	Assert(!isnull);
+	indclass = (oidvector *) DatumGetPointer(indclassDatum);
+
+	indoptionDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+									 Anum_pg_index_indoption, &isnull);
+	Assert(!isnull);
+	indoption = (int2vector *) DatumGetPointer(indoptionDatum);
+
+	/*
+	 * Fetch the pg_class tuple of the index relation
+	 */
+	ht_idxrel = SearchSysCache1(RELOID, ObjectIdGetDatum(indexrelid));
+	if (!HeapTupleIsValid(ht_idxrel))
+		elog(ERROR, "cache lookup failed for relation %u", indexrelid);
+	idxrelrec = (Form_pg_class) GETSTRUCT(ht_idxrel);
+
+	/*
+	 * Fetch the pg_am tuple of the index' access method
+	 */
+	ht_am = SearchSysCache1(AMOID, ObjectIdGetDatum(idxrelrec->relam));
+	if (!HeapTupleIsValid(ht_am))
+		elog(ERROR, "cache lookup failed for access method %u",
+			 idxrelrec->relam);
+	amrec = (Form_pg_am) GETSTRUCT(ht_am);
+
+	/*
+	 * Get the index expressions, if any.  (NOTE: we do not use the relcache
+	 * versions of the expressions and predicate, because we want to display
+	 * non-const-folded expressions.)
+	 */
+	if (!heap_attisnull(ht_idx, Anum_pg_index_indexprs))
+	{
+		Datum		exprsDatum;
+		bool		isnull;
+		char	   *exprsString;
+
+		exprsDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+									 Anum_pg_index_indexprs, &isnull);
+		Assert(!isnull);
+		exprsString = TextDatumGetCString(exprsDatum);
+		indexprs = (List *) stringToNode(exprsString);
+		pfree(exprsString);
+	}
+	else
+		indexprs = NIL;
+
+	indexpr_item = list_head(indexprs);
+
+	context = deparse_context_for(get_relation_name(indrelid), indrelid);
+
+	initStringInfo(&definitionBuf);
+
+	/* output index AM */
+	*index_am = pstrdup(quote_identifier(NameStr(amrec->amname)));
+
+	/*
+	 * Output index definition.  Note the outer parens must be supplied by
+	 * caller.
+	 */
+	sep = "";
+	for (keyno = 0; keyno < idxrec->indnatts; keyno++)
+	{
+		AttrNumber	attnum = idxrec->indkey.values[keyno];
+		int16		opt = indoption->values[keyno];
+		Oid			keycoltype;
+		Oid			keycolcollation;
+		Oid			indcoll;
+
+		appendStringInfoString(&definitionBuf, sep);
+		sep = ", ";
+
+		if (attnum != 0)
+		{
+			/* Simple index column */
+			char	   *attname;
+			int32		keycoltypmod;
+
+			attname = get_relid_attribute_name(indrelid, attnum);
+			appendStringInfoString(&definitionBuf, quote_identifier(attname));
+			get_atttypetypmodcoll(indrelid, attnum,
+								  &keycoltype, &keycoltypmod,
+								  &keycolcollation);
+		}
+		else
+		{
+			/* expressional index */
+			Node	   *indexkey;
+			char	   *str;
+
+			if (indexpr_item == NULL)
+				elog(ERROR, "too few entries in indexprs list");
+			indexkey = (Node *) lfirst(indexpr_item);
+			indexpr_item = lnext(indexpr_item);
+			/* Deparse */
+			str = deparse_expression_pretty(indexkey, context, false, false,
+											0, 0);
+
+			/* Need parens if it's not a bare function call */
+			if (indexkey && IsA(indexkey, FuncExpr) &&
+				((FuncExpr *) indexkey)->funcformat == COERCE_EXPLICIT_CALL)
+				appendStringInfoString(&definitionBuf, str);
+			else
+				appendStringInfo(&definitionBuf, "(%s)", str);
+
+			keycoltype = exprType(indexkey);
+			keycolcollation = exprCollation(indexkey);
+		}
+
+		/* Add collation, even if default */
+		indcoll = indcollation->values[keyno];
+		if (OidIsValid(indcoll))
+			appendStringInfo(&definitionBuf, " COLLATE %s",
+							 generate_collation_name((indcoll)));
+
+		/* Add the operator class name, even if default */
+		get_opclass_name(indclass->values[keyno], InvalidOid, &definitionBuf);
+
+		/* Add options if relevant */
+		if (amrec->amcanorder)
+		{
+			/* if it supports sort ordering, report DESC and NULLS opts */
+			if (opt & INDOPTION_DESC)
+			{
+				appendStringInfoString(&definitionBuf, " DESC");
+				/* NULLS FIRST is the default in this case */
+				if (!(opt & INDOPTION_NULLS_FIRST))
+					appendStringInfoString(&definitionBuf, " NULLS LAST");
+			}
+			else
+			{
+				if (opt & INDOPTION_NULLS_FIRST)
+					appendStringInfoString(&definitionBuf, " NULLS FIRST");
+			}
+		}
+
+		/* XXX excludeOps thingy was here; do we need anything? */
+	}
+	*definition = definitionBuf.data;
+
+	/* output reloptions */
+	*reloptions = flatten_reloptions(indexrelid);
+
+	/* output tablespace */
+	{
+		Oid			tblspc;
+
+		tblspc = get_rel_tablespace(indexrelid);
+		if (OidIsValid(tblspc))
+			*tablespace = pstrdup(quote_identifier(get_tablespace_name(tblspc)));
+		else
+			*tablespace = NULL;
+	}
+
+	/* report index predicate, if any */
+	if (!heap_attisnull(ht_idx, Anum_pg_index_indpred))
+	{
+		Node	   *node;
+		Datum		predDatum;
+		bool		isnull;
+		char	   *predString;
+
+		/* Convert text string to node tree */
+		predDatum = SysCacheGetAttr(INDEXRELID, ht_idx,
+									Anum_pg_index_indpred, &isnull);
+		Assert(!isnull);
+		predString = TextDatumGetCString(predDatum);
+		node = (Node *) stringToNode(predString);
+		pfree(predString);
+
+		/* Deparse */
+		*whereClause =
+			deparse_expression_pretty(node, context, false, false,
+									  0, 0);
+	}
+	else
+		*whereClause = NULL;
+
+	/* Clean up */
+	ReleaseSysCache(ht_idx);
+	ReleaseSysCache(ht_idxrel);
+	ReleaseSysCache(ht_am);
+
+	/* all done */
+}
 
 /*
  * pg_get_constraintdef
@@ -1279,9 +1527,9 @@ pg_get_constraintdef_ext(PG_FUNCTION_ARGS)
 
 /* Internal version that returns a palloc'd C string; no pretty-printing */
 char *
-pg_get_constraintdef_string(Oid constraintId)
+pg_get_constraintdef_string(Oid constraintId, bool fullCommand)
 {
-	return pg_get_constraintdef_worker(constraintId, true, 0);
+	return pg_get_constraintdef_worker(constraintId, fullCommand, 0);
 }
 
 static char *
@@ -2368,8 +2616,10 @@ pg_get_function_arg_default(PG_FUNCTION_ARGS)
 
 	proc = (Form_pg_proc) GETSTRUCT(proctup);
 
-	/* Calculate index into proargdefaults: proargdefaults corresponds to the
-	 * last N input arguments, where N = pronargdefaults. */
+	/*
+	 * Calculate index into proargdefaults: proargdefaults corresponds to the
+	 * last N input arguments, where N = pronargdefaults.
+	 */
 	nth_default = nth_inputarg - 1 - (proc->pronargs - proc->pronargdefaults);
 
 	if (nth_default < 0 || nth_default >= list_length(argdefaults))
@@ -4156,6 +4406,20 @@ get_query_def(Query *query, StringInfo buf, List *parentnamespace,
 	}
 }
 
+char *
+pg_get_viewstmt_definition(Query *viewParse)
+{
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+
+	get_query_def(viewParse, &buf, NIL, NULL, 0,
+				  WRAP_COLUMN_DEFAULT, 1);
+
+	return buf.data;
+}
+
+
 /* ----------
  * get_values_def			- Parse back a VALUES list
  * ----------
@@ -9096,3 +9360,21 @@ flatten_reloptions(Oid relid)
 
 	return result;
 }
+
+/*
+ * Obtain the deparsed default value for the given column of the given table.
+ *
+ * Caller must have set a correct deparse context.
+ */
+char *
+RelationGetColumnDefault(Relation rel, AttrNumber attno, List *dpcontext)
+{
+	Node *defval;
+	char *defstr;
+
+	defval = build_column_default(rel, attno);
+	defstr = deparse_expression_pretty(defval, dpcontext, false, false,
+									   0, 0);
+
+	return defstr;
+}
diff --git a/src/include/catalog/objectaddress.h b/src/include/catalog/objectaddress.h
index 2a9431d..fd20291 100644
--- a/src/include/catalog/objectaddress.h
+++ b/src/include/catalog/objectaddress.h
@@ -32,6 +32,8 @@ extern ObjectAddress get_object_address(ObjectType objtype, List *objname,
 				   List *objargs, Relation *relp,
 				   LOCKMODE lockmode, bool missing_ok);
 
+extern Oid get_objtype_catalog_oid(ObjectType objtype);
+
 extern void check_object_ownership(Oid roleid,
 					   ObjectType objtype, ObjectAddress address,
 					   List *objname, List *objargs, Relation relation);
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index e6713a6..66ab6f1 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -4793,6 +4793,10 @@ DESCR("information about replication slots currently in use");
 /* event triggers */
 DATA(insert OID = 3566 (  pg_event_trigger_dropped_objects		PGNSP PGUID 12 10 100 0 0 f f f f t t s 0 0 2249 "" "{26,26,23,25,25,25,25}" "{o,o,o,o,o,o,o}" "{classid, objid, objsubid, object_type, schema_name, object_name, object_identity}" _null_ pg_event_trigger_dropped_objects _null_ _null_ _null_ ));
 DESCR("list objects dropped by the current command");
+DATA(insert OID = 3567 (  pg_event_trigger_get_creation_commands PGNSP PGUID 12 10 100 0 0 f f f f t t s 0 0 2249 "" "{25,114}" "{o,o}" "{identity,command}" _null_ pg_event_trigger_get_creation_commands _null_ _null_ _null_ ));
+DESCR("list objects created by the current command");
+DATA(insert OID = 3568 (  pg_event_trigger_expand_command PGNSP PGUID 12 10 1 0 0 f f f f t f s 1 0 25 "114" _null_ _null_ _null_ _null_ pg_event_trigger_expand_command _null_ _null_ _null_ ));
+DESCR("format JSON message");
 
 /* generic transition functions for ordered-set aggregates */
 DATA(insert OID = 3970 ( ordered_set_transition			PGNSP PGUID 12 1 0 0 0 f f f f f f i 2 0 2281 "2281 2276" _null_ _null_ _null_ _null_ ordered_set_transition _null_ _null_ _null_ ));
diff --git a/src/include/commands/alter_table.h b/src/include/commands/alter_table.h
new file mode 100644
index 0000000..0974098
--- /dev/null
+++ b/src/include/commands/alter_table.h
@@ -0,0 +1,53 @@
+#ifndef ALTER_TABLE_H
+#define ALTER_TABLE_H
+
+/*
+ * State information for ALTER TABLE
+ *
+ * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
+ * structs, one for each table modified by the operation (the named table
+ * plus any child tables that are affected).  We save lists of subcommands
+ * to apply to this table (possibly modified by parse transformation steps);
+ * these lists will be executed in Phase 2.  If a Phase 3 step is needed,
+ * necessary information is stored in the constraints and newvals lists.
+ *
+ * Phase 2 is divided into multiple passes; subcommands are executed in
+ * a pass determined by subcommand type.
+ */
+
+#define AT_PASS_UNSET			-1		/* UNSET will cause ERROR */
+#define AT_PASS_DROP			0		/* DROP (all flavors) */
+#define AT_PASS_ALTER_TYPE		1		/* ALTER COLUMN TYPE */
+#define AT_PASS_OLD_INDEX		2		/* re-add existing indexes */
+#define AT_PASS_OLD_CONSTR		3		/* re-add existing constraints */
+#define AT_PASS_COL_ATTRS		4		/* set other column attributes */
+/* We could support a RENAME COLUMN pass here, but not currently used */
+#define AT_PASS_ADD_COL			5		/* ADD COLUMN */
+#define AT_PASS_ADD_INDEX		6		/* ADD indexes */
+#define AT_PASS_ADD_CONSTR		7		/* ADD constraints, defaults */
+#define AT_PASS_MISC			8		/* other stuff */
+#define AT_NUM_PASSES			9
+
+typedef struct AlteredTableInfo
+{
+	/* Information saved before any work commences: */
+	Oid			relid;			/* Relation to work on */
+	char		relkind;		/* Its relkind */
+	TupleDesc	oldDesc;		/* Pre-modification tuple descriptor */
+	/* Information saved by Phase 1 for Phase 2: */
+	List	   *subcmds[AT_NUM_PASSES]; /* Lists of AlterTableCmd */
+	/* Information saved by Phases 1/2 for Phase 3: */
+	List	   *constraints;	/* List of NewConstraint */
+	List	   *newvals;		/* List of NewColumnValue */
+	bool		new_notnull;	/* T if we added new NOT NULL constraints */
+	bool		rewrite;		/* T if a rewrite is forced */
+	Oid			newTableSpace;	/* new tablespace; 0 means no change */
+	/* Objects to rebuild after completing ALTER TYPE operations */
+	List	   *changedConstraintOids;	/* OIDs of constraints to rebuild */
+	List	   *changedConstraintDefs;	/* string definitions of same */
+	List	   *changedIndexOids;		/* OIDs of indexes to rebuild */
+	List	   *changedIndexDefs;		/* string definitions of same */
+} AlteredTableInfo;
+
+
+#endif	/* ALTER_TABLE_H */
diff --git a/src/include/commands/createas.h b/src/include/commands/createas.h
index c17d829..477339d 100644
--- a/src/include/commands/createas.h
+++ b/src/include/commands/createas.h
@@ -19,7 +19,7 @@
 #include "tcop/dest.h"
 
 
-extern void ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
+extern Oid	ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 				  ParamListInfo params, char *completionTag);
 
 extern int	GetIntoRelEFlags(IntoClause *intoClause);
diff --git a/src/include/commands/event_trigger.h b/src/include/commands/event_trigger.h
index 0233f4c..3c38af3 100644
--- a/src/include/commands/event_trigger.h
+++ b/src/include/commands/event_trigger.h
@@ -49,6 +49,8 @@ extern void EventTriggerSQLDrop(Node *parsetree);
 
 extern bool EventTriggerBeginCompleteQuery(void);
 extern void EventTriggerEndCompleteQuery(void);
+extern void EventTriggerStashCommand(Oid objectId, ObjectType objtype,
+						 Node *parsetree);
 extern bool trackDroppedObjectsNeeded(void);
 extern void EventTriggerSQLDropAddObject(ObjectAddress *object);
 
diff --git a/src/include/commands/matview.h b/src/include/commands/matview.h
index 476b285..2c468b2 100644
--- a/src/include/commands/matview.h
+++ b/src/include/commands/matview.h
@@ -22,7 +22,7 @@
 
 extern void SetMatViewPopulatedState(Relation relation, bool newstate);
 
-extern void ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
+extern Oid ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 				   ParamListInfo params, char *completionTag);
 
 extern DestReceiver *CreateTransientRelDestReceiver(Oid oid);
diff --git a/src/include/commands/sequence.h b/src/include/commands/sequence.h
index 7d8a370..b7a5db4 100644
--- a/src/include/commands/sequence.h
+++ b/src/include/commands/sequence.h
@@ -70,6 +70,7 @@ extern Datum setval3_oid(PG_FUNCTION_ARGS);
 extern Datum lastval(PG_FUNCTION_ARGS);
 
 extern Datum pg_sequence_parameters(PG_FUNCTION_ARGS);
+extern Form_pg_sequence get_sequence_values(Oid sequenceId);
 
 extern Oid	DefineSequence(CreateSeqStmt *stmt);
 extern Oid	AlterSequence(AlterSeqStmt *stmt);
diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index ad58b39..6f87e53 100644
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -1221,6 +1221,7 @@ typedef enum ObjectType
 	OBJECT_TSPARSER,
 	OBJECT_TSTEMPLATE,
 	OBJECT_TYPE,
+	OBJECT_USER_MAPPING,
 	OBJECT_VIEW
 } ObjectType;
 
diff --git a/src/include/tcop/deparse_utility.h b/src/include/tcop/deparse_utility.h
new file mode 100644
index 0000000..7e63f52
--- /dev/null
+++ b/src/include/tcop/deparse_utility.h
@@ -0,0 +1,17 @@
+/*-------------------------------------------------------------------------
+ *
+ * deparse_utility.h
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/tcop/deparse_utility.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DEPARSE_UTILITY_H
+#define DEPARSE_UTILITY_H
+
+extern char *deparse_utility_command(Oid objectId, Node *parsetree);
+
+#endif	/* DEPARSE_UTILITY_H */
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index b90d88d..8fd829d 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -663,15 +663,24 @@ extern Datum pg_get_viewdef_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_viewdef_wrap(PG_FUNCTION_ARGS);
 extern Datum pg_get_viewdef_name(PG_FUNCTION_ARGS);
 extern Datum pg_get_viewdef_name_ext(PG_FUNCTION_ARGS);
+extern char *pg_get_viewdef_internal(Oid viewoid);
 extern Datum pg_get_indexdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_indexdef_ext(PG_FUNCTION_ARGS);
 extern char *pg_get_indexdef_string(Oid indexrelid);
 extern char *pg_get_indexdef_columns(Oid indexrelid, bool pretty);
+extern void pg_get_indexdef_detailed(Oid indexrelid,
+						 char **index_am,
+						 char **definition,
+						 char **reloptions,
+						 char **tablespace,
+						 char **whereClause);
+
 extern Datum pg_get_triggerdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_triggerdef_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_constraintdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_constraintdef_ext(PG_FUNCTION_ARGS);
-extern char *pg_get_constraintdef_string(Oid constraintId);
+extern char *pg_get_constraintdef_string(Oid constraintId, bool fullCommand);
+extern char *pg_get_viewstmt_definition(Query *viewParse);
 extern Datum pg_get_expr(PG_FUNCTION_ARGS);
 extern Datum pg_get_expr_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_userbyid(PG_FUNCTION_ARGS);
@@ -1057,6 +1066,9 @@ extern char *format_type_be_qualified(Oid type_oid);
 extern char *format_type_with_typemod(Oid type_oid, int32 typemod);
 extern Datum oidvectortypes(PG_FUNCTION_ARGS);
 extern int32 type_maximum_size(Oid type_oid, int32 typemod);
+extern void format_type_detailed(Oid type_oid, int32 typemod,
+					 char **nspname, char **typname,
+					 char **typemodstr, bool *is_array);
 
 /* quote.c */
 extern Datum quote_ident(PG_FUNCTION_ARGS);
@@ -1177,6 +1189,8 @@ extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
 /* commands/event_trigger.c */
 extern Datum pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS);
+extern Datum pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS);
+extern Datum pg_event_trigger_expand_command(PG_FUNCTION_ARGS);
 
 /* commands/extension.c */
 extern Datum pg_available_extensions(PG_FUNCTION_ARGS);
diff --git a/src/include/utils/relcache.h b/src/include/utils/relcache.h
index 31f4878..4501134 100644
--- a/src/include/utils/relcache.h
+++ b/src/include/utils/relcache.h
@@ -41,6 +41,9 @@ extern List *RelationGetIndexList(Relation relation);
 extern Oid	RelationGetOidIndex(Relation relation);
 extern List *RelationGetIndexExpressions(Relation relation);
 extern List *RelationGetIndexPredicate(Relation relation);
+/* in ruleutils.c */
+extern char *RelationGetColumnDefault(Relation rel, AttrNumber attno,
+						 List *dpcontext);
 
 typedef enum IndexAttrBitmapKind
 {

>From 94137ba6c7ef0a05c1bc0df7966ce44cbaeffe36 Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Tue, 6 May 2014 11:53:45 +0530
Subject: [PATCH 32/36] deparse: Initial support for CREATE TEXT SEARCH
 CONFIGURATION

Since there's no way to create token-dict mappings with this CREATE
command, we search for them and refuse to deparse the configuration
if they exist.
---
 src/backend/tcop/deparse_utility.c | 86 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 85 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 8c2fa9e..bfe0eee 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -47,6 +47,8 @@
 #include "catalog/pg_range.h"
 #include "catalog/pg_rewrite.h"
 #include "catalog/pg_trigger.h"
+#include "catalog/pg_ts_config.h"
+#include "catalog/pg_ts_config_map.h"
 #include "catalog/pg_ts_dict.h"
 #include "catalog/pg_ts_parser.h"
 #include "catalog/pg_ts_template.h"
@@ -757,6 +759,85 @@ deparse_DefineStmt_Operator(Oid objectId, DefineStmt *define)
 }
 
 static ObjTree *
+deparse_DefineStmt_TSConfig(Oid objectId, DefineStmt *define)
+{
+	HeapTuple   tscTup;
+	HeapTuple   tspTup;
+	ObjTree	   *stmt;
+	Form_pg_ts_config tscForm;
+	Form_pg_ts_parser tspForm;
+
+	tscTup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(tscTup))
+		elog(ERROR, "cache lookup failed for text search configuration "
+			 "with OID %u", objectId);
+	tscForm = (Form_pg_ts_config) GETSTRUCT(tscTup);
+
+	tspTup = SearchSysCache1(TSPARSEROID, ObjectIdGetDatum(tscForm->cfgparser));
+	if (!HeapTupleIsValid(tspTup))
+		elog(ERROR, "cache lookup failed for text search parser with OID %u",
+			 tscForm->cfgparser);
+	tspForm = (Form_pg_ts_parser) GETSTRUCT(tspTup);
+
+	stmt = new_objtree_VA("CREATE TEXT SEARCH CONFIGURATION %{identity}D "
+						  "(PARSER=%{parser}s)", 0);
+
+	append_object_object(stmt, "identity",
+						 new_objtree_for_qualname(tscForm->cfgnamespace,
+												  NameStr(tscForm->cfgname)));
+	append_object_object(stmt, "parser",
+						 new_objtree_for_qualname(tspForm->prsnamespace,
+												  NameStr(tspForm->prsname)));
+
+	/*
+	 * If this text search configuration was created by copying another
+	 * one with "CREATE TEXT SEARCH CONFIGURATION x (COPY=y)", then y's
+	 * PARSER selection is copied along with its mappings of tokens to
+	 * dictionaries (created with ALTER … ADD MAPPING …).
+	 *
+	 * Unfortunately, there's no way to define these mappings in the
+	 * CREATE command, so if they exist for the configuration we're
+	 * deparsing, we must detect them and fail.
+	 */
+
+	{
+		ScanKeyData skey;
+		SysScanDesc scan;
+		HeapTuple	tup;
+		Relation	map;
+		bool		has_mapping;
+
+		map = heap_open(TSConfigMapRelationId, AccessShareLock);
+
+		ScanKeyInit(&skey,
+					Anum_pg_ts_config_map_mapcfg,
+					BTEqualStrategyNumber, F_OIDEQ,
+					ObjectIdGetDatum(objectId));
+
+		scan = systable_beginscan(map, TSConfigMapIndexId, true,
+								  NULL, 1, &skey);
+
+		while (HeapTupleIsValid((tup = systable_getnext(scan))))
+		{
+			has_mapping = true;
+			break;
+		}
+
+		systable_endscan(scan);
+		heap_close(map, AccessShareLock);
+
+		if (has_mapping)
+			ereport(ERROR,
+					(errmsg("can't recreate text search configuration with mappings")));
+	}
+
+	ReleaseSysCache(tspTup);
+	ReleaseSysCache(tscTup);
+
+	return stmt;
+}
+
+static ObjTree *
 deparse_DefineStmt_TSParser(Oid objectId, DefineStmt *define)
 {
 	HeapTuple   tspTup;
@@ -1137,6 +1218,10 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 			defStmt = deparse_DefineStmt_Operator(objectId, define);
 			break;
 
+		case OBJECT_TSCONFIGURATION:
+			defStmt = deparse_DefineStmt_TSConfig(objectId, define);
+			break;
+
 		case OBJECT_TSPARSER:
 			defStmt = deparse_DefineStmt_TSParser(objectId, define);
 			break;
@@ -1155,7 +1240,6 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 
 		default:
 		case OBJECT_AGGREGATE:
-		case OBJECT_TSCONFIGURATION:
 			elog(ERROR, "unsupported object kind");
 			return NULL;
 	}
-- 
1.9.1

>From b765cadf59111ecfafcb73b73035ddac41b0516d Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Tue, 6 May 2014 13:46:01 +0530
Subject: [PATCH 33/36] deparse: Support CREATE AGGREGATE

---
 src/backend/tcop/deparse_utility.c | 241 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 240 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index bfe0eee..ec457ca 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -638,6 +638,242 @@ get_persistence_str(char persistence)
 }
 
 static ObjTree *
+deparse_DefineStmt_Aggregate(Oid objectId, DefineStmt *define)
+{
+	HeapTuple   aggTup;
+	HeapTuple   procTup;
+	ObjTree	   *stmt;
+	ObjTree	   *tmp;
+	List	   *list;
+	Datum		initval;
+	bool		isnull;
+	Form_pg_aggregate agg;
+	Form_pg_proc proc;
+
+	aggTup = SearchSysCache1(AGGFNOID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(aggTup))
+		elog(ERROR, "cache lookup failed for aggregate with OID %u", objectId);
+	agg = (Form_pg_aggregate) GETSTRUCT(aggTup);
+
+	procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(agg->aggfnoid));
+	if (!HeapTupleIsValid(procTup))
+		elog(ERROR, "cache lookup failed for procedure with OID %u",
+			 agg->aggfnoid);
+	proc = (Form_pg_proc) GETSTRUCT(procTup);
+
+	stmt = new_objtree_VA("CREATE AGGREGATE %{identity}D (%{types:, }s) "
+						  "(%{elems:, }s)", 0);
+
+	append_object_object(stmt, "identity",
+						 new_objtree_for_qualname(proc->pronamespace,
+												  NameStr(proc->proname)));
+
+	list = NIL;
+
+	/*
+	 * An aggregate may have no arguments, in which case its signature
+	 * is (*), to match count(*). If it's not an ordered-set aggregate,
+	 * it may have a non-zero number of arguments. Otherwise it may have
+	 * zero or more direct arguments and zero or more ordered arguments.
+	 * There are no defaults or table parameters, and the only mode that
+	 * we need to consider is VARIADIC.
+	 */
+
+	if (proc->pronargs == 0)
+		list = lappend(list, new_object_object(NULL, new_objtree_VA("*", 0)));
+	else
+	{
+		int			i;
+		int			nargs;
+		Oid		   *types;
+		char	   *modes;
+		char	  **names;
+		int			insertorderbyat = -1;
+
+		nargs = get_func_arg_info(procTup, &types, &names, &modes);
+
+		if (AGGKIND_IS_ORDERED_SET(agg->aggkind))
+			insertorderbyat = agg->aggnumdirectargs;
+
+		for (i = 0; i < nargs; i++)
+		{
+			tmp = new_objtree_VA("%{order}s%{mode}s%{name}s%{type}T", 0);
+
+			if (i == insertorderbyat)
+				append_string_object(tmp, "order", "ORDER BY ");
+			else
+				append_string_object(tmp, "order", "");
+
+			if (modes)
+				append_string_object(tmp, "mode",
+									 modes[i] == 'v' ? "VARIADIC " : "");
+			else
+				append_string_object(tmp, "mode", "");
+
+			if (names)
+				append_string_object(tmp, "name", names[i]);
+			else
+				append_string_object(tmp, "name", " ");
+
+			append_object_object(tmp, "type",
+								 new_objtree_for_type(types[i], -1));
+
+			list = lappend(list, new_object_object(NULL, tmp));
+
+			/*
+			 * For variadic ordered-set aggregates, we have to repeat
+			 * the last argument. This nasty hack is copied from
+			 * print_function_arguments in ruleutils.c
+			 */
+			if (i == insertorderbyat && i == nargs-1)
+				list = lappend(list, new_object_object(NULL, tmp));
+		}
+	}
+
+	append_array_object(stmt, "types", list);
+
+	list = NIL;
+
+	tmp = new_objtree_VA("SFUNC=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 agg->aggtransfn));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	tmp = new_objtree_VA("STYPE=%{type}T", 0);
+	append_object_object(tmp, "type",
+						 new_objtree_for_type(agg->aggtranstype, -1));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	if (agg->aggtransspace != 0)
+	{
+		tmp = new_objtree_VA("SSPACE=%{space}s", 1,
+							 "space", ObjTypeString,
+							 psprintf("%d", agg->aggtransspace));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(agg->aggfinalfn))
+	{
+		tmp = new_objtree_VA("FINALFUNC=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 agg->aggfinalfn));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (agg->aggfinalextra)
+	{
+		tmp = new_objtree_VA("FINALFUNC_EXTRA=true", 0);
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	initval = SysCacheGetAttr(AGGFNOID, aggTup,
+							  Anum_pg_aggregate_agginitval,
+							  &isnull);
+	if (!isnull)
+	{
+		tmp = new_objtree_VA("INITCOND=%{initval}L",
+							 1, "initval", ObjTypeString,
+							 TextDatumGetCString(initval));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(agg->aggmtransfn))
+	{
+		tmp = new_objtree_VA("MSFUNC=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 agg->aggmtransfn));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(agg->aggmtranstype))
+	{
+		tmp = new_objtree_VA("MSTYPE=%{type}T", 0);
+		append_object_object(tmp, "type",
+							 new_objtree_for_type(agg->aggmtranstype, -1));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (agg->aggmtransspace != 0)
+	{
+		tmp = new_objtree_VA("SSPACE=%{space}s", 1,
+							 "space", ObjTypeString,
+							 psprintf("%d", agg->aggmtransspace));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(agg->aggminvtransfn))
+	{
+		tmp = new_objtree_VA("MINVFUNC=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 agg->aggminvtransfn));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(agg->aggmfinalfn))
+	{
+		tmp = new_objtree_VA("MFINALFUNC=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 agg->aggmfinalfn));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (agg->aggmfinalextra)
+	{
+		tmp = new_objtree_VA("MFINALFUNC_EXTRA=true", 0);
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	initval = SysCacheGetAttr(AGGFNOID, aggTup,
+							  Anum_pg_aggregate_aggminitval,
+							  &isnull);
+	if (!isnull)
+	{
+		tmp = new_objtree_VA("MINITCOND=%{initval}L",
+							 1, "initval", ObjTypeString,
+							 TextDatumGetCString(initval));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (agg->aggkind == AGGKIND_HYPOTHETICAL)
+	{
+		tmp = new_objtree_VA("HYPOTHETICAL=true", 0);
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(agg->aggsortop))
+	{
+		Oid sortop = agg->aggsortop;
+		Form_pg_operator op;
+		HeapTuple tup;
+
+		tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(sortop));
+		if (!HeapTupleIsValid(tup))
+			elog(ERROR, "cache lookup failed for operator with OID %u", sortop);
+		op = (Form_pg_operator) GETSTRUCT(tup);
+
+		tmp = new_objtree_VA("SORTOP=%{operator}O", 0);
+		append_object_object(tmp, "operator",
+							 new_objtree_for_qualname(op->oprnamespace,
+													  NameStr(op->oprname)));
+		list = lappend(list, new_object_object(NULL, tmp));
+
+		ReleaseSysCache(tup);
+	}
+
+	append_array_object(stmt, "elems", list);
+
+	ReleaseSysCache(procTup);
+	ReleaseSysCache(aggTup);
+
+	return stmt;
+}
+
+static ObjTree *
 deparse_DefineStmt_Collation(Oid objectId, DefineStmt *define)
 {
 	HeapTuple   colTup;
@@ -1210,6 +1446,10 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 
 	switch (define->kind)
 	{
+		case OBJECT_AGGREGATE:
+			defStmt = deparse_DefineStmt_Aggregate(objectId, define);
+			break;
+
 		case OBJECT_COLLATION:
 			defStmt = deparse_DefineStmt_Collation(objectId, define);
 			break;
@@ -1239,7 +1479,6 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 			break;
 
 		default:
-		case OBJECT_AGGREGATE:
 			elog(ERROR, "unsupported object kind");
 			return NULL;
 	}
-- 
1.9.1

>From f3a4b84c0989dceb25a97cbe0b8c6180ac5e4e7a Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Tue, 6 May 2014 17:22:13 -0400
Subject: [PATCH 34/36] deparse: support ALTER THING OWNER TO

---
 src/backend/tcop/deparse_utility.c | 31 +++++++++++++++++++++++++++++++
 src/backend/tcop/utility.c         |  5 ++++-
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index ec457ca..b7bb4da 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -3706,6 +3706,33 @@ deparse_AlterEnumStmt(Oid objectId, Node *parsetree)
 }
 
 static char *
+deparse_AlterOwnerStmt(Oid objectId, Node *parsetree)
+{
+	AlterOwnerStmt *node = (AlterOwnerStmt *) parsetree;
+	ObjTree	   *ownerStmt;
+	ObjectAddress addr;
+	char	   *fmt;
+	char	   *command;
+
+	fmt = psprintf("ALTER %s %%{identity}s OWNER TO %%{newname}I",
+				   stringify_objtype(node->objectType));
+	ownerStmt = new_objtree_VA(fmt, 0);
+	append_string_object(ownerStmt, "newname", node->newowner);
+
+	addr.classId = get_objtype_catalog_oid(node->objectType);
+	addr.objectId = objectId;
+	addr.objectSubId = 0;
+
+	append_string_object(ownerStmt, "identity",
+						 getObjectIdentity(&addr));
+
+	command = jsonize_objtree(ownerStmt);
+	free_objtree(ownerStmt);
+
+	return command;
+}
+
+static char *
 deparse_CreateConversion(Oid objectId, Node *parsetree)
 {
 	HeapTuple   conTup;
@@ -4297,6 +4324,10 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			command = deparse_AlterEnumStmt(objectId, parsetree);
 			break;
 
+		case T_AlterOwnerStmt:
+			command = deparse_AlterOwnerStmt(objectId, parsetree);
+			break;
+
 		default:
 			command = NULL;
 			elog(LOG, "unrecognized node type: %d",
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 03547a6..c9c5499 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -1404,7 +1404,10 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_AlterOwnerStmt:
-				ExecAlterOwnerStmt((AlterOwnerStmt *) parsetree);
+				objectId = ExecAlterOwnerStmt((AlterOwnerStmt *) parsetree);
+				EventTriggerStashCommand(objectId,
+										 ((AlterOwnerStmt *) parsetree)->objectType,
+										 parsetree);
 				break;
 
 			case T_GrantStmt:
-- 
1.9.1

>From 7bf25a8b78720c14035add9402138b3693c63936 Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Thu, 8 May 2014 15:35:58 +0530
Subject: [PATCH 35/36] deparse: Support ALTER EXTENSION / UPDATE TO

---
 src/backend/tcop/deparse_utility.c | 50 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index b7bb4da..44c1071 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -1568,6 +1568,52 @@ deparse_CreateExtensionStmt(Oid objectId, Node *parsetree)
 	return command;
 }
 
+static char *
+deparse_AlterExtensionStmt(Oid objectId, Node *parsetree)
+{
+	AlterExtensionStmt *node = (AlterExtensionStmt *) parsetree;
+	Relation    pg_extension;
+	HeapTuple   extTup;
+	Form_pg_extension extForm;
+	ObjTree	   *stmt;
+	char	   *command;
+	char	   *version = NULL;
+	ListCell   *cell;
+
+	pg_extension = heap_open(ExtensionRelationId, AccessShareLock);
+	extTup = get_catalog_object_by_oid(pg_extension, objectId);
+	if (!HeapTupleIsValid(extTup))
+		elog(ERROR, "cache lookup failed for extension with OID %u",
+			 objectId);
+	extForm = (Form_pg_extension) GETSTRUCT(extTup);
+
+	stmt = new_objtree_VA("ALTER EXTENSION %{identity}I UPDATE%{to}s", 1,
+						  "identity", ObjTypeString,
+						  NameStr(extForm->extname));
+
+	foreach(cell, node->options)
+	{
+		DefElem *opt = (DefElem *) lfirst(cell);
+
+		if (strcmp(opt->defname, "new_version") == 0)
+			version = defGetString(opt);
+		else
+			elog(ERROR, "unsupported option %s", opt->defname);
+	}
+
+	if (version)
+		append_string_object(stmt, "to", psprintf(" TO '%s'", version));
+	else
+		append_string_object(stmt, "to", "");
+
+	heap_close(pg_extension, AccessShareLock);
+
+	command = jsonize_objtree(stmt);
+	free_objtree(stmt);
+
+	return command;
+}
+
 /*
  * deparse_ViewStmt
  *		deparse a ViewStmt
@@ -4272,6 +4318,10 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			command = deparse_CreateExtensionStmt(objectId, parsetree);
 			break;
 
+		case T_AlterExtensionStmt:
+			command = deparse_AlterExtensionStmt(objectId, parsetree);
+			break;
+
 		case T_CompositeTypeStmt:		/* CREATE TYPE (composite) */
 			command = deparse_CompositeTypeStmt(objectId, parsetree);
 			break;
-- 
1.9.1

>From 9e5c6e5ad9e5721b7f3dbafdeaff8328a49a5321 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Thu, 12 Jun 2014 18:34:53 -0400
Subject: [PATCH 36/36] deparse: support GRANT/REVOKE

---
 src/backend/catalog/aclchk.c         |  36 ++----
 src/backend/commands/event_trigger.c |  65 ++++++++++
 src/backend/tcop/deparse_utility.c   | 224 +++++++++++++++++++++++++++++++++++
 src/include/commands/event_trigger.h |   2 +
 src/include/tcop/deparse_utility.h   |  10 +-
 src/include/utils/aclchk.h           |  45 +++++++
 6 files changed, 355 insertions(+), 27 deletions(-)
 create mode 100644 src/include/utils/aclchk.h

diff --git a/src/backend/catalog/aclchk.c b/src/backend/catalog/aclchk.c
index d9745ca..b2e2312 100644
--- a/src/backend/catalog/aclchk.c
+++ b/src/backend/catalog/aclchk.c
@@ -48,6 +48,7 @@
 #include "catalog/pg_ts_config.h"
 #include "catalog/pg_ts_dict.h"
 #include "commands/dbcommands.h"
+#include "commands/event_trigger.h"
 #include "commands/proclang.h"
 #include "commands/tablespace.h"
 #include "foreign/foreign.h"
@@ -56,6 +57,7 @@
 #include "parser/parse_func.h"
 #include "parser/parse_type.h"
 #include "utils/acl.h"
+#include "utils/aclchk.h"
 #include "utils/builtins.h"
 #include "utils/fmgroids.h"
 #include "utils/lsyscache.h"
@@ -65,32 +67,6 @@
 
 
 /*
- * The information about one Grant/Revoke statement, in internal format: object
- * and grantees names have been turned into Oids, the privilege list is an
- * AclMode bitmask.  If 'privileges' is ACL_NO_RIGHTS (the 0 value) and
- * all_privs is true, 'privileges' will be internally set to the right kind of
- * ACL_ALL_RIGHTS_*, depending on the object type (NB - this will modify the
- * InternalGrant struct!)
- *
- * Note: 'all_privs' and 'privileges' represent object-level privileges only.
- * There might also be column-level privilege specifications, which are
- * represented in col_privs (this is a list of untransformed AccessPriv nodes).
- * Column privileges are only valid for objtype ACL_OBJECT_RELATION.
- */
-typedef struct
-{
-	bool		is_grant;
-	GrantObjectType objtype;
-	List	   *objects;
-	bool		all_privs;
-	AclMode		privileges;
-	List	   *col_privs;
-	List	   *grantees;
-	bool		grant_option;
-	DropBehavior behavior;
-} InternalGrant;
-
-/*
  * Internal format used by ALTER DEFAULT PRIVILEGES.
  */
 typedef struct
@@ -602,6 +578,14 @@ ExecGrantStmt_oids(InternalGrant *istmt)
 			elog(ERROR, "unrecognized GrantStmt.objtype: %d",
 				 (int) istmt->objtype);
 	}
+
+	/*
+	 * Pass the info to event triggers about the just-executed GRANT.  Note
+	 * that we prefer to do it after actually executing it, because that gives
+	 * the functions a chance to adjust the istmt with privileges actually
+	 * granted.
+	 */
+	EventTriggerStashGrant(istmt);
 }
 
 /*
diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index 74fe67c..5cca1cd 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -1449,6 +1449,48 @@ EventTriggerComplexCmdEnd(void)
 	currentEventTriggerState->curcmd = NULL;
 }
 
+/*
+ * EventTriggerStashGrant
+ * 		Save data about a GRANT/REVOKE command being executed
+ *
+ * This function creates a copy of the InternalGrant, as the original might
+ * not have the right lifetime.
+ */
+void
+EventTriggerStashGrant(InternalGrant *istmt)
+{
+	MemoryContext oldcxt;
+	StashedCommand *stashed;
+	InternalGrant  *icopy;
+	ListCell	   *cell;
+
+	oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
+
+	/*
+	 * copying the node is moderately challenging ... XXX should we consider
+	 * changing InternalGrant into a full-fledged node instead?
+	 */
+	icopy = palloc(sizeof(InternalGrant));
+	memcpy(icopy, istmt, sizeof(InternalGrant));
+	icopy->objects = list_copy(istmt->objects);
+	icopy->grantees = list_copy(istmt->grantees);
+	icopy->col_privs = NIL;
+	foreach(cell, istmt->col_privs)
+		icopy->col_privs = lappend(icopy->col_privs, copyObject(lfirst(cell)));
+
+	stashed = palloc(sizeof(StashedCommand));
+	stashed->type = SCT_Grant;
+	stashed->in_extension = currentEventTriggerState->in_extension;
+
+	stashed->d.grant.istmt = icopy;
+	stashed->parsetree = NULL;
+
+	currentEventTriggerState->stash = lappend(currentEventTriggerState->stash,
+											  stashed);
+
+	MemoryContextSwitchTo(oldcxt);
+}
+
 Datum
 pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS)
 {
@@ -1613,6 +1655,29 @@ pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS)
 				/* command */
 				values[i++] = CStringGetTextDatum(command);
 			}
+			else
+			{
+				Assert(cmd->type == SCT_Grant);
+
+				/* classid */
+				nulls[i++] = true;
+				/* objid */
+				nulls[i++] = true;
+				/* objsubid */
+				nulls[i++] = true;
+				/* command tag */
+				values[i++] = CStringGetTextDatum("GRANT");	/* XXX maybe REVOKE or something else */
+				/* object_type */
+				values[i++] = CStringGetTextDatum("TABLE"); /* XXX maybe something else */
+				/* schema */
+				nulls[i++] = true;
+				/* identity */
+				nulls[i++] = true;
+				/* in_extension */
+				values[i++] = BoolGetDatum(cmd->in_extension);
+				/* command */
+				values[i++] = CStringGetTextDatum(command);
+			}
 
 			tuplestore_putvalues(tupstore, tupdesc, values, nulls);
 		}
diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 44c1071..e47a2fe 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -32,14 +32,19 @@
 #include "catalog/index.h"
 #include "catalog/namespace.h"
 #include "catalog/pg_aggregate.h"
+#include "catalog/pg_authid.h"
 #include "catalog/pg_class.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_constraint.h"
 #include "catalog/pg_conversion.h"
 #include "catalog/pg_depend.h"
 #include "catalog/pg_extension.h"
+#include "catalog/pg_foreign_data_wrapper.h"
+#include "catalog/pg_foreign_server.h"
 #include "catalog/pg_inherits.h"
 #include "catalog/pg_language.h"
+#include "catalog/pg_largeobject.h"
+#include "catalog/pg_namespace.h"
 #include "catalog/pg_operator.h"
 #include "catalog/pg_opclass.h"
 #include "catalog/pg_opfamily.h"
@@ -3855,6 +3860,218 @@ deparse_CreateOpFamily(Oid objectId, Node *parsetree)
 }
 
 static char *
+deparse_GrantStmt(StashedCommand *cmd)
+{
+	InternalGrant *istmt;
+	ObjTree	   *grantStmt;
+	char	   *command;
+	char	   *fmt;
+	char	   *objtype;
+	List	   *list;
+	ListCell   *cell;
+	Oid			classId;
+	ObjTree	   *tmp;
+
+	istmt = cmd->d.grant.istmt;
+
+	switch (istmt->objtype)
+	{
+		case ACL_OBJECT_COLUMN:
+		case ACL_OBJECT_RELATION:
+			objtype = "TABLE";
+			classId = RelationRelationId;
+			break;
+		case ACL_OBJECT_SEQUENCE:
+			objtype = "SEQUENCE";
+			classId = RelationRelationId;
+			break;
+		case ACL_OBJECT_DOMAIN:
+			objtype = "DOMAIN";
+			classId = TypeRelationId;
+			break;
+		case ACL_OBJECT_FDW:
+			objtype = "FOREIGN DATA WRAPPER";
+			classId = ForeignDataWrapperRelationId;
+			break;
+		case ACL_OBJECT_FOREIGN_SERVER:
+			objtype = "SERVER";
+			classId = ForeignServerRelationId;
+			break;
+		case ACL_OBJECT_FUNCTION:
+			objtype = "FUNCTION";
+			classId = ProcedureRelationId;
+			break;
+		case ACL_OBJECT_LANGUAGE:
+			objtype = "LANGUAGE";
+			classId = LanguageRelationId;
+			break;
+		case ACL_OBJECT_LARGEOBJECT:
+			objtype = "LARGE OBJECT";
+			classId = LargeObjectRelationId;
+			break;
+		case ACL_OBJECT_NAMESPACE:
+			objtype = "SCHEMA";
+			classId = NamespaceRelationId;
+			break;
+		case ACL_OBJECT_TYPE:
+			objtype = "TYPE";
+			classId = TypeRelationId;
+			break;
+		case ACL_OBJECT_DATABASE:
+		case ACL_OBJECT_TABLESPACE:
+			objtype = "";
+			classId = InvalidOid;
+			elog(ERROR, "global objects not supported");
+		default:
+			elog(ERROR, "invalid ACL_OBJECT value %d", istmt->objtype);
+	}
+
+	/* GRANT TO or REVOKE FROM */
+	if (istmt->is_grant)
+		fmt = psprintf("GRANT %%{privileges:, }s ON %s %%{privtarget:, }s "
+					   "TO %%{grantees:, }s %%{grant_option}s",
+					   objtype);
+	else
+		fmt = psprintf("REVOKE %%{grant_option}s %%{privileges:, }s ON %s %%{privtarget:, }s "
+					   "FROM %%{grantees:, }s %%{cascade}s",
+					   objtype);
+
+	grantStmt = new_objtree_VA(fmt, 0);
+
+	/* build list of privileges to grant/revoke */
+	if (istmt->all_privs)
+	{
+		tmp = new_objtree_VA("ALL PRIVILEGES", 0);
+		list = list_make1(new_object_object(NULL, tmp));
+	}
+	else
+	{
+		list = NIL;
+
+		if (istmt->privileges & ACL_INSERT)
+			list = lappend(list, new_string_object(NULL, "INSERT"));
+		if (istmt->privileges & ACL_SELECT)
+			list = lappend(list, new_string_object(NULL, "SELECT"));
+		if (istmt->privileges & ACL_UPDATE)
+			list = lappend(list, new_string_object(NULL, "UPDATE"));
+		if (istmt->privileges & ACL_DELETE)
+			list = lappend(list, new_string_object(NULL, "DELETE"));
+		if (istmt->privileges & ACL_TRUNCATE)
+			list = lappend(list, new_string_object(NULL, "TRUNCATE"));
+		if (istmt->privileges & ACL_REFERENCES)
+			list = lappend(list, new_string_object(NULL, "REFERENCES"));
+		if (istmt->privileges & ACL_TRIGGER)
+			list = lappend(list, new_string_object(NULL, "TRIGGER"));
+		if (istmt->privileges & ACL_EXECUTE)
+			list = lappend(list, new_string_object(NULL, "EXECUTE"));
+		if (istmt->privileges & ACL_USAGE)
+			list = lappend(list, new_string_object(NULL, "USAGE"));
+		if (istmt->privileges & ACL_CREATE)
+			list = lappend(list, new_string_object(NULL, "CREATE"));
+		if (istmt->privileges & ACL_CREATE_TEMP)
+			list = lappend(list, new_string_object(NULL, "TEMPORARY"));
+		if (istmt->privileges & ACL_CONNECT)
+			list = lappend(list, new_string_object(NULL, "CONNECT"));
+
+		if (istmt->col_privs != NIL)
+		{
+			ListCell   *ocell;
+
+			foreach(ocell, istmt->col_privs)
+			{
+				AccessPriv *priv = lfirst(ocell);
+				List   *cols = NIL;
+
+				tmp = new_objtree_VA("%{priv}s (%{cols:, }I)", 0);
+				foreach(cell, priv->cols)
+				{
+					Value *colname = lfirst(cell);
+
+					cols = lappend(cols,
+								   new_string_object(NULL,
+													 strVal(colname)));
+				}
+				append_array_object(tmp, "cols", cols);
+				if (priv->priv_name == NULL)
+					append_string_object(tmp, "priv", "ALL PRIVILEGES");
+				else
+					append_string_object(tmp, "priv", priv->priv_name);
+
+				list = lappend(list, new_object_object(NULL, tmp));
+			}
+		}
+	}
+	append_array_object(grantStmt, "privileges", list);
+
+	/* target objects.  We use object identities here */
+	list = NIL;
+	foreach(cell, istmt->objects)
+	{
+		Oid		objid = lfirst_oid(cell);
+		ObjectAddress addr;
+
+		addr.classId = classId;
+		addr.objectId = objid;
+		addr.objectSubId = 0;
+
+		tmp = new_objtree_VA("%{identity}s", 0);
+		append_string_object(tmp, "identity",
+							 getObjectIdentity(&addr));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+	append_array_object(grantStmt, "privtarget", list);
+
+	/* list of grantees */
+	list = NIL;
+	foreach(cell, istmt->grantees)
+	{
+		Oid		grantee = lfirst_oid(cell);
+
+		if (grantee == ACL_ID_PUBLIC)
+			tmp = new_objtree_VA("PUBLIC", 0);
+		else
+		{
+			HeapTuple	roltup;
+			char	   *rolname;
+
+			roltup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(grantee));
+			if (!HeapTupleIsValid(roltup))
+				ereport(ERROR,
+						(errcode(ERRCODE_UNDEFINED_OBJECT),
+						 errmsg("role with OID %u does not exist", grantee)));
+
+			tmp = new_objtree_VA("%{name}I", 0);
+			rolname = NameStr(((Form_pg_authid) GETSTRUCT(roltup))->rolname);
+			append_string_object(tmp, "name", pstrdup(rolname));
+			ReleaseSysCache(roltup);
+		}
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+	append_array_object(grantStmt, "grantees", list);
+
+	/* the wording of the grant option is variable ... */
+	if (istmt->is_grant)
+		append_string_object(grantStmt, "grant_option",
+							 istmt->grant_option ?  "WITH GRANT OPTION" : "");
+	else
+		append_string_object(grantStmt, "grant_option",
+							 istmt->grant_option ?  "GRANT OPTION FOR" : "");
+
+	if (!istmt->is_grant)
+	{
+		if (istmt->behavior == DROP_CASCADE)
+			append_string_object(grantStmt, "cascade", "CASCADE");
+		else
+			append_string_object(grantStmt, "cascade", "");
+	}
+
+	command = jsonize_objtree(grantStmt);
+	free_objtree(grantStmt);
+
+	return command;
+}
+
+static char *
 deparse_AlterTableStmt(StashedCommand *cmd)
 {
 	ObjTree	   *alterTableStmt;
@@ -4378,6 +4595,10 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			command = deparse_AlterOwnerStmt(objectId, parsetree);
 			break;
 
+		case T_GrantStmt:
+			elog(ERROR, "unexpected node type T_GrantStmt");
+			break;
+
 		default:
 			command = NULL;
 			elog(LOG, "unrecognized node type: %d",
@@ -4433,6 +4654,9 @@ deparse_utility_command(StashedCommand *cmd)
 		case SCT_AlterTable:
 			command = deparse_parsenode_cmd(cmd);
 			break;
+		case SCT_Grant:
+			command = deparse_GrantStmt(cmd);
+			break;
 		default:
 			elog(ERROR, "unexpected deparse node type %d", cmd->type);
 	}
diff --git a/src/include/commands/event_trigger.h b/src/include/commands/event_trigger.h
index 3e84cf7..8141244 100644
--- a/src/include/commands/event_trigger.h
+++ b/src/include/commands/event_trigger.h
@@ -17,6 +17,7 @@
 #include "catalog/objectaddress.h"
 #include "catalog/pg_event_trigger.h"
 #include "nodes/parsenodes.h"
+#include "utils/aclchk.h"
 
 typedef struct EventTriggerData
 {
@@ -56,6 +57,7 @@ extern void EventTriggerStashExtensionStart(void);
 extern void EventTriggerStashExtensionStop(void);
 extern void EventTriggerStashCommand(Oid objectId, ObjectType objtype,
 						 Node *parsetree);
+extern void EventTriggerStashGrant(InternalGrant *istmt);
 extern void EventTriggerComplexCmdStart(Node *parsetree, ObjectType objtype);
 extern void EventTriggerComplexCmdSetOid(Oid objectId);
 extern void EventTriggerRecordSubcmd(Node *subcmd, Oid relid,
diff --git a/src/include/tcop/deparse_utility.h b/src/include/tcop/deparse_utility.h
index 37b38f0..61ad728 100644
--- a/src/include/tcop/deparse_utility.h
+++ b/src/include/tcop/deparse_utility.h
@@ -14,6 +14,8 @@
 
 #include "access/attnum.h"
 #include "nodes/nodes.h"
+#include "utils/aclchk.h"
+
 
 /*
  * Support for keeping track of a command to deparse.
@@ -26,7 +28,8 @@
 typedef enum StashedCommandType
 {
 	SCT_Basic,
-	SCT_AlterTable
+	SCT_AlterTable,
+	SCT_Grant
 } StashedCommandType;
 
 /*
@@ -60,6 +63,11 @@ typedef struct StashedCommand
 			ObjectType objtype;
 			List   *subcmds;
 		} alterTable;
+
+		struct GrantCommand
+		{
+			InternalGrant *istmt;
+		} grant;
 	} d;
 } StashedCommand;
 
diff --git a/src/include/utils/aclchk.h b/src/include/utils/aclchk.h
new file mode 100644
index 0000000..1ca7095
--- /dev/null
+++ b/src/include/utils/aclchk.h
@@ -0,0 +1,45 @@
+/*-------------------------------------------------------------------------
+ *
+ * aclchk.h
+ *
+ * Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/utils/aclchk.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef ACLCHK_H
+#define ACLCHK_H
+
+#include "nodes/parsenodes.h"
+#include "nodes/pg_list.h"
+
+/*
+ * The information about one Grant/Revoke statement, in internal format: object
+ * and grantees names have been turned into Oids, the privilege list is an
+ * AclMode bitmask.  If 'privileges' is ACL_NO_RIGHTS (the 0 value) and
+ * all_privs is true, 'privileges' will be internally set to the right kind of
+ * ACL_ALL_RIGHTS_*, depending on the object type (NB - this will modify the
+ * InternalGrant struct!)
+ *
+ * Note: 'all_privs' and 'privileges' represent object-level privileges only.
+ * There might also be column-level privilege specifications, which are
+ * represented in col_privs (this is a list of untransformed AccessPriv nodes).
+ * Column privileges are only valid for objtype ACL_OBJECT_RELATION.
+ */
+typedef struct
+{
+	bool		is_grant;
+	GrantObjectType objtype;
+	List	   *objects;
+	bool		all_privs;
+	AclMode		privileges;
+	List	   *col_privs;
+	List	   *grantees;
+	bool		grant_option;
+	DropBehavior behavior;
+} InternalGrant;
+
+
+#endif	/* ACLCHK_H */
-- 
1.9.1

>From 1f6ced7d954ea533f2b0df4daea3f29b5743fd97 Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Mon, 5 May 2014 16:20:40 +0530
Subject: [PATCH 31/36] deparse: Support CREATE TYPE via DefineStmt

---
 src/backend/tcop/deparse_utility.c | 210 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 209 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 9a325ac..8c2fa9e 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -915,6 +915,211 @@ deparse_DefineStmt_TSTemplate(Oid objectId, DefineStmt *define)
 	return stmt;
 }
 
+static ObjTree *
+deparse_DefineStmt_Type(Oid objectId, DefineStmt *define)
+{
+	HeapTuple   typTup;
+	ObjTree	   *stmt;
+	ObjTree	   *tmp;
+	List	   *list;
+	char	   *str;
+	Datum		dflt;
+	bool		isnull;
+	Form_pg_type typForm;
+
+	typTup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(typTup))
+		elog(ERROR, "cache lookup failed for type with OID %u", objectId);
+	typForm = (Form_pg_type) GETSTRUCT(typTup);
+
+	/* Shortcut processing for shell types. */
+	if (!typForm->typisdefined)
+	{
+		stmt = new_objtree_VA("CREATE TYPE %{identity}D", 0);
+		append_object_object(stmt, "identity",
+							 new_objtree_for_qualname(typForm->typnamespace,
+													  NameStr(typForm->typname)));
+		ReleaseSysCache(typTup);
+		return stmt;
+	}
+
+	stmt = new_objtree_VA("CREATE TYPE %{identity}D (%{elems:, }s)", 0);
+
+	append_object_object(stmt, "identity",
+						 new_objtree_for_qualname(typForm->typnamespace,
+												  NameStr(typForm->typname)));
+
+	list = NIL;
+
+	/* INPUT */
+	tmp = new_objtree_VA("INPUT=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 typForm->typinput));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	/* OUTPUT */
+	tmp = new_objtree_VA("OUTPUT=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 typForm->typoutput));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	/* RECEIVE */
+	if (OidIsValid(typForm->typreceive))
+	{
+		tmp = new_objtree_VA("RECEIVE=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 typForm->typreceive));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	/* SEND */
+	if (OidIsValid(typForm->typsend))
+	{
+		tmp = new_objtree_VA("SEND=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 typForm->typsend));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	/* TYPMOD_IN */
+	if (OidIsValid(typForm->typmodin))
+	{
+		tmp = new_objtree_VA("TYPMOD_IN=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 typForm->typmodin));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	/* TYPMOD_OUT */
+	if (OidIsValid(typForm->typmodout))
+	{
+		tmp = new_objtree_VA("TYPMOD_OUT=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 typForm->typmodout));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	/* ANALYZE */
+	if (OidIsValid(typForm->typanalyze))
+	{
+		tmp = new_objtree_VA("ANALYZE=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 typForm->typanalyze));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	/* INTERNALLENGTH */
+	tmp = new_objtree_VA("INTERNALLENGTH=%{typlen}s", 0);
+	if (typForm->typlen == -1)
+		append_string_object(tmp, "typlen", "VARIABLE");
+	else
+		append_string_object(tmp, "typlen",
+							 psprintf("%d", typForm->typlen));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	/* PASSEDBYVALUE */
+	if (typForm->typbyval)
+		list = lappend(list, new_object_object(NULL, new_objtree_VA("PASSEDBYVALUE", 0)));
+
+	/* ALIGNMENT */
+	tmp = new_objtree_VA("ALIGNMENT=%{align}s", 0);
+	switch (typForm->typalign)
+	{
+		case 'd':
+			str = "pg_catalog.float8";
+			break;
+		case 'i':
+			str = "pg_catalog.int4";
+			break;
+		case 's':
+			str = "pg_catalog.int2";
+			break;
+		case 'c':
+			str = "pg_catalog.bpchar";
+			break;
+		default:
+			elog(ERROR, "invalid alignment %c", typForm->typalign);
+	}
+	append_string_object(tmp, "align", str);
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	tmp = new_objtree_VA("STORAGE=%{storage}s", 0);
+	switch (typForm->typstorage)
+	{
+		case 'p':
+			str = "plain";
+			break;
+		case 'e':
+			str = "external";
+			break;
+		case 'x':
+			str = "extended";
+			break;
+		case 'm':
+			str = "main";
+			break;
+		default:
+			elog(ERROR, "invalid storage specifier %c", typForm->typstorage);
+	}
+	append_string_object(tmp, "storage", str);
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	/* CATEGORY */
+	tmp = new_objtree_VA("CATEGORY=%{category}L", 0);
+	append_string_object(tmp, "category",
+						 psprintf("%c", typForm->typcategory));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	/* PREFERRED */
+	if (typForm->typispreferred)
+		list = lappend(list, new_object_object(NULL, new_objtree_VA("PREFERRED=true", 0)));
+
+	/* DEFAULT */
+	dflt = SysCacheGetAttr(TYPEOID, typTup,
+						   Anum_pg_type_typdefault,
+						   &isnull);
+	if (!isnull)
+	{
+		tmp = new_objtree_VA("DEFAULT=%{default}L", 0);
+		append_string_object(tmp, "default", TextDatumGetCString(dflt));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	/* ELEMENT */
+	if (OidIsValid(typForm->typelem))
+	{
+		tmp = new_objtree_VA("ELEMENT=%{elem}T", 0);
+		append_object_object(tmp, "elem",
+							 new_objtree_for_type(typForm->typelem, -1));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	/* DELIMITER */
+	tmp = new_objtree_VA("DELIMITER=%{delim}L", 0);
+	append_string_object(tmp, "delim",
+						 psprintf("%c", typForm->typdelim));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	/* COLLATABLE */
+	if (OidIsValid(typForm->typcollation))
+		list = lappend(list,
+					   new_object_object(NULL,
+										 new_objtree_VA("COLLATABLE=true", 0)));
+
+	append_array_object(stmt, "elems", list);
+
+	ReleaseSysCache(typTup);
+
+	return stmt;
+}
+
 static char *
 deparse_DefineStmt(Oid objectId, Node *parsetree)
 {
@@ -944,9 +1149,12 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 			defStmt = deparse_DefineStmt_TSTemplate(objectId, define);
 			break;
 
+		case OBJECT_TYPE:
+			defStmt = deparse_DefineStmt_Type(objectId, define);
+			break;
+
 		default:
 		case OBJECT_AGGREGATE:
-		case OBJECT_TYPE:
 		case OBJECT_TSCONFIGURATION:
 			elog(ERROR, "unsupported object kind");
 			return NULL;
-- 
1.9.1

>From 069e3d2d4fe62751eb021eb9aaa0afbb029c16a1 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 7 Feb 2014 16:42:37 -0300
Subject: [PATCH 01/36] gram.y: more psprintf()

---
 src/backend/parser/gram.y | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 7b9895d..df9ee31 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -4469,9 +4469,7 @@ TriggerFuncArgs:
 TriggerFuncArg:
 			Iconst
 				{
-					char buf[64];
-					snprintf(buf, sizeof(buf), "%d", $1);
-					$$ = makeString(pstrdup(buf));
+					$$ = makeString(psprintf("%d", $1));
 				}
 			| FCONST								{ $$ = makeString($1); }
 			| Sconst								{ $$ = makeString($1); }
-- 
1.9.1

>From 7838472617ddb1a093d86a5d31c917b748f7eac3 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 25 Apr 2014 14:33:11 -0300
Subject: [PATCH 02/36] core: use PG_FUNCNAME_MACRO to avoid stale name

---
 src/backend/commands/event_trigger.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index 6d4e091..1285fd0 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -1217,7 +1217,7 @@ pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 		 errmsg("%s can only be called in a sql_drop event trigger function",
-				"pg_event_trigger_dropped_objects()")));
+				PG_FUNCNAME_MACRO)));
 
 	/* check to see if caller supports us returning a tuplestore */
 	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
-- 
1.9.1

>From 3c99d9a65e8acf9fde01684bdc042cb6dce1a83e Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Mon, 7 Jan 2013 12:35:48 -0300
Subject: [PATCH 03/36] deparse/core: return OID in CREATE TABLE AS

---
 src/backend/commands/createas.c | 18 ++++++++++++++++--
 src/include/commands/createas.h |  2 +-
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 96806ee..5245171 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -55,6 +55,9 @@ typedef struct
 	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);
@@ -64,7 +67,7 @@ static void intorel_destroy(DestReceiver *self);
 /*
  * ExecCreateTableAs -- execute a CREATE TABLE AS command
  */
-void
+Oid
 ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 				  ParamListInfo params, char *completionTag)
 {
@@ -75,6 +78,7 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 	Oid			save_userid = InvalidOid;
 	int			save_sec_context = 0;
 	int			save_nestlevel = 0;
+	Oid			relOid;
 	List	   *rewritten;
 	PlannedStmt *plan;
 	QueryDesc  *queryDesc;
@@ -98,7 +102,9 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		Assert(!is_matview);	/* excluded by syntax */
 		ExecuteQuery(estmt, into, queryString, params, dest, completionTag);
 
-		return;
+		relOid = CreateAsRelid;
+		CreateAsRelid = InvalidOid;
+		return relOid;
 	}
 	Assert(query->commandType == CMD_SELECT);
 
@@ -190,6 +196,11 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		/* Restore userid and security context */
 		SetUserIdAndSecContext(save_userid, save_sec_context);
 	}
+
+	relOid = CreateAsRelid;
+	CreateAsRelid = InvalidOid;
+
+	return relOid;
 }
 
 /*
@@ -421,6 +432,9 @@ intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
 	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.
diff --git a/src/include/commands/createas.h b/src/include/commands/createas.h
index c17d829..477339d 100644
--- a/src/include/commands/createas.h
+++ b/src/include/commands/createas.h
@@ -19,7 +19,7 @@
 #include "tcop/dest.h"
 
 
-extern void ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
+extern Oid	ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 				  ParamListInfo params, char *completionTag);
 
 extern int	GetIntoRelEFlags(IntoClause *intoClause);
-- 
1.9.1

>From 16d9a659b9bdf29f1fead13d99085697ba83c6f3 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Thu, 7 Nov 2013 09:46:11 -0300
Subject: [PATCH 04/36] deparse/core: return OID of matview in REFRESH

For future consumption by event triggers
---
 src/backend/commands/matview.c | 4 +++-
 src/include/commands/matview.h | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c
index 5130d51..1e26fa9 100644
--- a/src/backend/commands/matview.c
+++ b/src/backend/commands/matview.c
@@ -132,7 +132,7 @@ SetMatViewPopulatedState(Relation relation, bool newstate)
  * The matview's "populated" state is changed based on whether the contents
  * reflect the result set of the materialized view's query.
  */
-void
+Oid
 ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 				   ParamListInfo params, char *completionTag)
 {
@@ -274,6 +274,8 @@ ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 	}
 	else
 		refresh_by_heap_swap(matviewOid, OIDNewHeap);
+
+	return matviewOid;
 }
 
 /*
diff --git a/src/include/commands/matview.h b/src/include/commands/matview.h
index 476b285..2c468b2 100644
--- a/src/include/commands/matview.h
+++ b/src/include/commands/matview.h
@@ -22,7 +22,7 @@
 
 extern void SetMatViewPopulatedState(Relation relation, bool newstate);
 
-extern void ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
+extern Oid ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
 				   ParamListInfo params, char *completionTag);
 
 extern DestReceiver *CreateTransientRelDestReceiver(Oid oid);
-- 
1.9.1

>From 396ed63d4b08eac863c3ae379ab288e0e6e378e3 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Tue, 11 Feb 2014 15:58:56 -0300
Subject: [PATCH 05/36] deparse/core: split builtins.h to new ruleutils.h

This contains many prototypes for functions in ruleutils.c that are not
exposed to the SQL level.
---
 src/backend/access/index/genam.c  |  1 +
 src/backend/catalog/heap.c        |  1 +
 src/backend/commands/explain.c    |  1 +
 src/backend/commands/tablecmds.c  |  1 +
 src/backend/commands/typecmds.c   |  1 +
 src/backend/utils/adt/misc.c      |  1 +
 src/backend/utils/adt/ruleutils.c |  1 +
 src/include/utils/builtins.h      | 11 -----------
 src/include/utils/ruleutils.h     | 34 ++++++++++++++++++++++++++++++++++
 9 files changed, 41 insertions(+), 11 deletions(-)
 create mode 100644 src/include/utils/ruleutils.h

diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c
index 850008b..8849c08 100644
--- a/src/backend/access/index/genam.c
+++ b/src/backend/access/index/genam.c
@@ -28,6 +28,7 @@
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
+#include "utils/ruleutils.h"
 #include "utils/snapmgr.h"
 #include "utils/tqual.h"
 
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 33eef9f..3cf616c 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -69,6 +69,7 @@
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
+#include "utils/ruleutils.h"
 #include "utils/snapmgr.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 0d9663c..6411c5a 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -28,6 +28,7 @@
 #include "utils/json.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
+#include "utils/ruleutils.h"
 #include "utils/snapmgr.h"
 #include "utils/tuplesort.h"
 #include "utils/xml.h"
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 341262b..062f3e6 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -83,6 +83,7 @@
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/relcache.h"
+#include "utils/ruleutils.h"
 #include "utils/snapmgr.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c
index f377c19..4606b9b 100644
--- a/src/backend/commands/typecmds.c
+++ b/src/backend/commands/typecmds.c
@@ -72,6 +72,7 @@
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/rel.h"
+#include "utils/ruleutils.h"
 #include "utils/snapmgr.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 4eeb631..67539ec 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -35,6 +35,7 @@
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/lsyscache.h"
+#include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index a30d8fe..9744b91 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -55,6 +55,7 @@
 #include "utils/fmgroids.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
+#include "utils/ruleutils.h"
 #include "utils/snapmgr.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index bbb5d39..26f998d 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -675,13 +675,10 @@ extern Datum pg_get_viewdef_name(PG_FUNCTION_ARGS);
 extern Datum pg_get_viewdef_name_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_indexdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_indexdef_ext(PG_FUNCTION_ARGS);
-extern char *pg_get_indexdef_string(Oid indexrelid);
-extern char *pg_get_indexdef_columns(Oid indexrelid, bool pretty);
 extern Datum pg_get_triggerdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_triggerdef_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_constraintdef(PG_FUNCTION_ARGS);
 extern Datum pg_get_constraintdef_ext(PG_FUNCTION_ARGS);
-extern char *pg_get_constraintdef_string(Oid constraintId);
 extern Datum pg_get_expr(PG_FUNCTION_ARGS);
 extern Datum pg_get_expr_ext(PG_FUNCTION_ARGS);
 extern Datum pg_get_userbyid(PG_FUNCTION_ARGS);
@@ -691,17 +688,9 @@ extern Datum pg_get_function_arguments(PG_FUNCTION_ARGS);
 extern Datum pg_get_function_identity_arguments(PG_FUNCTION_ARGS);
 extern Datum pg_get_function_result(PG_FUNCTION_ARGS);
 extern Datum pg_get_function_arg_default(PG_FUNCTION_ARGS);
-extern char *deparse_expression(Node *expr, List *dpcontext,
-				   bool forceprefix, bool showimplicit);
-extern List *deparse_context_for(const char *aliasname, Oid relid);
-extern List *deparse_context_for_planstate(Node *planstate, List *ancestors,
-							  List *rtable, List *rtable_names);
-extern List *select_rtable_names_for_explain(List *rtable,
-								Bitmapset *rels_used);
 extern const char *quote_identifier(const char *ident);
 extern char *quote_qualified_identifier(const char *qualifier,
 						   const char *ident);
-extern char *generate_collation_name(Oid collid);
 
 
 /* tid.c */
diff --git a/src/include/utils/ruleutils.h b/src/include/utils/ruleutils.h
new file mode 100644
index 0000000..520b066
--- /dev/null
+++ b/src/include/utils/ruleutils.h
@@ -0,0 +1,34 @@
+/*-------------------------------------------------------------------------
+ *
+ * ruleutils.h
+ *		Declarations for ruleutils.c
+ *
+ * Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/ruleutils.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RULEUTILS_H
+#define RULEUTILS_H
+
+#include "nodes/nodes.h"
+#include "nodes/parsenodes.h"
+#include "nodes/pg_list.h"
+
+
+extern char *pg_get_indexdef_string(Oid indexrelid);
+extern char *pg_get_indexdef_columns(Oid indexrelid, bool pretty);
+
+extern char *pg_get_constraintdef_string(Oid constraintId);
+extern char *deparse_expression(Node *expr, List *dpcontext,
+				   bool forceprefix, bool showimplicit);
+extern List *deparse_context_for(const char *aliasname, Oid relid);
+extern List *deparse_context_for_planstate(Node *planstate, List *ancestors,
+							  List *rtable, List *rtable_names);
+extern List *select_rtable_names_for_explain(List *rtable,
+								Bitmapset *rels_used);
+extern char *generate_collation_name(Oid collid);
+
+#endif	/* RULEUTILS_H */
-- 
1.9.1

>From e5ac47ac81310e4c9de15c4efe6a0c9180b75385 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Mon, 5 May 2014 17:49:54 -0400
Subject: [PATCH 06/36] deparse/core: return the base type OID, not the array's

DefineType should return the OID of the base type just created, not the
subsidiary array's.
---
 src/backend/commands/typecmds.c | 62 ++++++++++++++++++++---------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c
index 4606b9b..6c9f06d 100644
--- a/src/backend/commands/typecmds.c
+++ b/src/backend/commands/typecmds.c
@@ -597,37 +597,37 @@ DefineType(List *names, List *parameters)
 	/* alignment must be 'i' or 'd' for arrays */
 	alignment = (alignment == 'd') ? 'd' : 'i';
 
-	typoid = TypeCreate(array_oid,		/* force assignment of this type OID */
-						array_type,		/* type name */
-						typeNamespace,	/* namespace */
-						InvalidOid,		/* relation oid (n/a here) */
-						0,		/* relation kind (ditto) */
-						GetUserId(),	/* owner's ID */
-						-1,		/* internal size (always varlena) */
-						TYPTYPE_BASE,	/* type-type (base type) */
-						TYPCATEGORY_ARRAY,		/* type-category (array) */
-						false,	/* array types are never preferred */
-						delimiter,		/* array element delimiter */
-						F_ARRAY_IN,		/* input procedure */
-						F_ARRAY_OUT,	/* output procedure */
-						F_ARRAY_RECV,	/* receive procedure */
-						F_ARRAY_SEND,	/* send procedure */
-						typmodinOid,	/* typmodin procedure */
-						typmodoutOid,	/* typmodout procedure */
-						F_ARRAY_TYPANALYZE,		/* analyze procedure */
-						typoid, /* element type ID */
-						true,	/* yes this is an array type */
-						InvalidOid,		/* no further array type */
-						InvalidOid,		/* base type ID */
-						NULL,	/* never a default type value */
-						NULL,	/* binary default isn't sent either */
-						false,	/* never passed by value */
-						alignment,		/* see above */
-						'x',	/* ARRAY is always toastable */
-						-1,		/* typMod (Domains only) */
-						0,		/* Array dimensions of typbasetype */
-						false,	/* Type NOT NULL */
-						collation);		/* type's collation */
+	TypeCreate(array_oid,		/* force assignment of this type OID */
+			   array_type,		/* type name */
+			   typeNamespace,	/* namespace */
+			   InvalidOid,		/* relation oid (n/a here) */
+			   0,		/* relation kind (ditto) */
+			   GetUserId(),	/* owner's ID */
+			   -1,		/* internal size (always varlena) */
+			   TYPTYPE_BASE,	/* type-type (base type) */
+			   TYPCATEGORY_ARRAY,		/* type-category (array) */
+			   false,	/* array types are never preferred */
+			   delimiter,		/* array element delimiter */
+			   F_ARRAY_IN,		/* input procedure */
+			   F_ARRAY_OUT,	/* output procedure */
+			   F_ARRAY_RECV,	/* receive procedure */
+			   F_ARRAY_SEND,	/* send procedure */
+			   typmodinOid,	/* typmodin procedure */
+			   typmodoutOid,	/* typmodout procedure */
+			   F_ARRAY_TYPANALYZE,		/* analyze procedure */
+			   typoid, /* element type ID */
+			   true,	/* yes this is an array type */
+			   InvalidOid,		/* no further array type */
+			   InvalidOid,		/* base type ID */
+			   NULL,	/* never a default type value */
+			   NULL,	/* binary default isn't sent either */
+			   false,	/* never passed by value */
+			   alignment,		/* see above */
+			   'x',	/* ARRAY is always toastable */
+			   -1,		/* typMod (Domains only) */
+			   0,		/* Array dimensions of typbasetype */
+			   false,	/* Type NOT NULL */
+			   collation);		/* type's collation */
 
 	pfree(array_type);
 
-- 
1.9.1

>From 4b475ce7b7ef8e8e972e22a5453be3fd12494abe Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 25 Apr 2014 17:15:49 -0300
Subject: [PATCH 08/36] deparse/core: have ALTER TABLE return OIDs and col# of
 affected objs

---
 src/backend/catalog/heap.c          |  40 ++++--
 src/backend/catalog/index.c         |   7 +-
 src/backend/catalog/pg_constraint.c |   2 +
 src/backend/commands/tablecmds.c    | 270 ++++++++++++++++++++++++------------
 src/include/catalog/heap.h          |   3 +-
 src/include/catalog/index.h         |   2 +-
 6 files changed, 216 insertions(+), 108 deletions(-)

diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 3cf616c..96e3ee2 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -96,7 +96,7 @@ static Oid AddNewRelationType(const char *typeName,
 				   Oid new_row_type,
 				   Oid new_array_type);
 static void RelationRemoveInheritance(Oid relid);
-static void StoreRelCheck(Relation rel, char *ccname, Node *expr,
+static Oid StoreRelCheck(Relation rel, char *ccname, Node *expr,
 			  bool is_validated, bool is_local, int inhcount,
 			  bool is_no_inherit, bool is_internal);
 static void StoreConstraints(Relation rel, List *cooked_constraints,
@@ -1840,7 +1840,7 @@ heap_drop_with_catalog(Oid relid)
 /*
  * Store a default expression for column attnum of relation rel.
  */
-void
+Oid
 StoreAttrDefault(Relation rel, AttrNumber attnum,
 				 Node *expr, bool is_internal)
 {
@@ -1945,6 +1945,8 @@ StoreAttrDefault(Relation rel, AttrNumber attnum,
 	 */
 	InvokeObjectPostCreateHookArg(AttrDefaultRelationId,
 								  RelationGetRelid(rel), attnum, is_internal);
+
+	return attrdefOid;
 }
 
 /*
@@ -1952,8 +1954,10 @@ StoreAttrDefault(Relation rel, AttrNumber attnum,
  *
  * Caller is responsible for updating the count of constraints
  * in the pg_class entry for the relation.
+ *
+ * The OID of the new constraint is returned.
  */
-static void
+static Oid
 StoreRelCheck(Relation rel, char *ccname, Node *expr,
 			  bool is_validated, bool is_local, int inhcount,
 			  bool is_no_inherit, bool is_internal)
@@ -1963,6 +1967,7 @@ StoreRelCheck(Relation rel, char *ccname, Node *expr,
 	List	   *varList;
 	int			keycount;
 	int16	   *attNos;
+	Oid			constrOid;
 
 	/*
 	 * Flatten expression to string form for storage.
@@ -2014,7 +2019,7 @@ StoreRelCheck(Relation rel, char *ccname, Node *expr,
 	/*
 	 * Create the Check Constraint
 	 */
-	CreateConstraintEntry(ccname,		/* Constraint Name */
+	constrOid = CreateConstraintEntry(ccname,		/* Constraint Name */
 						  RelationGetNamespace(rel),	/* namespace */
 						  CONSTRAINT_CHECK,		/* Constraint Type */
 						  false,	/* Is Deferrable */
@@ -2045,11 +2050,15 @@ StoreRelCheck(Relation rel, char *ccname, Node *expr,
 
 	pfree(ccbin);
 	pfree(ccsrc);
+
+	return constrOid;
 }
 
 /*
  * Store defaults and constraints (passed as a list of CookedConstraint).
  *
+ * Each CookedConstraint struct is modified to store the new catalog tuple OID.
+ *
  * NOTE: only pre-cooked expressions will be passed this way, which is to
  * say expressions inherited from an existing relation.  Newly parsed
  * expressions can be added later, by direct calls to StoreAttrDefault
@@ -2061,7 +2070,7 @@ StoreConstraints(Relation rel, List *cooked_constraints, bool is_internal)
 	int			numchecks = 0;
 	ListCell   *lc;
 
-	if (!cooked_constraints)
+	if (list_length(cooked_constraints) == 0)
 		return;					/* nothing to do */
 
 	/*
@@ -2078,12 +2087,14 @@ StoreConstraints(Relation rel, List *cooked_constraints, bool is_internal)
 		switch (con->contype)
 		{
 			case CONSTR_DEFAULT:
-				StoreAttrDefault(rel, con->attnum, con->expr, is_internal);
+				con->conoid = StoreAttrDefault(rel, con->attnum, con->expr,
+											   is_internal);
 				break;
 			case CONSTR_CHECK:
-				StoreRelCheck(rel, con->name, con->expr, !con->skip_validation,
-							  con->is_local, con->inhcount,
-							  con->is_no_inherit, is_internal);
+				con->conoid =
+					StoreRelCheck(rel, con->name, con->expr,
+								  !con->skip_validation, con->is_local, con->inhcount,
+								  con->is_no_inherit, is_internal);
 				numchecks++;
 				break;
 			default:
@@ -2171,6 +2182,7 @@ AddRelationNewConstraints(Relation rel,
 	{
 		RawColumnDefault *colDef = (RawColumnDefault *) lfirst(cell);
 		Form_pg_attribute atp = rel->rd_att->attrs[colDef->attnum - 1];
+		Oid		defOid;
 
 		expr = cookDefault(pstate, colDef->raw_default,
 						   atp->atttypid, atp->atttypmod,
@@ -2191,10 +2203,11 @@ AddRelationNewConstraints(Relation rel,
 			(IsA(expr, Const) &&((Const *) expr)->constisnull))
 			continue;
 
-		StoreAttrDefault(rel, colDef->attnum, expr, is_internal);
+		defOid = StoreAttrDefault(rel, colDef->attnum, expr, is_internal);
 
 		cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
 		cooked->contype = CONSTR_DEFAULT;
+		cooked->conoid = defOid;
 		cooked->name = NULL;
 		cooked->attnum = colDef->attnum;
 		cooked->expr = expr;
@@ -2214,6 +2227,7 @@ AddRelationNewConstraints(Relation rel,
 	{
 		Constraint *cdef = (Constraint *) lfirst(cell);
 		char	   *ccname;
+		Oid			constrOid;
 
 		if (cdef->contype != CONSTR_CHECK)
 			continue;
@@ -2316,13 +2330,15 @@ AddRelationNewConstraints(Relation rel,
 		/*
 		 * OK, store it.
 		 */
-		StoreRelCheck(rel, ccname, expr, !cdef->skip_validation, is_local,
-					  is_local ? 0 : 1, cdef->is_no_inherit, is_internal);
+		constrOid =
+			StoreRelCheck(rel, ccname, expr, !cdef->skip_validation, is_local,
+						  is_local ? 0 : 1, cdef->is_no_inherit, is_internal);
 
 		numchecks++;
 
 		cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
 		cooked->contype = CONSTR_CHECK;
+		cooked->conoid = constrOid;
 		cooked->name = ccname;
 		cooked->attnum = 0;
 		cooked->expr = expr;
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index a5a204e..e95d772 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -1095,7 +1095,8 @@ index_create(Relation heapRelation,
 /*
  * index_constraint_create
  *
- * Set up a constraint associated with an index
+ * Set up a constraint associated with an index.  Return the new constraint's
+ * OID.
  *
  * heapRelation: table owning the index (must be suitably locked by caller)
  * indexRelationId: OID of the index
@@ -1112,7 +1113,7 @@ index_create(Relation heapRelation,
  * allow_system_table_mods: allow table to be a system catalog
  * is_internal: index is constructed due to internal process
  */
-void
+Oid
 index_constraint_create(Relation heapRelation,
 						Oid indexRelationId,
 						IndexInfo *indexInfo,
@@ -1300,6 +1301,8 @@ index_constraint_create(Relation heapRelation,
 		heap_freetuple(indexTuple);
 		heap_close(pg_index, RowExclusiveLock);
 	}
+
+	return conOid;
 }
 
 /*
diff --git a/src/backend/catalog/pg_constraint.c b/src/backend/catalog/pg_constraint.c
index 041f5ad..f04de42 100644
--- a/src/backend/catalog/pg_constraint.c
+++ b/src/backend/catalog/pg_constraint.c
@@ -40,6 +40,8 @@
  * Subsidiary records (such as triggers or indexes to implement the
  * constraint) are *not* created here.  But we do make dependency links
  * from the constraint to the things it depends on.
+ *
+ * The new constraint's OID is returned.
  */
 Oid
 CreateConstraintEntry(const char *constraintName,
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 062f3e6..c5e5c82 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -46,6 +46,7 @@
 #include "commands/cluster.h"
 #include "commands/comment.h"
 #include "commands/defrem.h"
+#include "commands/event_trigger.h"
 #include "commands/sequence.h"
 #include "commands/tablecmds.h"
 #include "commands/tablespace.h"
@@ -276,9 +277,9 @@ static void AlterIndexNamespaces(Relation classRel, Relation rel,
 static void AlterSeqNamespaces(Relation classRel, Relation rel,
 				   Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved,
 				   LOCKMODE lockmode);
-static void ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
+static Oid ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
 					  bool recurse, bool recursing, LOCKMODE lockmode);
-static void ATExecValidateConstraint(Relation rel, char *constrName,
+static Oid ATExecValidateConstraint(Relation rel, char *constrName,
 						 bool recurse, bool recursing, LOCKMODE lockmode);
 static int transformColumnNameList(Oid relId, List *colList,
 						int16 *attnums, Oid *atttypids);
@@ -318,26 +319,26 @@ static List *find_typed_table_dependencies(Oid typeOid, const char *typeName,
 							  DropBehavior behavior);
 static void ATPrepAddColumn(List **wqueue, Relation rel, bool recurse, bool recursing,
 				AlterTableCmd *cmd, LOCKMODE lockmode);
-static void ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
-				ColumnDef *colDef, bool isOid,
+static AttrNumber ATExecAddColumn(List **wqueue, AlteredTableInfo *tab,
+				Relation rel, ColumnDef *colDef, bool isOid,
 				bool recurse, bool recursing, LOCKMODE lockmode);
 static void check_for_column_name_collision(Relation rel, const char *colname);
 static void add_column_datatype_dependency(Oid relid, int32 attnum, Oid typid);
 static void add_column_collation_dependency(Oid relid, int32 attnum, Oid collid);
 static void ATPrepAddOids(List **wqueue, Relation rel, bool recurse,
 			  AlterTableCmd *cmd, LOCKMODE lockmode);
-static void ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode);
-static void ATExecSetNotNull(AlteredTableInfo *tab, Relation rel,
+static AttrNumber ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode);
+static AttrNumber ATExecSetNotNull(AlteredTableInfo *tab, Relation rel,
 				 const char *colName, LOCKMODE lockmode);
-static void ATExecColumnDefault(Relation rel, const char *colName,
+static AttrNumber ATExecColumnDefault(Relation rel, const char *colName,
 					Node *newDefault, LOCKMODE lockmode);
 static void ATPrepSetStatistics(Relation rel, const char *colName,
 					Node *newValue, LOCKMODE lockmode);
-static void ATExecSetStatistics(Relation rel, const char *colName,
+static AttrNumber ATExecSetStatistics(Relation rel, const char *colName,
 					Node *newValue, LOCKMODE lockmode);
-static void ATExecSetOptions(Relation rel, const char *colName,
+static AttrNumber ATExecSetOptions(Relation rel, const char *colName,
 				 Node *options, bool isReset, LOCKMODE lockmode);
-static void ATExecSetStorage(Relation rel, const char *colName,
+static AttrNumber ATExecSetStorage(Relation rel, const char *colName,
 				 Node *newValue, LOCKMODE lockmode);
 static void ATPrepDropColumn(List **wqueue, Relation rel, bool recurse, bool recursing,
 				 AlterTableCmd *cmd, LOCKMODE lockmode);
@@ -345,20 +346,20 @@ static void ATExecDropColumn(List **wqueue, Relation rel, const char *colName,
 				 DropBehavior behavior,
 				 bool recurse, bool recursing,
 				 bool missing_ok, LOCKMODE lockmode);
-static void ATExecAddIndex(AlteredTableInfo *tab, Relation rel,
+static Oid ATExecAddIndex(AlteredTableInfo *tab, Relation rel,
 			   IndexStmt *stmt, bool is_rebuild, LOCKMODE lockmode);
-static void ATExecAddConstraint(List **wqueue,
+static Oid ATExecAddConstraint(List **wqueue,
 					AlteredTableInfo *tab, Relation rel,
 					Constraint *newConstraint, bool recurse, bool is_readd,
 					LOCKMODE lockmode);
-static void ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel,
+static Oid ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel,
 						 IndexStmt *stmt, LOCKMODE lockmode);
-static void ATAddCheckConstraint(List **wqueue,
+static Oid ATAddCheckConstraint(List **wqueue,
 					 AlteredTableInfo *tab, Relation rel,
 					 Constraint *constr,
 					 bool recurse, bool recursing, bool is_readd,
 					 LOCKMODE lockmode);
-static void ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
+static Oid ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
 						  Constraint *fkconstraint, LOCKMODE lockmode);
 static void ATExecDropConstraint(Relation rel, const char *constrName,
 					 DropBehavior behavior,
@@ -369,9 +370,9 @@ static void ATPrepAlterColumnType(List **wqueue,
 					  bool recurse, bool recursing,
 					  AlterTableCmd *cmd, LOCKMODE lockmode);
 static bool ATColumnChangeRequiresRewrite(Node *expr, AttrNumber varattno);
-static void ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
+static AttrNumber ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
 					  AlterTableCmd *cmd, LOCKMODE lockmode);
-static void ATExecAlterColumnGenericOptions(Relation rel, const char *colName,
+static AttrNumber ATExecAlterColumnGenericOptions(Relation rel, const char *colName,
 								List *options, LOCKMODE lockmode);
 static void ATPostAlterTypeCleanup(List **wqueue, AlteredTableInfo *tab, LOCKMODE lockmode);
 static void ATPostAlterTypeParse(Oid oldId, Oid oldRelId, Oid refRelId,
@@ -383,7 +384,7 @@ static void change_owner_fix_column_acls(Oid relationOid,
 							 Oid oldOwnerId, Oid newOwnerId);
 static void change_owner_recurse_to_sequences(Oid relationOid,
 								  Oid newOwnerId, LOCKMODE lockmode);
-static void ATExecClusterOn(Relation rel, const char *indexName, LOCKMODE lockmode);
+static Oid ATExecClusterOn(Relation rel, const char *indexName, LOCKMODE lockmode);
 static void ATExecDropCluster(Relation rel, LOCKMODE lockmode);
 static void ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel,
 					char *tablespacename, LOCKMODE lockmode);
@@ -609,6 +610,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId)
 
 			cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
 			cooked->contype = CONSTR_DEFAULT;
+			cooked->conoid = InvalidOid;
 			cooked->name = NULL;
 			cooked->attnum = attnum;
 			cooked->expr = colDef->cooked_default;
@@ -1720,6 +1722,7 @@ MergeAttributes(List *schema, List *supers, char relpersistence,
 
 					cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
 					cooked->contype = CONSTR_CHECK;
+					cooked->conoid = InvalidOid;
 					cooked->name = pstrdup(name);
 					cooked->attnum = 0; /* not used for constraints */
 					cooked->expr = expr;
@@ -3330,78 +3333,91 @@ static void
 ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
 		  AlterTableCmd *cmd, LOCKMODE lockmode)
 {
+	AttrNumber colno = InvalidAttrNumber;
+	Oid			newoid = InvalidOid;
+
 	switch (cmd->subtype)
 	{
 		case AT_AddColumn:		/* ADD COLUMN */
 		case AT_AddColumnToView:		/* add column via CREATE OR REPLACE
 										 * VIEW */
-			ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
-							false, false, false, lockmode);
+			colno = ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
+									false, false, false, lockmode);
 			break;
 		case AT_AddColumnRecurse:
-			ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
-							false, true, false, lockmode);
+			colno = ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
+									false, true, false, lockmode);
 			break;
 		case AT_ColumnDefault:	/* ALTER COLUMN DEFAULT */
-			ATExecColumnDefault(rel, cmd->name, cmd->def, lockmode);
+			colno = ATExecColumnDefault(rel, cmd->name, cmd->def, lockmode);
 			break;
 		case AT_DropNotNull:	/* ALTER COLUMN DROP NOT NULL */
-			ATExecDropNotNull(rel, cmd->name, lockmode);
+			colno = ATExecDropNotNull(rel, cmd->name, lockmode);
 			break;
 		case AT_SetNotNull:		/* ALTER COLUMN SET NOT NULL */
-			ATExecSetNotNull(tab, rel, cmd->name, lockmode);
+			colno = ATExecSetNotNull(tab, rel, cmd->name, lockmode);
 			break;
 		case AT_SetStatistics:	/* ALTER COLUMN SET STATISTICS */
-			ATExecSetStatistics(rel, cmd->name, cmd->def, lockmode);
+			colno = ATExecSetStatistics(rel, cmd->name, cmd->def, lockmode);
 			break;
 		case AT_SetOptions:		/* ALTER COLUMN SET ( options ) */
-			ATExecSetOptions(rel, cmd->name, cmd->def, false, lockmode);
+			colno = ATExecSetOptions(rel, cmd->name, cmd->def, false, lockmode);
 			break;
 		case AT_ResetOptions:	/* ALTER COLUMN RESET ( options ) */
-			ATExecSetOptions(rel, cmd->name, cmd->def, true, lockmode);
+			colno = ATExecSetOptions(rel, cmd->name, cmd->def, true, lockmode);
 			break;
 		case AT_SetStorage:		/* ALTER COLUMN SET STORAGE */
-			ATExecSetStorage(rel, cmd->name, cmd->def, lockmode);
+			colno = ATExecSetStorage(rel, cmd->name, cmd->def, lockmode);
 			break;
 		case AT_DropColumn:		/* DROP COLUMN */
 			ATExecDropColumn(wqueue, rel, cmd->name,
-					 cmd->behavior, false, false, cmd->missing_ok, lockmode);
+							 cmd->behavior, false, false,
+							 cmd->missing_ok, lockmode);
 			break;
 		case AT_DropColumnRecurse:		/* DROP COLUMN with recursion */
 			ATExecDropColumn(wqueue, rel, cmd->name,
-					  cmd->behavior, true, false, cmd->missing_ok, lockmode);
+							 cmd->behavior, true, false,
+							 cmd->missing_ok, lockmode);
 			break;
 		case AT_AddIndex:		/* ADD INDEX */
-			ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, false, lockmode);
+			newoid = ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, false,
+									lockmode);
 			break;
 		case AT_ReAddIndex:		/* ADD INDEX */
-			ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, true, lockmode);
+			newoid = ATExecAddIndex(tab, rel, (IndexStmt *) cmd->def, true,
+									lockmode);
 			break;
 		case AT_AddConstraint:	/* ADD CONSTRAINT */
-			ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
-								false, false, lockmode);
+			newoid =
+				ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
+									false, false, lockmode);
 			break;
 		case AT_AddConstraintRecurse:	/* ADD CONSTRAINT with recursion */
-			ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
-								true, false, lockmode);
+			newoid =
+				ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
+									true, false, lockmode);
 			break;
 		case AT_ReAddConstraint:		/* Re-add pre-existing check
 										 * constraint */
-			ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
-								false, true, lockmode);
+			newoid =
+				ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
+									false, true, lockmode);
 			break;
 		case AT_AddIndexConstraint:		/* ADD CONSTRAINT USING INDEX */
-			ATExecAddIndexConstraint(tab, rel, (IndexStmt *) cmd->def, lockmode);
+			newoid = ATExecAddIndexConstraint(tab, rel, (IndexStmt *) cmd->def,
+											  lockmode);
 			break;
 		case AT_AlterConstraint:		/* ALTER CONSTRAINT */
-			ATExecAlterConstraint(rel, cmd, false, false, lockmode);
+			newoid = ATExecAlterConstraint(rel, cmd, false, false, lockmode);
 			break;
 		case AT_ValidateConstraint:		/* VALIDATE CONSTRAINT */
-			ATExecValidateConstraint(rel, cmd->name, false, false, lockmode);
+			newoid = ATExecValidateConstraint(rel, cmd->name, false, false,
+											  lockmode);
 			break;
 		case AT_ValidateConstraintRecurse:		/* VALIDATE CONSTRAINT with
 												 * recursion */
-			ATExecValidateConstraint(rel, cmd->name, true, false, lockmode);
+			newoid = ATExecValidateConstraint(rel, cmd->name, true, false,
+											  lockmode);
 			break;
 		case AT_DropConstraint:	/* DROP CONSTRAINT */
 			ATExecDropConstraint(rel, cmd->name, cmd->behavior,
@@ -3414,10 +3430,12 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
 								 cmd->missing_ok, lockmode);
 			break;
 		case AT_AlterColumnType:		/* ALTER COLUMN TYPE */
-			ATExecAlterColumnType(tab, rel, cmd, lockmode);
+			colno = ATExecAlterColumnType(tab, rel, cmd, lockmode);
 			break;
 		case AT_AlterColumnGenericOptions:		/* ALTER COLUMN OPTIONS */
-			ATExecAlterColumnGenericOptions(rel, cmd->name, (List *) cmd->def, lockmode);
+			colno =
+				ATExecAlterColumnGenericOptions(rel, cmd->name,
+												(List *) cmd->def, lockmode);
 			break;
 		case AT_ChangeOwner:	/* ALTER OWNER */
 			ATExecChangeOwner(RelationGetRelid(rel),
@@ -3425,7 +3443,7 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
 							  false, lockmode);
 			break;
 		case AT_ClusterOn:		/* CLUSTER ON */
-			ATExecClusterOn(rel, cmd->name, lockmode);
+			newoid = ATExecClusterOn(rel, cmd->name, lockmode);
 			break;
 		case AT_DropCluster:	/* SET WITHOUT CLUSTER */
 			ATExecDropCluster(rel, lockmode);
@@ -3523,7 +3541,8 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
 			ATExecDropOf(rel, lockmode);
 			break;
 		case AT_ReplicaIdentity:
-			ATExecReplicaIdentity(rel, (ReplicaIdentityStmt *) cmd->def, lockmode);
+			ATExecReplicaIdentity(rel, (ReplicaIdentityStmt *) cmd->def,
+								  lockmode);
 			break;
 		case AT_GenericOptions:
 			ATExecGenericOptions(rel, (List *) cmd->def);
@@ -4470,7 +4489,7 @@ ATPrepAddColumn(List **wqueue, Relation rel, bool recurse, bool recursing,
 		cmd->subtype = AT_AddColumnRecurse;
 }
 
-static void
+static AttrNumber
 ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 				ColumnDef *colDef, bool isOid,
 				bool recurse, bool recursing, LOCKMODE lockmode)
@@ -4555,7 +4574,7 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 					  colDef->colname, RelationGetRelationName(rel))));
 
 			heap_close(attrdesc, RowExclusiveLock);
-			return;
+			return InvalidAttrNumber;
 		}
 	}
 
@@ -4801,6 +4820,8 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
 
 		heap_close(childrel, NoLock);
 	}
+
+	return newattnum;
 }
 
 /*
@@ -4915,7 +4936,7 @@ ATPrepAddOids(List **wqueue, Relation rel, bool recurse, AlterTableCmd *cmd, LOC
 /*
  * ALTER TABLE ALTER COLUMN DROP NOT NULL
  */
-static void
+static AttrNumber
 ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode)
 {
 	HeapTuple	tuple;
@@ -5000,18 +5021,22 @@ ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode)
 
 		/* keep the system catalog indexes current */
 		CatalogUpdateIndexes(attr_rel, tuple);
+
+		/* XXX should we return InvalidAttrNumber if there was no change? */
 	}
 
 	InvokeObjectPostAlterHook(RelationRelationId,
 							  RelationGetRelid(rel), attnum);
 
 	heap_close(attr_rel, RowExclusiveLock);
+
+	return attnum;
 }
 
 /*
  * ALTER TABLE ALTER COLUMN SET NOT NULL
  */
-static void
+static AttrNumber
 ATExecSetNotNull(AlteredTableInfo *tab, Relation rel,
 				 const char *colName, LOCKMODE lockmode)
 {
@@ -5055,18 +5080,22 @@ ATExecSetNotNull(AlteredTableInfo *tab, Relation rel,
 
 		/* Tell Phase 3 it needs to test the constraint */
 		tab->new_notnull = true;
+
+		/* XXX should we return InvalidAttrNumber if there was no change? */
 	}
 
 	InvokeObjectPostAlterHook(RelationRelationId,
 							  RelationGetRelid(rel), attnum);
 
 	heap_close(attr_rel, RowExclusiveLock);
+
+	return attnum;
 }
 
 /*
  * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT
  */
-static void
+static AttrNumber
 ATExecColumnDefault(Relation rel, const char *colName,
 					Node *newDefault, LOCKMODE lockmode)
 {
@@ -5117,6 +5146,8 @@ ATExecColumnDefault(Relation rel, const char *colName,
 		AddRelationNewConstraints(rel, list_make1(rawEnt), NIL,
 								  false, true, false);
 	}
+
+	return attnum;
 }
 
 /*
@@ -5146,13 +5177,14 @@ ATPrepSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE
 					   RelationGetRelationName(rel));
 }
 
-static void
+static AttrNumber
 ATExecSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE lockmode)
 {
 	int			newtarget;
 	Relation	attrelation;
 	HeapTuple	tuple;
 	Form_pg_attribute attrtuple;
+	AttrNumber	attnum;
 
 	Assert(IsA(newValue, Integer));
 	newtarget = intVal(newValue);
@@ -5187,7 +5219,8 @@ ATExecSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE
 						colName, RelationGetRelationName(rel))));
 	attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
 
-	if (attrtuple->attnum <= 0)
+	attnum = attrtuple->attnum;
+	if (attnum <= 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 				 errmsg("cannot alter system column \"%s\"",
@@ -5206,9 +5239,11 @@ ATExecSetStatistics(Relation rel, const char *colName, Node *newValue, LOCKMODE
 	heap_freetuple(tuple);
 
 	heap_close(attrelation, RowExclusiveLock);
+
+	return attnum;
 }
 
-static void
+static AttrNumber
 ATExecSetOptions(Relation rel, const char *colName, Node *options,
 				 bool isReset, LOCKMODE lockmode)
 {
@@ -5216,6 +5251,7 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options,
 	HeapTuple	tuple,
 				newtuple;
 	Form_pg_attribute attrtuple;
+	AttrNumber	attnum;
 	Datum		datum,
 				newOptions;
 	bool		isnull;
@@ -5234,7 +5270,8 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options,
 						colName, RelationGetRelationName(rel))));
 	attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
 
-	if (attrtuple->attnum <= 0)
+	attnum = attrtuple->attnum;
+	if (attnum <= 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 				 errmsg("cannot alter system column \"%s\"",
@@ -5273,12 +5310,14 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options,
 	ReleaseSysCache(tuple);
 
 	heap_close(attrelation, RowExclusiveLock);
+
+	return attnum;
 }
 
 /*
  * ALTER TABLE ALTER COLUMN SET STORAGE
  */
-static void
+static AttrNumber
 ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE lockmode)
 {
 	char	   *storagemode;
@@ -5286,6 +5325,7 @@ ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE loc
 	Relation	attrelation;
 	HeapTuple	tuple;
 	Form_pg_attribute attrtuple;
+	AttrNumber	attnum;
 
 	Assert(IsA(newValue, String));
 	storagemode = strVal(newValue);
@@ -5318,7 +5358,8 @@ ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE loc
 						colName, RelationGetRelationName(rel))));
 	attrtuple = (Form_pg_attribute) GETSTRUCT(tuple);
 
-	if (attrtuple->attnum <= 0)
+	attnum = attrtuple->attnum;
+	if (attnum <= 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 				 errmsg("cannot alter system column \"%s\"",
@@ -5348,6 +5389,8 @@ ATExecSetStorage(Relation rel, const char *colName, Node *newValue, LOCKMODE loc
 	heap_freetuple(tuple);
 
 	heap_close(attrelation, RowExclusiveLock);
+
+	return attnum;
 }
 
 
@@ -5573,7 +5616,7 @@ ATExecDropColumn(List **wqueue, Relation rel, const char *colName,
  * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands.  This lets
  * us schedule creation of the index at the appropriate time during ALTER.
  */
-static void
+static Oid
 ATExecAddIndex(AlteredTableInfo *tab, Relation rel,
 			   IndexStmt *stmt, bool is_rebuild, LOCKMODE lockmode)
 {
@@ -5615,12 +5658,14 @@ ATExecAddIndex(AlteredTableInfo *tab, Relation rel,
 		RelationPreserveStorage(irel->rd_node, true);
 		index_close(irel, NoLock);
 	}
+
+	return new_index;
 }
 
 /*
  * ALTER TABLE ADD CONSTRAINT USING INDEX
  */
-static void
+static Oid
 ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel,
 						 IndexStmt *stmt, LOCKMODE lockmode)
 {
@@ -5630,6 +5675,7 @@ ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel,
 	IndexInfo  *indexInfo;
 	char	   *constraintName;
 	char		constraintType;
+	Oid			conOid;
 
 	Assert(IsA(stmt, IndexStmt));
 	Assert(OidIsValid(index_oid));
@@ -5674,30 +5720,34 @@ ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation rel,
 		constraintType = CONSTRAINT_UNIQUE;
 
 	/* Create the catalog entries for the constraint */
-	index_constraint_create(rel,
-							index_oid,
-							indexInfo,
-							constraintName,
-							constraintType,
-							stmt->deferrable,
-							stmt->initdeferred,
-							stmt->primary,
-							true,		/* update pg_index */
-							true,		/* remove old dependencies */
-							allowSystemTableMods,
-							false);		/* is_internal */
+	conOid = index_constraint_create(rel,
+									 index_oid,
+									 indexInfo,
+									 constraintName,
+									 constraintType,
+									 stmt->deferrable,
+									 stmt->initdeferred,
+									 stmt->primary,
+									 true,		/* update pg_index */
+									 true,		/* remove old dependencies */
+									 allowSystemTableMods,
+									 false);		/* is_internal */
 
 	index_close(indexRel, NoLock);
+
+	return conOid;
 }
 
 /*
  * ALTER TABLE ADD CONSTRAINT
  */
-static void
+static Oid
 ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 					Constraint *newConstraint, bool recurse, bool is_readd,
 					LOCKMODE lockmode)
 {
+	Oid		constrOid = InvalidOid;
+
 	Assert(IsA(newConstraint, Constraint));
 
 	/*
@@ -5708,9 +5758,10 @@ ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	switch (newConstraint->contype)
 	{
 		case CONSTR_CHECK:
-			ATAddCheckConstraint(wqueue, tab, rel,
-								 newConstraint, recurse, false, is_readd,
-								 lockmode);
+			constrOid =
+				ATAddCheckConstraint(wqueue, tab, rel,
+									 newConstraint, recurse, false, is_readd,
+									 lockmode);
 			break;
 
 		case CONSTR_FOREIGN:
@@ -5741,17 +5792,22 @@ ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 										 RelationGetNamespace(rel),
 										 NIL);
 
-			ATAddForeignKeyConstraint(tab, rel, newConstraint, lockmode);
+			constrOid = ATAddForeignKeyConstraint(tab, rel, newConstraint,
+												  lockmode);
 			break;
 
 		default:
 			elog(ERROR, "unrecognized constraint type: %d",
 				 (int) newConstraint->contype);
 	}
+
+	return constrOid;
 }
 
 /*
- * Add a check constraint to a single table and its children
+ * Add a check constraint to a single table and its children.  Returns the
+ * OID of the constraint added to the parent relation, if one gets added,
+ * or InvalidOid otherwise.
  *
  * Subroutine for ATExecAddConstraint.
  *
@@ -5770,7 +5826,7 @@ ATExecAddConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
  * "is_readd" flag for that; just setting recurse=false would result in an
  * error if there are child tables.
  */
-static void
+static Oid
 ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 					 Constraint *constr, bool recurse, bool recursing,
 					 bool is_readd, LOCKMODE lockmode)
@@ -5779,6 +5835,7 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	ListCell   *lcon;
 	List	   *children;
 	ListCell   *child;
+	Oid			constrOid = InvalidOid;
 
 	/* At top level, permission check was done in ATPrepCmd, else do it */
 	if (recursing)
@@ -5821,6 +5878,13 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 		/* Save the actually assigned name if it was defaulted */
 		if (constr->conname == NULL)
 			constr->conname = ccon->name;
+
+		/*
+		 * Save our return value. Note we don't expect more than one element in
+		 * this list.
+		 */
+		Assert(constrOid == InvalidOid);
+		constrOid = ccon->conoid;
 	}
 
 	/* At this point we must have a locked-down name to use */
@@ -5836,7 +5900,7 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	 * incorrect value for coninhcount.
 	 */
 	if (newcons == NIL)
-		return;
+		return InvalidOid;
 
 	/*
 	 * If adding a NO INHERIT constraint, no need to find our children.
@@ -5844,7 +5908,7 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 	 * handled at higher levels).
 	 */
 	if (constr->is_no_inherit || is_readd)
-		return;
+		return constrOid;
 
 	/*
 	 * Propagate to children as appropriate.  Unlike most other ALTER
@@ -5882,16 +5946,19 @@ ATAddCheckConstraint(List **wqueue, AlteredTableInfo *tab, Relation rel,
 
 		heap_close(childrel, NoLock);
 	}
+
+	return constrOid;
 }
 
 /*
- * Add a foreign-key constraint to a single table
+ * Add a foreign-key constraint to a single table; return the new constraint's
+ * OID.
  *
  * Subroutine for ATExecAddConstraint.  Must already hold exclusive
  * lock on the rel, and have done appropriate validity checks for it.
  * We do permissions checks here, however.
  */
-static void
+static Oid
 ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
 						  Constraint *fkconstraint, LOCKMODE lockmode)
 {
@@ -6290,6 +6357,8 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
 	 * Close pk table, but keep lock until we've committed.
 	 */
 	heap_close(pkrel, NoLock);
+
+	return constrOid;
 }
 
 /*
@@ -6302,7 +6371,7 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
  * recursion bit here, but we keep the API the same for when
  * other constraint types are supported.
  */
-static void
+static Oid
 ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
 					  bool recurse, bool recursing, LOCKMODE lockmode)
 {
@@ -6313,6 +6382,7 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
 	Form_pg_constraint currcon = NULL;
 	Constraint *cmdcon = NULL;
 	bool		found = false;
+	Oid			constrOid = InvalidOid;
 
 	Assert(IsA(cmd->def, Constraint));
 	cmdcon = (Constraint *) cmd->def;
@@ -6372,6 +6442,8 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
 		simple_heap_update(conrel, &copyTuple->t_self, copyTuple);
 		CatalogUpdateIndexes(conrel, copyTuple);
 
+		constrOid = HeapTupleGetOid(contuple);
+
 		InvokeObjectPostAlterHook(ConstraintRelationId,
 								  HeapTupleGetOid(contuple), 0);
 
@@ -6419,6 +6491,8 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
 	systable_endscan(scan);
 
 	heap_close(conrel, RowExclusiveLock);
+
+	return constrOid;
 }
 
 /*
@@ -6429,7 +6503,7 @@ ATExecAlterConstraint(Relation rel, AlterTableCmd *cmd,
  * no need to lock children in that case, yet we wouldn't be able to avoid
  * doing so at that level.
  */
-static void
+static Oid
 ATExecValidateConstraint(Relation rel, char *constrName, bool recurse,
 						 bool recursing, LOCKMODE lockmode)
 {
@@ -6439,6 +6513,7 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse,
 	HeapTuple	tuple;
 	Form_pg_constraint con = NULL;
 	bool		found = false;
+	Oid			constrOid = InvalidOid;
 
 	conrel = heap_open(ConstraintRelationId, RowExclusiveLock);
 
@@ -6480,9 +6555,10 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse,
 		HeapTuple	copyTuple;
 		Form_pg_constraint copy_con;
 
+		constrOid = HeapTupleGetOid(tuple);
+
 		if (con->contype == CONSTRAINT_FOREIGN)
 		{
-			Oid			conid = HeapTupleGetOid(tuple);
 			Relation	refrel;
 
 			/*
@@ -6497,7 +6573,7 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse,
 
 			validateForeignKeyConstraint(constrName, rel, refrel,
 										 con->conindid,
-										 conid);
+										 constrOid);
 			heap_close(refrel, NoLock);
 
 			/*
@@ -6578,6 +6654,8 @@ ATExecValidateConstraint(Relation rel, char *constrName, bool recurse,
 	systable_endscan(scan);
 
 	heap_close(conrel, RowExclusiveLock);
+
+	return constrOid;
 }
 
 
@@ -7657,7 +7735,7 @@ ATColumnChangeRequiresRewrite(Node *expr, AttrNumber varattno)
 	}
 }
 
-static void
+static AttrNumber
 ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
 					  AlterTableCmd *cmd, LOCKMODE lockmode)
 {
@@ -8033,9 +8111,11 @@ ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
 
 	/* Cleanup */
 	heap_freetuple(heapTup);
+
+	return attnum;
 }
 
-static void
+static AttrNumber
 ATExecAlterColumnGenericOptions(Relation rel,
 								const char *colName,
 								List *options,
@@ -8054,9 +8134,10 @@ ATExecAlterColumnGenericOptions(Relation rel,
 	Datum		datum;
 	Form_pg_foreign_table fttableform;
 	Form_pg_attribute atttableform;
+	AttrNumber	attnum;
 
 	if (options == NIL)
-		return;
+		return InvalidAttrNumber;
 
 	/* First, determine FDW validator associated to the foreign table. */
 	ftrel = heap_open(ForeignTableRelationId, AccessShareLock);
@@ -8083,7 +8164,8 @@ ATExecAlterColumnGenericOptions(Relation rel,
 
 	/* Prevent them from altering a system attribute */
 	atttableform = (Form_pg_attribute) GETSTRUCT(tuple);
-	if (atttableform->attnum <= 0)
+	attnum = atttableform->attnum;
+	if (attnum <= 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 				 errmsg("cannot alter system column \"%s\"", colName)));
@@ -8132,6 +8214,8 @@ ATExecAlterColumnGenericOptions(Relation rel,
 	heap_close(attrel, RowExclusiveLock);
 
 	heap_freetuple(newtuple);
+
+	return attnum;
 }
 
 /*
@@ -8773,7 +8857,7 @@ change_owner_recurse_to_sequences(Oid relationOid, Oid newOwnerId, LOCKMODE lock
  *
  * The only thing we have to do is to change the indisclustered bits.
  */
-static void
+static Oid
 ATExecClusterOn(Relation rel, const char *indexName, LOCKMODE lockmode)
 {
 	Oid			indexOid;
@@ -8791,6 +8875,8 @@ ATExecClusterOn(Relation rel, const char *indexName, LOCKMODE lockmode)
 
 	/* And do the work */
 	mark_index_clustered(rel, indexOid, false);
+
+	return indexOid;
 }
 
 /*
diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h
index e690e27..075c238 100644
--- a/src/include/catalog/heap.h
+++ b/src/include/catalog/heap.h
@@ -27,6 +27,7 @@ typedef struct RawColumnDefault
 typedef struct CookedConstraint
 {
 	ConstrType	contype;		/* CONSTR_DEFAULT or CONSTR_CHECK */
+	Oid			conoid;			/* OID of the new element */
 	char	   *name;			/* name, or NULL if none */
 	AttrNumber	attnum;			/* which attr (only for DEFAULT) */
 	Node	   *expr;			/* transformed default or check expr */
@@ -99,7 +100,7 @@ extern List *AddRelationNewConstraints(Relation rel,
 						  bool is_local,
 						  bool is_internal);
 
-extern void StoreAttrDefault(Relation rel, AttrNumber attnum,
+extern Oid StoreAttrDefault(Relation rel, AttrNumber attnum,
 				 Node *expr, bool is_internal);
 
 extern Node *cookDefault(ParseState *pstate,
diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h
index 006b180..acde583 100644
--- a/src/include/catalog/index.h
+++ b/src/include/catalog/index.h
@@ -62,7 +62,7 @@ extern Oid index_create(Relation heapRelation,
 			 bool concurrent,
 			 bool is_internal);
 
-extern void index_constraint_create(Relation heapRelation,
+extern Oid index_constraint_create(Relation heapRelation,
 						Oid indexRelationId,
 						IndexInfo *indexInfo,
 						const char *constraintName,
-- 
1.9.1

>From 421bd1080a9ad5aa05e26f3c2cc32c5e4a163f1b Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Tue, 29 Apr 2014 15:51:19 -0400
Subject: [PATCH 09/36] core: support ALTER TABLESPACE MOVE in event trigs

This operation actually affects tables, not tablespaces, so it doesn't
make sense to avoid support for it.
---
 src/backend/commands/event_trigger.c |  1 +
 src/backend/tcop/utility.c           | 11 +++++------
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index 1285fd0..bfab1d7 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -250,6 +250,7 @@ check_ddl_tag(const char *tag)
 		pg_strcasecmp(tag, "REFRESH MATERIALIZED VIEW") == 0 ||
 		pg_strcasecmp(tag, "ALTER DEFAULT PRIVILEGES") == 0 ||
 		pg_strcasecmp(tag, "ALTER LARGE OBJECT") == 0 ||
+		pg_strcasecmp(tag, "ALTER TABLESPACE MOVE") == 0 ||
 		pg_strcasecmp(tag, "DROP OWNED") == 0)
 		return EVENT_TRIGGER_COMMAND_TAG_OK;
 
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 3423898..5553221 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -506,11 +506,6 @@ standard_ProcessUtility(Node *parsetree,
 			AlterTableSpaceOptions((AlterTableSpaceOptionsStmt *) parsetree);
 			break;
 
-		case T_AlterTableSpaceMoveStmt:
-			/* no event triggers for global objects */
-			AlterTableSpaceMove((AlterTableSpaceMoveStmt *) parsetree);
-			break;
-
 		case T_TruncateStmt:
 			ExecuteTruncate((TruncateStmt *) parsetree);
 			break;
@@ -1304,6 +1299,10 @@ ProcessUtilitySlow(Node *parsetree,
 				ExecAlterObjectSchemaStmt((AlterObjectSchemaStmt *) parsetree);
 				break;
 
+			case T_AlterTableSpaceMoveStmt:
+				AlterTableSpaceMove((AlterTableSpaceMoveStmt *) parsetree);
+				break;
+
 			case T_AlterOwnerStmt:
 				ExecAlterOwnerStmt((AlterOwnerStmt *) parsetree);
 				break;
@@ -1806,7 +1805,7 @@ CreateCommandTag(Node *parsetree)
 			break;
 
 		case T_AlterTableSpaceMoveStmt:
-			tag = "ALTER TABLESPACE";
+			tag = "ALTER TABLESPACE MOVE";
 			break;
 
 		case T_CreateExtensionStmt:
-- 
1.9.1

>From b8ad699774b9eaaa064afe37a54ab6eb7a702b1b Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 9 May 2014 18:32:23 -0400
Subject: [PATCH 10/36] deparse/core: event triggers support GRANT/REVOKE

---
 src/backend/commands/event_trigger.c |  2 ++
 src/backend/tcop/utility.c           | 10 +++++-----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index bfab1d7..02b4e45 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -251,6 +251,8 @@ check_ddl_tag(const char *tag)
 		pg_strcasecmp(tag, "ALTER DEFAULT PRIVILEGES") == 0 ||
 		pg_strcasecmp(tag, "ALTER LARGE OBJECT") == 0 ||
 		pg_strcasecmp(tag, "ALTER TABLESPACE MOVE") == 0 ||
+		pg_strcasecmp(tag, "GRANT") == 0 ||
+		pg_strcasecmp(tag, "REVOKE") == 0 ||
 		pg_strcasecmp(tag, "DROP OWNED") == 0)
 		return EVENT_TRIGGER_COMMAND_TAG_OK;
 
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 5553221..15feead 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -545,11 +545,6 @@ standard_ProcessUtility(Node *parsetree,
 			DeallocateQuery((DeallocateStmt *) parsetree);
 			break;
 
-		case T_GrantStmt:
-			/* no event triggers for global objects */
-			ExecuteGrantStmt((GrantStmt *) parsetree);
-			break;
-
 		case T_GrantRoleStmt:
 			/* no event triggers for global objects */
 			GrantRole((GrantRoleStmt *) parsetree);
@@ -1307,6 +1302,11 @@ ProcessUtilitySlow(Node *parsetree,
 				ExecAlterOwnerStmt((AlterOwnerStmt *) parsetree);
 				break;
 
+			case T_GrantStmt:
+				/* command is stashed in ExecuteGrantStmt_oids */
+				ExecuteGrantStmt((GrantStmt *) parsetree);
+				break;
+
 			case T_DropOwnedStmt:
 				DropOwnedObjects((DropOwnedStmt *) parsetree);
 				break;
-- 
1.9.1

>From 3fb5d2e2ed7065f04b5c18e1e9cb42c287c6e284 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Thu, 12 Jun 2014 16:43:07 -0400
Subject: [PATCH 11/36] deparse/core: add format_type_detailed()

---
 src/backend/utils/adt/format_type.c | 99 ++++++++++++++++++++++++++++++++++++-
 src/include/utils/builtins.h        |  3 ++
 2 files changed, 100 insertions(+), 2 deletions(-)

diff --git a/src/backend/utils/adt/format_type.c b/src/backend/utils/adt/format_type.c
index e1763a3..7639d49 100644
--- a/src/backend/utils/adt/format_type.c
+++ b/src/backend/utils/adt/format_type.c
@@ -96,6 +96,9 @@ format_type_be(Oid type_oid)
 	return format_type_internal(type_oid, -1, false, false, false);
 }
 
+/*
+ * This version returns a name which is always qualified.
+ */
 char *
 format_type_be_qualified(Oid type_oid)
 {
@@ -323,6 +326,92 @@ format_type_internal(Oid type_oid, int32 typemod,
 	return buf;
 }
 
+/*
+ * Similar to format_type_internal, except we return each bit of information
+ * separately:
+ *
+ * - nspid is the schema OID
+ *
+ * - typename is set to the type name, without quotes
+ *
+ * - typmod is set to the typemod, if any, as a string with parens
+ *
+ * - is_array indicates whether []s must be added
+ *
+ * Also, we don't try to decode type names to their standard-mandated names.
+ *
+ * XXX there is a lot of code duplication between this routine and
+ * format_type_internal.  (One thing that doesn't quite match is the whole
+ * allow_invalid business.)
+ */
+void
+format_type_detailed(Oid type_oid, int32 typemod,
+					 Oid *nspid, char **typname, char **typemodstr,
+					 bool *is_array)
+{
+	HeapTuple	tuple;
+	Form_pg_type typeform;
+	Oid			array_base_type;
+
+	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
+	if (!HeapTupleIsValid(tuple))
+		elog(ERROR, "cache lookup failed for type %u", type_oid);
+
+	typeform = (Form_pg_type) GETSTRUCT(tuple);
+
+	/*
+	 * Special-case crock for INTERVAL.  The typmod here is so awful that
+	 * there's no way to cope with the regular code path.
+	 */
+	if (type_oid == INTERVALOID)
+	{
+		*typname = pstrdup("INTERVAL");
+		*nspid = InvalidOid;
+
+		if (typemod > 0)
+			*typemodstr = printTypmod(NULL, typemod, typeform->typmodout);
+		else
+			*typemodstr = pstrdup("");	/* XXX ?? */
+
+		*is_array = false;
+
+		ReleaseSysCache(tuple);
+		return;
+	}
+
+	/*
+	 * Check if it's a regular (variable length) array type.  As above,
+	 * fixed-length array types such as "name" shouldn't get deconstructed.
+	 */
+	array_base_type = typeform->typelem;
+
+	if (array_base_type != InvalidOid &&
+		typeform->typstorage != 'p')
+	{
+		/* Switch our attention to the array element type */
+		ReleaseSysCache(tuple);
+		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for type %u", type_oid);
+
+		typeform = (Form_pg_type) GETSTRUCT(tuple);
+		type_oid = array_base_type;
+		*is_array = true;
+	}
+	else
+		*is_array = false;
+
+	*nspid = typeform->typnamespace;
+	*typname = pstrdup(NameStr(typeform->typname));
+
+	if (typemod > 0)
+		*typemodstr = printTypmod(NULL, typemod, typeform->typmodout);
+	else
+		*typemodstr = pstrdup("");	/* XXX ?? */
+
+	ReleaseSysCache(tuple);
+}
+
 
 /*
  * Add typmod decoration to the basic type name
@@ -338,7 +427,10 @@ printTypmod(const char *typname, int32 typmod, Oid typmodout)
 	if (typmodout == InvalidOid)
 	{
 		/* Default behavior: just print the integer typmod with parens */
-		res = psprintf("%s(%d)", typname, (int) typmod);
+		if (typname == NULL)
+			res = psprintf("(%d)", (int) typmod);
+		else
+			res = psprintf("%s(%d)", typname, (int) typmod);
 	}
 	else
 	{
@@ -347,7 +439,10 @@ printTypmod(const char *typname, int32 typmod, Oid typmodout)
 
 		tmstr = DatumGetCString(OidFunctionCall1(typmodout,
 												 Int32GetDatum(typmod)));
-		res = psprintf("%s%s", typname, tmstr);
+		if (typname == NULL)
+			res = psprintf("%s", tmstr);
+		else
+			res = psprintf("%s%s", typname, tmstr);
 	}
 
 	return res;
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index 26f998d..58c813b 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -1064,6 +1064,9 @@ extern char *format_type_be_qualified(Oid type_oid);
 extern char *format_type_with_typemod(Oid type_oid, int32 typemod);
 extern Datum oidvectortypes(PG_FUNCTION_ARGS);
 extern int32 type_maximum_size(Oid type_oid, int32 typemod);
+extern void format_type_detailed(Oid type_oid, int32 typemod,
+					 Oid *nspid, char **typname,
+					 char **typemodstr, bool *is_array);
 
 /* quote.c */
 extern Datum quote_ident(PG_FUNCTION_ARGS);
-- 
1.9.1

>From 9745fef80fb7d348d496d71bf2ecefac20444a2a Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Thu, 12 Jun 2014 16:44:47 -0400
Subject: [PATCH 12/36] deparse/core: add get_sequence_values()

---
 src/backend/commands/sequence.c | 34 ++++++++++++++++++++++++++++++++++
 src/include/commands/sequence.h |  1 +
 2 files changed, 35 insertions(+)

diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index e608420..f459b4e 100644
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -1474,6 +1474,40 @@ process_owned_by(Relation seqrel, List *owned_by)
 		relation_close(tablerel, NoLock);
 }
 
+/*
+ * Return sequence parameters, detailed
+ */
+Form_pg_sequence
+get_sequence_values(Oid sequenceId)
+{
+	Buffer		buf;
+	SeqTable	elm;
+	Relation	seqrel;
+	HeapTupleData seqtuple;
+	Form_pg_sequence seq;
+	Form_pg_sequence retSeq;
+
+	retSeq = palloc(sizeof(FormData_pg_sequence));
+
+	/* open and AccessShareLock sequence */
+	init_sequence(sequenceId, &elm, &seqrel);
+
+	if (pg_class_aclcheck(sequenceId, GetUserId(),
+						  ACL_SELECT | ACL_UPDATE | ACL_USAGE) != ACLCHECK_OK)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 errmsg("permission denied for sequence %s",
+						RelationGetRelationName(seqrel))));
+
+	seq = read_seq_tuple(elm, seqrel, &buf, &seqtuple);
+
+	memcpy(retSeq, seq, sizeof(FormData_pg_sequence));
+
+	UnlockReleaseBuffer(buf);
+	relation_close(seqrel, NoLock);
+
+	return retSeq;
+}
 
 /*
  * Return sequence parameters, for use by information schema
diff --git a/src/include/commands/sequence.h b/src/include/commands/sequence.h
index 7d8a370..b7a5db4 100644
--- a/src/include/commands/sequence.h
+++ b/src/include/commands/sequence.h
@@ -70,6 +70,7 @@ extern Datum setval3_oid(PG_FUNCTION_ARGS);
 extern Datum lastval(PG_FUNCTION_ARGS);
 
 extern Datum pg_sequence_parameters(PG_FUNCTION_ARGS);
+extern Form_pg_sequence get_sequence_values(Oid sequenceId);
 
 extern Oid	DefineSequence(CreateSeqStmt *stmt);
 extern Oid	AlterSequence(AlterSeqStmt *stmt);
-- 
1.9.1

>From bbb67644f1ff5fc691fbe80004f761e51a2d4568 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Thu, 1 May 2014 19:10:57 +0200
Subject: [PATCH 13/36] deparse/core: PGDLLIMPORT creating_extension

---
 src/include/commands/extension.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/include/commands/extension.h b/src/include/commands/extension.h
index 2cf784b..6e53320 100644
--- a/src/include/commands/extension.h
+++ b/src/include/commands/extension.h
@@ -23,7 +23,7 @@
  * on the current pg_extension object for each SQL object created by its
  * installation script.
  */
-extern bool creating_extension;
+extern PGDLLIMPORT bool creating_extension;
 extern Oid	CurrentExtensionObject;
 
 
-- 
1.9.1

>From c82cf1dbe5a262f73758901e38834693e162bb7d Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 14 Feb 2014 19:04:08 -0300
Subject: [PATCH 15/36] deparse: support CREATE TYPE AS RANGE

---
 src/backend/tcop/deparse_utility.c | 107 +++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index fb97d53..f01d912 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -37,7 +37,9 @@
 #include "catalog/pg_depend.h"
 #include "catalog/pg_inherits.h"
 #include "catalog/pg_operator.h"
+#include "catalog/pg_opclass.h"
 #include "catalog/pg_proc.h"
+#include "catalog/pg_range.h"
 #include "catalog/pg_trigger.h"
 #include "catalog/pg_type.h"
 #include "commands/defrem.h"
@@ -1479,6 +1481,108 @@ deparse_CreateEnumStmt(Oid objectId, Node *parsetree)
 	return command;
 }
 
+static char *
+deparse_CreateRangeStmt(Oid objectId, Node *parsetree)
+{
+	ObjTree	   *range;
+	ObjTree	   *tmp;
+	List	   *definition = NIL;
+	Relation	pg_range;
+	HeapTuple	rangeTup;
+	Form_pg_range rangeForm;
+	ScanKeyData key[1];
+	SysScanDesc scan;
+	char	   *command;
+
+	pg_range = heap_open(RangeRelationId, RowExclusiveLock);
+
+	ScanKeyInit(&key[0],
+				Anum_pg_range_rngtypid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(objectId));
+
+	scan = systable_beginscan(pg_range, RangeTypidIndexId, true,
+							  NULL, 1, key);
+
+	rangeTup = systable_getnext(scan);
+	if (!HeapTupleIsValid(rangeTup))
+		elog(ERROR, "cache lookup failed for range with type oid %u",
+			 objectId);
+
+	rangeForm = (Form_pg_range) GETSTRUCT(rangeTup);
+
+	range = new_objtree_VA("CREATE TYPE %{identity}D AS RANGE (%{definition:, }s)", 0);
+	tmp = new_objtree_for_qualname_id(TypeRelationId, objectId);
+	append_object_object(range, "identity", tmp);
+
+	/* SUBTYPE */
+	tmp = new_objtree_for_qualname_id(TypeRelationId,
+									  rangeForm->rngsubtype);
+	tmp = new_objtree_VA("SUBTYPE = %{type}D",
+						 2,
+						 "clause", ObjTypeString, "subtype",
+						 "type", ObjTypeObject, tmp);
+	definition = lappend(definition, new_object_object(NULL, tmp));
+
+	/* SUBTYPE_OPCLASS */
+	if (OidIsValid(rangeForm->rngsubopc))
+	{
+		tmp = new_objtree_for_qualname_id(OperatorClassRelationId,
+										  rangeForm->rngsubopc);
+		tmp = new_objtree_VA("SUBTYPE_OPCLASS = %{opclass}D",
+							 2,
+							 "clause", ObjTypeString, "opclass",
+							 "opclass", ObjTypeObject, tmp);
+		definition = lappend(definition, new_object_object(NULL, tmp));
+	}
+
+	/* COLLATION */
+	if (OidIsValid(rangeForm->rngcollation))
+	{
+		tmp = new_objtree_for_qualname_id(CollationRelationId,
+										  rangeForm->rngcollation);
+		tmp = new_objtree_VA("COLLATION = %{collation}D",
+							 2,
+							 "clause", ObjTypeString, "collation",
+							 "collation", ObjTypeObject, tmp);
+		definition = lappend(definition, new_object_object(NULL, tmp));
+	}
+
+	/* CANONICAL */
+	if (OidIsValid(rangeForm->rngcanonical))
+	{
+		tmp = new_objtree_for_qualname_id(ProcedureRelationId,
+										  rangeForm->rngcanonical);
+		tmp = new_objtree_VA("CANONICAL = %{canonical}D",
+							 2,
+							 "clause", ObjTypeString, "canonical",
+							 "canonical", ObjTypeObject, tmp);
+		definition = lappend(definition, new_object_object(NULL, tmp));
+	}
+
+	/* SUBTYPE_DIFF */
+	if (OidIsValid(rangeForm->rngsubdiff))
+	{
+		tmp = new_objtree_for_qualname_id(ProcedureRelationId,
+										  rangeForm->rngsubdiff);
+		tmp = new_objtree_VA("SUBTYPE_DIFF = %{subtype_diff}D",
+							 2,
+							 "clause", ObjTypeString, "subtype_diff",
+							 "subtype_diff", ObjTypeObject, tmp);
+		definition = lappend(definition, new_object_object(NULL, tmp));
+	}
+
+	append_array_object(range, "definition", definition);
+
+	systable_endscan(scan);
+	heap_close(pg_range, RowExclusiveLock);
+
+	command = jsonize_objtree(range);
+	free_objtree(range);
+
+	return command;
+}
+
 static inline ObjElem *
 deparse_Seq_Cache(ObjTree *parent, Form_pg_sequence seqdata)
 {
@@ -1962,6 +2066,9 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			break;
 
 		case T_CreateRangeStmt:	/* CREATE TYPE AS RANGE */
+			command = deparse_CreateRangeStmt(objectId, parsetree);
+			break;
+
 		case T_CreateDomainStmt:
 		case T_CreateFunctionStmt:
 		case T_CreateTableAsStmt:
-- 
1.9.1

>From d0be0f321f917e83e1a273ec1ca24337eca2f7b9 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 21 Feb 2014 18:11:35 -0300
Subject: [PATCH 16/36] deparse: Add support for CREATE EXTENSION

---
 src/backend/tcop/deparse_utility.c | 85 +++++++++++++++++++++++++++++++++++++-
 src/backend/tcop/utility.c         |  3 +-
 2 files changed, 86 insertions(+), 2 deletions(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index f01d912..ffe6326 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -35,6 +35,7 @@
 #include "catalog/pg_collation.h"
 #include "catalog/pg_constraint.h"
 #include "catalog/pg_depend.h"
+#include "catalog/pg_extension.h"
 #include "catalog/pg_inherits.h"
 #include "catalog/pg_operator.h"
 #include "catalog/pg_opclass.h"
@@ -626,6 +627,85 @@ get_persistence_str(char persistence)
 }
 
 /*
+ * deparse_CreateExtensionStmt
+ * 		deparse a CreateExtensionStmt
+ *
+ * Given an extension OID and the parsetree that created it, return the JSON
+ * blob representing the creation command.
+ *
+ * XXX the current representation makes the output command dependant on the
+ * installed versions of the extension.  Is this a problem?
+ */
+static char *
+deparse_CreateExtensionStmt(Oid objectId, Node *parsetree)
+{
+	CreateExtensionStmt *node = (CreateExtensionStmt *) parsetree;
+	Relation    pg_extension;
+	HeapTuple   extTup;
+	Form_pg_extension extForm;
+	ObjTree	   *extStmt;
+	ObjTree	   *tmp;
+	char	   *command;
+	List	   *list;
+	ListCell   *cell;
+
+	pg_extension = heap_open(ExtensionRelationId, AccessShareLock);
+	extTup = get_catalog_object_by_oid(pg_extension, objectId);
+	if (!HeapTupleIsValid(extTup))
+		elog(ERROR, "cache lookup failed for extension with OID %u",
+			 objectId);
+	extForm = (Form_pg_extension) GETSTRUCT(extTup);
+
+	extStmt = new_objtree_VA("CREATE EXTENSION %{if_not_exists}s %{identity}I "
+							 "%{options: }s",
+							 1, "identity", ObjTypeString, node->extname);
+	append_string_object(extStmt, "if_not_exists",
+						 node->if_not_exists ? "IF NOT EXISTS" : "");
+	list = NIL;
+	foreach(cell, node->options)
+	{
+		DefElem *opt = (DefElem *) lfirst(cell);
+
+		if (strcmp(opt->defname, "schema") == 0)
+		{
+			/* skip this one; we add one unconditionally below */
+			continue;
+		}
+		else if (strcmp(opt->defname, "new_version") == 0)
+		{
+			tmp = new_objtree_VA("VERSION %{version}L", 2,
+								 "type", ObjTypeString, "version",
+								 "version", ObjTypeString, defGetString(opt));
+			list = lappend(list, new_object_object(NULL, tmp));
+		}
+		else if (strcmp(opt->defname, "old_version") == 0)
+		{
+			tmp = new_objtree_VA("FROM %{version}L", 2,
+								 "type", ObjTypeString, "from",
+								 "version", ObjTypeString, defGetString(opt));
+			list = lappend(list, new_object_object(NULL, tmp));
+		}
+		else
+			elog(ERROR, "unsupported option %s", opt->defname);
+	}
+
+	tmp = new_objtree_VA("SCHEMA %{schema}I",
+						 2, "type", ObjTypeString, "schema",
+						 "schema", ObjTypeString,
+						 get_namespace_name(extForm->extnamespace));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	append_array_object(extStmt, "options", list);
+
+	heap_close(pg_extension, AccessShareLock);
+
+	command = jsonize_objtree(extStmt);
+	free_objtree(extStmt);
+
+	return command;
+}
+
+/*
  * deparse_ViewStmt
  *		deparse a ViewStmt
  *
@@ -2053,10 +2133,13 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 
 			/* other local objects */
 		case T_DefineStmt:
-		case T_CreateExtensionStmt:
 			command = NULL;
 			break;
 
+		case T_CreateExtensionStmt:
+			command = deparse_CreateExtensionStmt(objectId, parsetree);
+			break;
+
 		case T_CompositeTypeStmt:		/* CREATE TYPE (composite) */
 			command = deparse_CompositeTypeStmt(objectId, parsetree);
 			break;
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 0528c78..63fba50 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -1178,7 +1178,8 @@ ProcessUtilitySlow(Node *parsetree,
 
 			case T_AlterExtensionStmt:
 				EventTriggerStashExtensionStart();
-				ExecAlterExtensionStmt((AlterExtensionStmt *) parsetree);
+				objectId = ExecAlterExtensionStmt((AlterExtensionStmt *) parsetree);
+				EventTriggerStashCommand(objectId, OBJECT_EXTENSION, parsetree);
 				EventTriggerStashExtensionStop();
 				break;
 
-- 
1.9.1

>From 29efc0daed3f09ea06e6a35924575b45aaa9fcac Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Wed, 26 Feb 2014 17:26:55 -0300
Subject: [PATCH 17/36] deparse: add support for CREATE RULE

---
 src/backend/tcop/deparse_utility.c | 97 +++++++++++++++++++++++++++++++++++++-
 src/backend/utils/adt/ruleutils.c  | 71 ++++++++++++++++++++++++++++
 src/include/utils/ruleutils.h      |  2 +
 3 files changed, 169 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index ffe6326..677e7dc 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -27,6 +27,7 @@
 #include "postgres.h"
 
 #include "access/htup_details.h"
+#include "access/sysattr.h"
 #include "catalog/heap.h"
 #include "catalog/index.h"
 #include "catalog/namespace.h"
@@ -41,6 +42,7 @@
 #include "catalog/pg_opclass.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_range.h"
+#include "catalog/pg_rewrite.h"
 #include "catalog/pg_trigger.h"
 #include "catalog/pg_type.h"
 #include "commands/defrem.h"
@@ -2027,6 +2029,99 @@ deparse_IndexStmt(Oid objectId, Node *parsetree)
 	return command;
 }
 
+static char *
+deparse_RuleStmt(Oid objectId, Node *parsetree)
+{
+	RuleStmt *node = (RuleStmt *) parsetree;
+	ObjTree	   *ruleStmt;
+	ObjTree	   *tmp;
+	char	   *command;
+	Relation	pg_rewrite;
+	Form_pg_rewrite rewrForm;
+	HeapTuple	rewrTup;
+	SysScanDesc	scan;
+	ScanKeyData	key;
+	Datum		ev_qual;
+	Datum		ev_actions;
+	bool		isnull;
+	char	   *qual;
+	List	   *actions;
+	List	   *list;
+	ListCell   *cell;
+
+	pg_rewrite = heap_open(RewriteRelationId, AccessShareLock);
+	ScanKeyInit(&key,
+				ObjectIdAttributeNumber,
+				BTEqualStrategyNumber,
+				F_OIDEQ, ObjectIdGetDatum(objectId));
+
+	scan = systable_beginscan(pg_rewrite, RewriteOidIndexId, true,
+							  NULL, 1, &key);
+	rewrTup = systable_getnext(scan);
+	if (!HeapTupleIsValid(rewrTup))
+		elog(ERROR, "cache lookup failed for rewrite rule with oid %u",
+			 objectId);
+
+	rewrForm = (Form_pg_rewrite) GETSTRUCT(rewrTup);
+
+	ruleStmt =
+		new_objtree_VA("CREATE %{or_replace}s RULE %{identity}I "
+					   "AS ON %{event}s TO %{table}D %{where_clause}s "
+					   "DO %{instead}s (%{actions:; }s)", 2,
+					   "identity", ObjTypeString, node->rulename,
+					   "or_replace", ObjTypeString,
+					   node->replace ? "OR REPLACE" : "");
+	append_string_object(ruleStmt, "event",
+						 node->event == CMD_SELECT ? "SELECT" :
+						 node->event == CMD_UPDATE ? "UPDATE" :
+						 node->event == CMD_DELETE ? "DELETE" :
+						 node->event == CMD_INSERT ? "INSERT" : "XXX");
+	append_object_object(ruleStmt, "table",
+						 new_objtree_for_qualname_id(RelationRelationId,
+													 rewrForm->ev_class));
+
+	append_string_object(ruleStmt, "instead",
+						 node->instead ? "INSTEAD" : "ALSO");
+
+	ev_qual = heap_getattr(rewrTup, Anum_pg_rewrite_ev_qual,
+						   RelationGetDescr(pg_rewrite), &isnull);
+	ev_actions = heap_getattr(rewrTup, Anum_pg_rewrite_ev_action,
+							  RelationGetDescr(pg_rewrite), &isnull);
+
+	pg_get_ruledef_details(ev_qual, ev_actions, &qual, &actions);
+
+	tmp = new_objtree_VA("WHERE %{clause}s", 0);
+
+	if (qual)
+		append_string_object(tmp, "clause", qual);
+	else
+	{
+		append_null_object(tmp, "clause");
+		append_bool_object(tmp, "present", false);
+	}
+
+	append_object_object(ruleStmt, "where_clause", tmp);
+
+	list = NIL;
+	foreach(cell, actions)
+	{
+		char *action = lfirst(cell);
+
+		list = lappend(list, new_string_object(NULL, action));
+	}
+	append_array_object(ruleStmt, "actions", list);
+
+	systable_endscan(scan);
+	heap_close(pg_rewrite, AccessShareLock);
+
+	command = jsonize_objtree(ruleStmt);
+	free_objtree(ruleStmt);
+
+	return command;
+}
+
+
+
 /*
  * deparse_CreateSchemaStmt
  *		deparse a CreateSchemaStmt
@@ -2120,7 +2215,7 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			break;
 
 		case T_RuleStmt:
-			command = NULL;
+			command = deparse_RuleStmt(objectId, parsetree);
 			break;
 
 			/* FDW-related objects */
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 2cdb60e..522ccf4 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -448,6 +448,77 @@ pg_get_ruledef_ext(PG_FUNCTION_ARGS)
 	PG_RETURN_TEXT_P(string_to_text(pg_get_ruledef_worker(ruleoid, prettyFlags)));
 }
 
+/*
+ * Given a pair of Datum corresponding to a rule's pg_rewrite.ev_qual and
+ * ev_action columns, return their text representation; ev_qual as a single
+ * string in whereClause and ev_action as a List of strings (which might be
+ * NIL, signalling NOTHING) in actions.
+ */
+void
+pg_get_ruledef_details(Datum ev_qual, Datum ev_action,
+					   char **whereClause, List **actions)
+{
+	int prettyFlags = 0;
+	char *qualstr = TextDatumGetCString(ev_qual);
+	char *actionstr = TextDatumGetCString(ev_action);
+	List *actionNodeList = (List *) stringToNode(actionstr);
+	StringInfoData buf;
+
+	initStringInfo(&buf);
+	if (strlen(qualstr) > 0 && strcmp(qualstr, "<>") != 0)
+	{
+		Node	   *qual;
+		Query	   *query;
+		deparse_context context;
+		deparse_namespace dpns;
+
+		qual = stringToNode(qualstr);
+
+		query = (Query *) linitial(actionNodeList);
+		query = getInsertSelectQuery(query, NULL);
+
+		AcquireRewriteLocks(query, false, false);
+
+		context.buf = &buf;
+		context.namespaces = list_make1(&dpns);
+		context.windowClause = NIL;
+		context.windowTList = NIL;
+		context.varprefix = (list_length(query->rtable) != 1);
+		context.prettyFlags = prettyFlags;
+		context.wrapColumn = WRAP_COLUMN_DEFAULT;
+		context.indentLevel = PRETTYINDENT_STD;
+
+		set_deparse_for_query(&dpns, query, NIL);
+
+		get_rule_expr(qual, &context, false);
+
+		*whereClause = pstrdup(buf.data);
+	}
+	else
+		*whereClause = NULL;
+
+	if (list_length(actionNodeList) == 0)
+		*actions = NIL;
+	else
+	{
+		ListCell *cell;
+		List	*output = NIL;
+
+		foreach(cell, actionNodeList)
+		{
+			Query	*query = (Query *) lfirst(cell);
+
+			if (query->commandType == CMD_NOTHING)
+				continue;
+
+			resetStringInfo(&buf);
+			get_query_def(query, &buf, NIL, NULL,
+						  prettyFlags, WRAP_COLUMN_DEFAULT, 0);
+			output = lappend(output, pstrdup(buf.data));
+		}
+		*actions = output;
+	}
+}
 
 static char *
 pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
diff --git a/src/include/utils/ruleutils.h b/src/include/utils/ruleutils.h
index 492d940..657069d 100644
--- a/src/include/utils/ruleutils.h
+++ b/src/include/utils/ruleutils.h
@@ -32,6 +32,8 @@ extern char *pg_get_trigger_whenclause(Form_pg_trigger trigrec,
 extern char *pg_get_constraintdef_string(Oid constraintId, bool fullCommand);
 extern char *pg_get_viewstmt_definition(Query *viewParse);
 extern char *pg_get_viewdef_internal(Oid viewoid);
+extern void pg_get_ruledef_details(Datum ev_qual, Datum ev_action,
+					   char **whereClause, List **actions);
 
 extern char *deparse_expression(Node *expr, List *dpcontext,
 				   bool forceprefix, bool showimplicit);
-- 
1.9.1

>From 80f2004a06040033fa3a6fbd7360f59b6811484d Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 21 Mar 2014 16:33:14 -0300
Subject: [PATCH 18/36] deparse: support ALTER TYPE / ADD VALUE (for enums)

---
 src/backend/tcop/deparse_utility.c | 45 ++++++++++++++++++++++++++++++++++++++
 src/backend/tcop/utility.c         |  3 ++-
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 677e7dc..691c78a 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -2166,6 +2166,43 @@ deparse_CreateSchemaStmt(Oid objectId, Node *parsetree)
 }
 
 static char *
+deparse_AlterEnumStmt(Oid objectId, Node *parsetree)
+{
+	AlterEnumStmt *node = (AlterEnumStmt *) parsetree;
+	ObjTree	   *alterEnum;
+	ObjTree	   *tmp;
+	char	   *command;
+
+	alterEnum =
+		new_objtree_VA("ALTER TYPE %{identity}D ADD VALUE %{if_not_exists}s %{value}L %{position}s",
+					   0);
+
+	append_string_object(alterEnum, "if_not_exists",
+						 node->skipIfExists ? "IF NOT EXISTS" : "");
+	append_object_object(alterEnum, "identity",
+						 new_objtree_for_qualname_id(TypeRelationId,
+													 objectId));
+	append_string_object(alterEnum, "value", node->newVal);
+	tmp = new_objtree_VA("%{after_or_before}s %{neighbour}L", 0);
+	if (node->newValNeighbor)
+	{
+		append_string_object(tmp, "after_or_before",
+							 node->newValIsAfter ? "AFTER" : "BEFORE");
+		append_string_object(tmp, "neighbour", node->newValNeighbor);
+	}
+	else
+	{
+		append_bool_object(tmp, "present", false);
+	}
+	append_object_object(alterEnum, "position", tmp);
+
+	command = jsonize_objtree(alterEnum);
+	free_objtree(alterEnum);
+
+	return command;
+}
+
+static char *
 deparse_parsenode_cmd(StashedCommand *cmd)
 {
 	Oid			objectId;
@@ -2263,6 +2300,14 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			command = NULL;
 			break;
 
+		case T_AlterTableStmt:
+			command = NULL;
+			break;
+
+		case T_AlterEnumStmt:
+			command = deparse_AlterEnumStmt(objectId, parsetree);
+			break;
+
 		default:
 			command = NULL;
 			elog(LOG, "unrecognized node type: %d",
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 63fba50..b606cb8 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -1244,7 +1244,8 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_AlterEnumStmt:		/* ALTER TYPE (enum) */
-				AlterEnum((AlterEnumStmt *) parsetree, isTopLevel);
+				objectId = AlterEnum((AlterEnumStmt *) parsetree, isTopLevel);
+				EventTriggerStashCommand(objectId, OBJECT_TYPE, parsetree);
 				break;
 
 			case T_ViewStmt:	/* CREATE VIEW */
-- 
1.9.1

>From 29ef698f7eda99312a6faafb7de76220d712567d Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 25 Apr 2014 16:43:53 -0300
Subject: [PATCH 19/36] deparse: add support for ALTER THING RENAME

It supports everything but functions, aggregates, operator classes and
operator families.
---
 src/backend/tcop/deparse_utility.c | 276 ++++++++++++++++++++++++++++++++++++-
 src/backend/tcop/utility.c         |  28 +++-
 2 files changed, 302 insertions(+), 2 deletions(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 691c78a..682a7f4 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -630,7 +630,7 @@ get_persistence_str(char persistence)
 
 /*
  * deparse_CreateExtensionStmt
- * 		deparse a CreateExtensionStmt
+ *		deparse a CreateExtensionStmt
  *
  * Given an extension OID and the parsetree that created it, return the JSON
  * blob representing the creation command.
@@ -1665,6 +1665,276 @@ deparse_CreateRangeStmt(Oid objectId, Node *parsetree)
 	return command;
 }
 
+/*
+ * Return the given object type as a string.
+ */
+static const char *
+stringify_objtype(ObjectType objtype)
+{
+	switch (objtype)
+	{
+		case OBJECT_AGGREGATE:
+			return "AGGREGATE";
+		case OBJECT_DOMAIN:
+			return "DOMAIN";
+		case OBJECT_COLLATION:
+			return "COLLATION";
+		case OBJECT_CONVERSION:
+			return "CONVERSION";
+		case OBJECT_FDW:
+			return "FOREIGN DATA WRAPPER";
+		case OBJECT_FOREIGN_SERVER:
+			return "SERVER";
+		case OBJECT_FOREIGN_TABLE:
+			return "FOREIGN TABLE";
+		case OBJECT_FUNCTION:
+			return "FUNCTION";
+		case OBJECT_INDEX:
+			return "INDEX";
+		case OBJECT_LANGUAGE:
+			return "LANGUAGE";
+		case OBJECT_LARGEOBJECT:
+			return "LARGE OBJECT";
+		case OBJECT_MATVIEW:
+			return "MATERIALIZED VIEW";
+		case OBJECT_OPERATOR:
+			return "OPERATOR";
+		case OBJECT_OPCLASS:
+			return "OPERATOR CLASS";
+		case OBJECT_OPFAMILY:
+			return "OPERATOR FAMILY";
+		case OBJECT_TABLE:
+			return "TABLE";
+		case OBJECT_TSCONFIGURATION:
+			return "TEXT SEARCH CONFIGURATION";
+		case OBJECT_TSDICTIONARY:
+			return "TEXT SEARCH DICTIONARY";
+		case OBJECT_TSPARSER:
+			return "TEXT SEARCH PARSER";
+		case OBJECT_TSTEMPLATE:
+			return "TEXT SEARCH TEMPLATE";
+		case OBJECT_TYPE:
+			return "TYPE";
+		case OBJECT_SCHEMA:
+			return "SCHEMA";
+		case OBJECT_SEQUENCE:
+			return "SEQUENCE";
+		case OBJECT_VIEW:
+			return "VIEW";
+
+		default:
+			elog(ERROR, "unsupported objtype %d", objtype);
+	}
+}
+
+static char *
+deparse_RenameStmt(Oid objectId, Node *parsetree)
+{
+	RenameStmt *node = (RenameStmt *) parsetree;
+	ObjTree	   *renameStmt;
+	char	   *command;
+	char	   *fmtstr;
+	Relation	relation;
+	Oid			schemaId;
+	const char *subthing;
+
+	/*
+	 * FIXME --- this code is missing support for inheritance behavioral flags,
+	 * i.e. the "*" and ONLY elements.
+	 */
+
+	/*
+	 * In a ALTER .. RENAME command, we don't have the original name of the
+	 * object in system catalogs: since we inspect them after the command has
+	 * executed, the old name is already gone.  Therefore, we extract it from
+	 * the parse node.  Note we still extract the schema name from the catalog
+	 * (it might not be present in the parse node); it cannot possibly have
+	 * changed anyway.
+	 *
+	 * XXX what if there's another event trigger running concurrently that
+	 * renames the schema or moves the object to another schema?  Seems
+	 * pretty far-fetched, but possible nonetheless.
+	 */
+	switch (node->renameType)
+	{
+		case OBJECT_TABLE:
+		case OBJECT_SEQUENCE:
+		case OBJECT_VIEW:
+		case OBJECT_MATVIEW:
+		case OBJECT_INDEX:
+		case OBJECT_FOREIGN_TABLE:
+			fmtstr = psprintf("ALTER %s %%{if_exists}s %%{identity}D RENAME TO %%{newname}I",
+							  stringify_objtype(node->renameType));
+			relation = relation_open(objectId, AccessShareLock);
+			schemaId = RelationGetNamespace(relation);
+			renameStmt = new_objtree_VA(fmtstr, 0);
+			append_object_object(renameStmt, "identity",
+								 new_objtree_for_qualname(schemaId,
+														  node->relation->relname));
+			append_string_object(renameStmt, "if_exists",
+								 node->missing_ok ? "IF EXISTS" : "");
+			relation_close(relation, AccessShareLock);
+			break;
+
+		case OBJECT_COLUMN:
+		case OBJECT_ATTRIBUTE:
+			relation = relation_open(objectId, AccessShareLock);
+			schemaId = RelationGetNamespace(relation);
+
+			if (node->renameType == OBJECT_COLUMN)
+				subthing = "COLUMN";
+			else
+				subthing = "ATTRIBUTE";
+
+			fmtstr = psprintf("ALTER %s %%{if_exists}s %%{identity}D RENAME %s %%{colname}I TO %%{newname}I",
+							  stringify_objtype(node->relationType),
+							  subthing);
+			renameStmt = new_objtree_VA(fmtstr, 0);
+			append_object_object(renameStmt, "identity",
+								 new_objtree_for_qualname(schemaId,
+														  node->relation->relname));
+			append_string_object(renameStmt, "colname", node->subname);
+			append_string_object(renameStmt, "if_exists",
+								 node->missing_ok ? "IF EXISTS" : "");
+			relation_close(relation, AccessShareLock);
+			break;
+
+		case OBJECT_SCHEMA:
+		case OBJECT_FDW:
+		case OBJECT_LANGUAGE:
+		case OBJECT_FOREIGN_SERVER:
+			fmtstr = psprintf("ALTER %s %%{identity}I RENAME TO %%{newname}I",
+							  stringify_objtype(node->relationType));
+			renameStmt = new_objtree_VA(fmtstr, 0);
+			append_string_object(renameStmt, "identity",
+								 node->subname);
+			break;
+
+		case OBJECT_COLLATION:
+		case OBJECT_CONVERSION:
+		case OBJECT_DOMAIN:
+		case OBJECT_TSDICTIONARY:
+		case OBJECT_TSPARSER:
+		case OBJECT_TSTEMPLATE:
+		case OBJECT_TSCONFIGURATION:
+		case OBJECT_TYPE:
+			{
+				ObjTree    *ident;
+				HeapTuple	objTup;
+				Oid			catalogId;
+				Relation	catalog;
+				bool		isnull;
+				AttrNumber	nspnum;
+
+				catalogId = get_objtype_catalog_oid(node->renameType);
+				catalog = heap_open(catalogId, AccessShareLock);
+				objTup = get_catalog_object_by_oid(catalog, objectId);
+				nspnum = get_object_attnum_namespace(catalogId);
+
+				schemaId = DatumGetObjectId(heap_getattr(objTup,
+														 nspnum,
+														 RelationGetDescr(catalog),
+														 &isnull));
+
+				fmtstr = psprintf("ALTER %s %%{identity}D RENAME TO %%{newname}I",
+								  stringify_objtype(node->renameType));
+				renameStmt = new_objtree_VA(fmtstr, 0);
+				ident = new_objtree_for_qualname(schemaId,
+												 strVal(llast(node->object)));
+				append_object_object(renameStmt, "identity", ident);
+				relation_close(catalog, AccessShareLock);
+
+			}
+			break;
+
+		case OBJECT_AGGREGATE:
+		case OBJECT_FUNCTION:
+			elog(ERROR, "renaming of functions and aggregates is not supported yet");
+
+		case OBJECT_CONSTRAINT:
+			{
+				HeapTuple		conTup;
+				Form_pg_constraint	constrForm;
+				ObjTree		   *ident;
+
+				conTup = SearchSysCache1(CONSTROID, objectId);
+				constrForm = (Form_pg_constraint) GETSTRUCT(conTup);
+				fmtstr = psprintf("ALTER %s %%{identity}D RENAME CONSTRAINT %%{conname}I TO %%{newname}I",
+								  stringify_objtype(node->relationType));
+				renameStmt = new_objtree_VA(fmtstr, 0);
+
+				if (node->relationType == OBJECT_DOMAIN)
+					ident = new_objtree_for_qualname_id(TypeRelationId,
+														constrForm->contypid);
+				else if (node->relationType == OBJECT_TABLE)
+					ident = new_objtree_for_qualname_id(RelationRelationId,
+														constrForm->conrelid);
+				else
+					elog(ERROR, "invalid relation type %d", node->relationType);
+
+				append_string_object(renameStmt, "conname", node->subname);
+				append_object_object(renameStmt, "identity", ident);
+				ReleaseSysCache(conTup);
+			}
+			break;
+
+		case OBJECT_OPCLASS:
+		case OBJECT_OPFAMILY:
+			ereport(ERROR,
+					(errmsg("renaming of operator classes and families is not supported")));
+			break;
+
+		case OBJECT_RULE:
+			{
+				HeapTuple	rewrTup;
+				Form_pg_rewrite rewrForm;
+				Relation	pg_rewrite;
+
+				pg_rewrite = relation_open(RewriteRelationId, AccessShareLock);
+				rewrTup = get_catalog_object_by_oid(pg_rewrite, objectId);
+				rewrForm = (Form_pg_rewrite) GETSTRUCT(rewrTup);
+
+				renameStmt = new_objtree_VA("ALTER RULE %{rulename}I ON %{identity}D RENAME TO %{newname}I",
+											0);
+				append_string_object(renameStmt, "rulename", node->subname);
+				append_object_object(renameStmt, "identity",
+									 new_objtree_for_qualname_id(RelationRelationId,
+																 rewrForm->ev_class));
+				relation_close(pg_rewrite, AccessShareLock);
+			}
+			break;
+
+		case OBJECT_TRIGGER:
+			{
+				HeapTuple	trigTup;
+				Form_pg_trigger trigForm;
+				Relation	pg_trigger;
+
+				pg_trigger = relation_open(TriggerRelationId, AccessShareLock);
+				trigTup = get_catalog_object_by_oid(pg_trigger, objectId);
+				trigForm = (Form_pg_trigger) GETSTRUCT(trigTup);
+
+				renameStmt = new_objtree_VA("ALTER TRIGGER %{triggername}I ON %{identity}D RENAME TO %{newname}I",
+											0);
+				append_string_object(renameStmt, "triggername", node->subname);
+				append_object_object(renameStmt, "identity",
+									 new_objtree_for_qualname_id(RelationRelationId,
+																 trigForm->tgrelid));
+				relation_close(pg_trigger, AccessShareLock);
+			}
+			break;
+		default:
+			elog(ERROR, "unsupported object type %d", node->renameType);
+	}
+
+	append_string_object(renameStmt, "newname", node->newname);
+
+	command = jsonize_objtree(renameStmt);
+	free_objtree(renameStmt);
+
+	return command;
+}
+
 static inline ObjElem *
 deparse_Seq_Cache(ObjTree *parent, Form_pg_sequence seqdata)
 {
@@ -2284,6 +2554,10 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			command = deparse_CreateRangeStmt(objectId, parsetree);
 			break;
 
+		case T_RenameStmt:		/* ALTER .. RENAME */
+			command = deparse_RenameStmt(objectId, parsetree);
+			break;
+
 		case T_CreateDomainStmt:
 		case T_CreateFunctionStmt:
 		case T_CreateTableAsStmt:
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index b606cb8..beedb01 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -1343,7 +1343,33 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_RenameStmt:
-				ExecRenameStmt((RenameStmt *) parsetree);
+				{
+					ObjectType	objtype;
+
+					objectId = ExecRenameStmt((RenameStmt *) parsetree);
+
+					/*
+					 * Kludge alert: the event trigger machinery as a whole
+					 * doesn't support OBJECT_COLUMN nor OBJECT_ATTRIBUTE, so
+					 * fool it by using the relation type instead.  In certain
+					 * cases this is actually incorrect (for example we might
+					 * be renaming a type attribute or a view column), but the
+					 * deparsing functions will cope with this by actually
+					 * looking at the renameType directly.  The object type and
+					 * identity as reported by
+					 * pg_event_trigger_get_creation_commands might be
+					 * misleading, though.
+					 *
+					 * To support this better we ought to have the attribute
+					 * number for the column or attribute here.  Maybe have
+					 * ExecRenameStmt pass it back?
+					 */
+					objtype = ((RenameStmt *) parsetree)->renameType;
+					if (objtype == OBJECT_COLUMN ||
+						objtype == OBJECT_ATTRIBUTE)
+						objtype = ((RenameStmt *) parsetree)->relationType;
+					EventTriggerStashCommand(objectId, objtype, parsetree);
+				}
 				break;
 
 			case T_AlterObjectSchemaStmt:
-- 
1.9.1

>From b9f18b7e0687a4cbc6a30de296ef1b38bf5cf70a Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 25 Apr 2014 17:54:19 -0300
Subject: [PATCH 20/36] deparse: support CREATE DOMAIN

---
 src/backend/tcop/deparse_utility.c | 60 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 682a7f4..0281b4e 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -1665,6 +1665,63 @@ deparse_CreateRangeStmt(Oid objectId, Node *parsetree)
 	return command;
 }
 
+static char *
+deparse_CreateDomain(Oid objectId, Node *parsetree)
+{
+	ObjTree	   *createDomain;
+	ObjTree	   *tmp;
+	char	   *command;
+	HeapTuple	typTup;
+	Form_pg_type typForm;
+	List	   *constraints;
+
+	typTup = SearchSysCache1(TYPEOID,
+							 objectId);
+	if (!HeapTupleIsValid(typTup))
+		elog(ERROR, "cache lookup failed for domain with OID %u", objectId);
+	typForm = (Form_pg_type) GETSTRUCT(typTup);
+
+	createDomain = new_objtree_VA("CREATE DOMAIN %{identity}D AS %{type}D %{not_null}s %{constraints}s %{collation}s",
+								  0);
+
+	append_object_object(createDomain,
+						 "identity",
+						 new_objtree_for_qualname_id(TypeRelationId,
+													 objectId));
+	append_object_object(createDomain,
+						 "type",
+						 new_objtree_for_qualname_id(TypeRelationId,
+													 typForm->typbasetype));
+
+	if (typForm->typnotnull)
+		append_string_object(createDomain, "not_null", "NOT NULL");
+	else
+		append_string_object(createDomain, "not_null", "");
+
+	constraints = obtainConstraints(NIL, InvalidOid, objectId);
+	tmp = new_objtree_VA("%{elements: }s", 0);
+	if (constraints == NIL)
+		append_bool_object(tmp, "present", false);
+	else
+		append_array_object(tmp, "elements", constraints);
+	append_object_object(createDomain, "constraints", tmp);
+
+	tmp = new_objtree_VA("COLLATE %{collation}D", 0);
+	if (OidIsValid(typForm->typcollation))
+		append_object_object(tmp, "collation",
+							 new_objtree_for_qualname_id(CollationRelationId,
+														 typForm->typcollation));
+	else
+		append_bool_object(tmp, "present", false);
+	append_object_object(createDomain, "collation", tmp);
+
+	ReleaseSysCache(typTup);
+	command = jsonize_objtree(createDomain);
+	free_objtree(createDomain);
+
+	return command;
+}
+
 /*
  * Return the given object type as a string.
  */
@@ -2559,6 +2616,9 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			break;
 
 		case T_CreateDomainStmt:
+			command = deparse_CreateDomain(objectId, parsetree);
+			break;
+
 		case T_CreateFunctionStmt:
 		case T_CreateTableAsStmt:
 		case T_CreatePLangStmt:
-- 
1.9.1

>From 3bc186efd1c735828b280b24b3acd7b3ed5a9c8a Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Tue, 15 Apr 2014 16:44:23 -0300
Subject: [PATCH 21/36] deparse/core: enable deparse of function defaults expr

---
 src/backend/utils/adt/ruleutils.c | 25 +++++++++++++++++++++++++
 src/include/utils/ruleutils.h     |  1 +
 2 files changed, 26 insertions(+)

diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 522ccf4..ac007ee 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -9580,3 +9580,28 @@ RelationGetColumnDefault(Relation rel, AttrNumber attno, List *dpcontext)
 
 	return defstr;
 }
+
+/*
+ * Return the defaults values of arguments to a function, as a list of
+ * deparsed expressions.
+ */
+List *
+FunctionGetDefaults(text *proargdefaults)
+{
+	List   *nodedefs;
+	List   *strdefs = NIL;
+	ListCell *cell;
+
+	nodedefs = (List *) stringToNode(TextDatumGetCString(proargdefaults));
+	if (!IsA(nodedefs, List))
+		elog(ERROR, "proargdefaults is not a list");
+
+	foreach(cell, nodedefs)
+	{
+		Node   *onedef = lfirst(cell);
+
+		strdefs = lappend(strdefs, deparse_expression_pretty(onedef, NIL, false, false, 0, 0));
+	}
+
+	return strdefs;
+}
diff --git a/src/include/utils/ruleutils.h b/src/include/utils/ruleutils.h
index 657069d..5648938 100644
--- a/src/include/utils/ruleutils.h
+++ b/src/include/utils/ruleutils.h
@@ -43,6 +43,7 @@ extern List *deparse_context_for_planstate(Node *planstate, List *ancestors,
 extern List *select_rtable_names_for_explain(List *rtable,
 								Bitmapset *rels_used);
 extern char *generate_collation_name(Oid collid);
+extern List *FunctionGetDefaults(text *proargdefaults);
 
 extern char *RelationGetColumnDefault(Relation rel, AttrNumber attno,
 						 List *dpcontext);
-- 
1.9.1

>From 9baf2143155a72317edc09b76a1290ee127b9c10 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Tue, 15 Apr 2014 16:45:03 -0300
Subject: [PATCH 22/36] deparse: deparse CREATE FUNCTION

---
 src/backend/tcop/deparse_utility.c | 319 +++++++++++++++++++++++++++++++++++++
 1 file changed, 319 insertions(+)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 0281b4e..2412843 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -38,6 +38,7 @@
 #include "catalog/pg_depend.h"
 #include "catalog/pg_extension.h"
 #include "catalog/pg_inherits.h"
+#include "catalog/pg_language.h"
 #include "catalog/pg_operator.h"
 #include "catalog/pg_opclass.h"
 #include "catalog/pg_proc.h"
@@ -1723,6 +1724,321 @@ deparse_CreateDomain(Oid objectId, Node *parsetree)
 }
 
 /*
+ * deparse_CreateFunctionStmt
+ *		Deparse a CreateFunctionStmt (CREATE FUNCTION)
+ *
+ * Given a function OID and the parsetree that created it, return the JSON
+ * blob representing the creation command.
+ *
+ * XXX this is missing the per-function custom-GUC thing.
+ */
+static char *
+deparse_CreateFunction(Oid objectId, Node *parsetree)
+{
+	CreateFunctionStmt *node = (CreateFunctionStmt *) parsetree;
+	ObjTree	   *createFunc;
+	ObjTree	   *sign;
+	ObjTree	   *tmp;
+	Datum		tmpdatum;
+	char	   *fmt;
+	char	   *definition;
+	char	   *command;
+	char	   *source;
+	char	   *probin;
+	List	   *params;
+	List	   *defaults;
+	ListCell   *cell;
+	ListCell   *curdef;
+	ListCell   *table_params = NULL;
+	HeapTuple	procTup;
+	Form_pg_proc procForm;
+	HeapTuple	langTup;
+	Oid		   *typarray;
+	Form_pg_language langForm;
+	int			i;
+	int			typnum;
+	bool		isnull;
+
+	/* get the pg_proc tuple */
+	procTup = SearchSysCache1(PROCOID, objectId);
+	if (!HeapTupleIsValid(procTup))
+		elog(ERROR, "cache lookup failure for function with OID %u",
+			 objectId);
+	procForm = (Form_pg_proc) GETSTRUCT(procTup);
+
+	/* get the corresponding pg_language tuple */
+	langTup = SearchSysCache1(LANGOID, procForm->prolang);
+	if (!HeapTupleIsValid(langTup))
+		elog(ERROR, "cache lookup failure for language with OID %u",
+			 procForm->prolang);
+	langForm = (Form_pg_language) GETSTRUCT(langTup);
+
+	/*
+	 * Determine useful values for prosrc and probin.  We cope with probin
+	 * being either NULL or "-", but prosrc must have a valid value.
+	 */
+	tmpdatum = SysCacheGetAttr(PROCOID, procTup,
+							   Anum_pg_proc_prosrc, &isnull);
+	if (isnull)
+		elog(ERROR, "null prosrc in function with OID %u", objectId);
+	source = TextDatumGetCString(tmpdatum);
+
+	/* Determine a useful value for probin */
+	tmpdatum = SysCacheGetAttr(PROCOID, procTup,
+							   Anum_pg_proc_probin, &isnull);
+	if (isnull)
+		probin = NULL;
+	else
+	{
+		probin = TextDatumGetCString(tmpdatum);
+		if (probin[0] == '\0' || strcmp(probin, "-") == 0)
+		{
+			pfree(probin);
+			probin = NULL;
+		}
+	}
+
+	if (probin == NULL)
+		definition = "%{definition}L";
+	else
+		definition = "%{objfile}L, %{symbol}L";
+
+	fmt = psprintf("CREATE %%{or_replace}s FUNCTION %%{signature}s "
+				   "RETURNS %%{return_type}s LANGUAGE %%{language}I "
+				   "%%{window}s %%{volatility}s %%{leakproof}s "
+				   "%%{strict}s %%{security_definer}s %%{cost}s %%{rows}s "
+				   "%%{set_options: }s "
+				   "AS %s", definition);
+
+	createFunc = new_objtree_VA(fmt, 1,
+								"or_replace", ObjTypeString,
+								node->replace ? "OR REPLACE" : "");
+
+	sign = new_objtree_VA("%{identity}D(%{arguments:, }s)", 0);
+
+	/*
+	 * To construct the arguments array, extract the type OIDs from the
+	 * function's pg_proc entry.  If pronargs equals the parameter list length,
+	 * there are no OUT parameters and thus we can extract the type OID from
+	 * proargtypes; otherwise we need to decode proallargtypes, which is
+	 * a bit more involved.
+	 */
+	typarray = palloc(list_length(node->parameters) * sizeof(Oid));
+	if (list_length(node->parameters) > procForm->pronargs)
+	{
+		bool	isnull;
+		Datum	alltypes;
+		Datum  *values;
+		bool   *nulls;
+		int		nelems;
+
+		alltypes = SysCacheGetAttr(PROCOID, procTup,
+								   Anum_pg_proc_proallargtypes, &isnull);
+		if (isnull)
+			elog(ERROR, "NULL proallargtypes, but more parameters than args");
+		deconstruct_array(DatumGetArrayTypeP(alltypes),
+						  OIDOID, 4, 't', 'i',
+						  &values, &nulls, &nelems);
+		if (nelems != list_length(node->parameters))
+			elog(ERROR, "mismatched proallargatypes");
+		for (i = 0; i < list_length(node->parameters); i++)
+			typarray[i] = values[i];
+	}
+	else
+	{
+		for (i = 0; i < list_length(node->parameters); i++)
+			 typarray[i] = procForm->proargtypes.values[i];
+	}
+
+	/*
+	 * If there are any default expressions, we read the deparsed expression as
+	 * a list so that we can attach them to each argument.
+	 */
+	tmpdatum = SysCacheGetAttr(PROCOID, procTup,
+							   Anum_pg_proc_proargdefaults, &isnull);
+	if (!isnull)
+	{
+		defaults = FunctionGetDefaults(DatumGetTextP(tmpdatum));
+		curdef = list_head(defaults);
+	}
+	else
+	{
+		defaults = NIL;
+		curdef = NULL;
+	}
+
+	/*
+	 * Now iterate over each parameter in the parsetree to create the
+	 * parameters array.
+	 */
+	params = NIL;
+	typnum = 0;
+	foreach(cell, node->parameters)
+	{
+		FunctionParameter *param = (FunctionParameter *) lfirst(cell);
+		ObjTree	   *tmp2;
+		ObjTree	   *tmp3;
+
+		/*
+		 * A PARAM_TABLE parameter indicates end of input arguments; the
+		 * following parameters are part of the return type.  We ignore them
+		 * here, but keep track of the current position in the list so that
+		 * we can easily produce the return type below.
+		 */
+		if (param->mode == FUNC_PARAM_TABLE)
+		{
+			table_params = cell;
+			break;
+		}
+
+		/*
+		 * Note that %{name}s is a string here, not an identifier; the reason
+		 * for this is that an absent parameter name must produce an empty
+		 * string, not "", which is what would happen if we were to use
+		 * %{name}I here.  So we add another level of indirection to allow us
+		 * to inject a "present" parameter.
+		 */
+		tmp2 = new_objtree_VA("%{mode}s %{name}s %{type}T %{default}s", 0);
+		append_string_object(tmp2, "mode",
+							 param->mode == FUNC_PARAM_IN ? "IN" :
+							 param->mode == FUNC_PARAM_OUT ? "OUT" :
+							 param->mode == FUNC_PARAM_INOUT ? "INOUT" :
+							 param->mode == FUNC_PARAM_VARIADIC ? "VARIADIC" :
+							 "INVALID MODE");
+
+		/* optional wholesale suppression of "name" occurs here */
+		append_object_object(tmp2, "name",
+							 new_objtree_VA("%{name}I", 2,
+											"name", ObjTypeString,
+											param->name ? param->name : "NULL",
+											"present", ObjTypeBool,
+											param->name ? true : false));
+
+		tmp3 = new_objtree_VA("DEFAULT %{value}s", 0);
+		if (PointerIsValid(param->defexpr))
+		{
+			char *expr;
+
+			if (curdef == NULL)
+				elog(ERROR, "proargdefaults list too short");
+			expr = lfirst(curdef);
+
+			append_string_object(tmp3, "value", expr);
+			curdef = lnext(curdef);
+		}
+		else
+			append_bool_object(tmp3, "present", false);
+		append_object_object(tmp2, "default", tmp3);
+
+		append_object_object(tmp2, "type",
+							 new_objtree_for_type(typarray[typnum++], -1));
+
+		params = lappend(params,
+						 new_object_object(NULL, tmp2));
+	}
+	append_array_object(sign, "arguments", params);
+	append_object_object(sign, "identity",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 objectId));
+	append_object_object(createFunc, "signature", sign);
+
+	/*
+	 * A return type can adopt one of two forms: either a [SETOF] some_type, or
+	 * a TABLE(list-of-types).  We can tell the second form because we saw a
+	 * table param above while scanning the argument list.
+	 */
+	if (table_params == NULL)
+	{
+		tmp = new_objtree_VA("%{setof}s %{rettype}T", 0);
+		append_string_object(tmp, "setof",
+							 procForm->proretset ? "SETOF" : "");
+		append_object_object(tmp, "rettype",
+							 new_objtree_for_type(procForm->prorettype, -1));
+		append_string_object(tmp, "return_form", "plain");
+	}
+	else
+	{
+		List	   *rettypes = NIL;
+		ObjTree	   *tmp2;
+
+		tmp = new_objtree_VA("TABLE (%{rettypes:, }s)", 0);
+		for (; table_params != NULL; table_params = lnext(table_params))
+		{
+			FunctionParameter *param = lfirst(table_params);
+
+			tmp2 = new_objtree_VA("%{name}I %{type}T", 0);
+			append_string_object(tmp2, "name", param->name);
+			append_object_object(tmp2, "type",
+								 new_objtree_for_type(typarray[typnum++], -1));
+			rettypes = lappend(rettypes,
+							   new_object_object(NULL, tmp2));
+		}
+
+		append_array_object(tmp, "rettypes", rettypes);
+		append_string_object(tmp, "return_form", "table");
+	}
+
+	append_object_object(createFunc, "return_type", tmp);
+
+	append_string_object(createFunc, "language",
+						 NameStr(langForm->lanname));
+
+	append_string_object(createFunc, "window",
+						 procForm->proiswindow ? "WINDOW" : "");
+	append_string_object(createFunc, "volatility",
+						 procForm->provolatile == PROVOLATILE_VOLATILE ?
+						 "VOLATILE" :
+						 procForm->provolatile == PROVOLATILE_STABLE ?
+						 "STABLE" :
+						 procForm->provolatile == PROVOLATILE_IMMUTABLE ?
+						 "IMMUTABLE" : "INVALID VOLATILITY");
+
+	append_string_object(createFunc, "leakproof",
+						 procForm->proleakproof ? "LEAKPROOF" : "");
+	append_string_object(createFunc, "strict",
+						 procForm->proisstrict ?
+						 "RETURNS NULL ON NULL INPUT" :
+						 "CALLED ON NULL INPUT");
+
+	append_string_object(createFunc, "security_definer",
+						 procForm->prosecdef ?
+						 "SECURITY DEFINER" : "SECURITY INVOKER");
+
+	append_object_object(createFunc, "cost",
+						 new_objtree_VA("COST %{cost}s", 1,
+										"cost", ObjTypeString,
+										psprintf("%f", procForm->procost)));
+
+	tmp = new_objtree_VA("ROWS %{rows}s", 0);
+	if (procForm->prorows == 0)
+		append_bool_object(tmp, "present", false);
+	else
+		append_string_object(tmp, "rows",
+							 psprintf("%f", procForm->prorows));
+	append_object_object(createFunc, "rows", tmp);
+
+	append_array_object(createFunc, "set_options", NIL);
+
+	if (probin == NULL)
+	{
+		append_string_object(createFunc, "definition",
+							 source);
+	}
+	else
+	{
+		append_string_object(createFunc, "objfile", probin);
+		append_string_object(createFunc, "symbol", source);
+	}
+
+	ReleaseSysCache(langTup);
+	ReleaseSysCache(procTup);
+	command = jsonize_objtree(createFunc);
+	free_objtree(createFunc);
+
+	return command;
+}
+
+/*
  * Return the given object type as a string.
  */
 static const char *
@@ -2620,6 +2936,9 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			break;
 
 		case T_CreateFunctionStmt:
+			command = deparse_CreateFunction(objectId, parsetree);
+			break;
+
 		case T_CreateTableAsStmt:
 		case T_CreatePLangStmt:
 		case T_CreateConversionStmt:
-- 
1.9.1

>From a03ea44bcbd18dd86b9e54ea3c8a1454ed1e0d59 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvherre@alvh.no-ip.org>
Date: Fri, 25 Apr 2014 16:32:20 -0300
Subject: [PATCH 23/36] deparse: initial support for ALTER TABLE

---
 src/backend/commands/event_trigger.c | 117 ++++++++++-
 src/backend/commands/tablecmds.c     |   7 +
 src/backend/tcop/deparse_utility.c   | 397 ++++++++++++++++++++++++++++++++++-
 src/backend/tcop/utility.c           |  25 ++-
 src/include/commands/event_trigger.h |   5 +
 src/include/tcop/deparse_utility.h   |   9 +
 6 files changed, 557 insertions(+), 3 deletions(-)

diff --git a/src/backend/commands/event_trigger.c b/src/backend/commands/event_trigger.c
index b351af8..74fe67c 100644
--- a/src/backend/commands/event_trigger.c
+++ b/src/backend/commands/event_trigger.c
@@ -50,6 +50,7 @@ typedef struct EventTriggerQueryState
 	slist_head	SQLDropList;
 	bool		in_sql_drop;
 	MemoryContext cxt;
+	StashedCommand *curcmd;
 	List	   *stash;		/* list of StashedCommand; see deparse_utility.h */
 	bool		in_extension;
 	struct EventTriggerQueryState *previous;
@@ -1041,6 +1042,7 @@ EventTriggerBeginCompleteQuery(void)
 	state->cxt = cxt;
 	slist_init(&(state->SQLDropList));
 	state->in_sql_drop = false;
+	state->curcmd = NULL;
 	state->stash = NIL;
 	state->in_extension = currentEventTriggerState ? currentEventTriggerState->in_extension : false;
 
@@ -1340,6 +1342,113 @@ EventTriggerStashExtensionStop(void)
 		currentEventTriggerState->in_extension = false;
 }
 
+/*
+ * EventTriggerStartRecordingSubcmds
+ * 		Prepare to receive data on a complex DDL command about to be executed
+ *
+ * Note we don't actually stash the object we create here into the "stashed"
+ * list; instead we keep it in curcmd, and only when we're done processing the
+ * subcommands we will add it to the actual stash.
+ *
+ * FIXME -- this API isn't considering the possibility of an ALTER TABLE command
+ * being called reentrantly by an event trigger function.  Do we need stackable
+ * commands at this level?
+ */
+void
+EventTriggerComplexCmdStart(Node *parsetree, ObjectType objtype)
+{
+	MemoryContext	oldcxt;
+	StashedCommand *stashed;
+
+	oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
+
+	stashed = palloc(sizeof(StashedCommand));
+
+	stashed->type = SCT_AlterTable;
+	stashed->in_extension = currentEventTriggerState->in_extension;
+
+	stashed->d.alterTable.objectId = InvalidOid;
+	stashed->d.alterTable.objtype = objtype;
+	stashed->d.alterTable.subcmds = NIL;
+	/* XXX is it necessary to have the whole parsetree? probably not ... */
+	stashed->parsetree = copyObject(parsetree);
+
+	currentEventTriggerState->curcmd = stashed;
+
+	MemoryContextSwitchTo(oldcxt);
+}
+
+void
+EventTriggerComplexCmdSetOid(Oid objectId)
+{
+	currentEventTriggerState->curcmd->d.alterTable.objectId = objectId;
+}
+
+/*
+ * EventTriggerRecordSubcmd
+ * 		Save data about a single part of a complex DDL command
+ *
+ * Right now we only support ALTER TABLE; there are no other DDL commands that
+ * require this.  (ALTER TYPE can also generate multiple subcommands, but it's
+ * actually parsed as ALTER TABLE, so there is no difference at this level.)
+ */
+void
+EventTriggerRecordSubcmd(Node *subcmd, Oid relid, AttrNumber attnum,
+						 Oid newoid)
+{
+	MemoryContext	oldcxt;
+	StashedATSubcmd *newsub;
+
+	Assert(IsA(subcmd, AlterTableCmd));
+	Assert(OidIsValid(currentEventTriggerState->curcmd->d.alterTable.objectId));
+
+	/*
+	 * If we receive a subcommand intended for a relation other than the one
+	 * we've started the complex command for, ignore it.  This is chiefly
+	 * concerned with inheritance situations: in such cases, alter table
+	 * would dispatch multiple copies of the same command for various things,
+	 * but we're only concerned with the one for the main table.
+	 */
+	if (relid != currentEventTriggerState->curcmd->d.alterTable.objectId)
+		return;
+
+	oldcxt = MemoryContextSwitchTo(currentEventTriggerState->cxt);
+
+	newsub = palloc(sizeof(StashedATSubcmd));
+	newsub->attnum = attnum;
+	newsub->oid = newoid;
+	newsub->parsetree = copyObject(subcmd);
+
+	currentEventTriggerState->curcmd->d.alterTable.subcmds =
+		lappend(currentEventTriggerState->curcmd->d.alterTable.subcmds, newsub);
+
+	MemoryContextSwitchTo(oldcxt);
+}
+
+/*
+ * EventTriggerEndRecordingSubcmds
+ * 		Finish up saving a complex DDL command
+ *
+ * FIXME this API isn't considering the possibility that a xact/subxact is
+ * aborted partway through.  Probably it's best to add an
+ * AtEOSubXact_EventTriggers() to fix this.
+ */
+void
+EventTriggerComplexCmdEnd(void)
+{
+	/* If no subcommands, don't stash anything */
+	if (list_length(currentEventTriggerState->curcmd->d.alterTable.subcmds) != 0)
+	{
+		currentEventTriggerState->stash =
+			lappend(currentEventTriggerState->stash,
+					currentEventTriggerState->curcmd);
+	}
+	else
+		pfree(currentEventTriggerState->curcmd);
+
+	currentEventTriggerState->curcmd = NULL;
+}
+
 Datum
 pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS)
 {
@@ -1418,7 +1527,8 @@ pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS)
 
 			MemSet(nulls, 0, sizeof(nulls));
 
-			if (cmd->type == SCT_Basic)
+			if (cmd->type == SCT_Basic ||
+				cmd->type == SCT_AlterTable)
 			{
 				Oid			classId;
 				Oid			objId;
@@ -1432,6 +1542,11 @@ pg_event_trigger_get_creation_commands(PG_FUNCTION_ARGS)
 					classId = get_objtype_catalog_oid(cmd->d.basic.objtype);
 					objId = cmd->d.basic.objectId;
 				}
+				else if (cmd->type == SCT_AlterTable)
+				{
+					classId = get_objtype_catalog_oid(cmd->d.alterTable.objtype);
+					objId = cmd->d.alterTable.objectId;
+				}
 
 				tag = CreateCommandTag(cmd->parsetree);
 				addr.classId = classId;
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 46dcf0e..cab0b0b 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2728,6 +2728,8 @@ AlterTableInternal(Oid relid, List *cmds, bool recurse)
 
 	rel = relation_open(relid, lockmode);
 
+	EventTriggerComplexCmdSetOid(relid);
+
 	ATController(rel, cmds, recurse, lockmode);
 }
 
@@ -3553,6 +3555,9 @@ ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
 			break;
 	}
 
+	EventTriggerRecordSubcmd((Node *) cmd, RelationGetRelid(rel),
+							 colno, newoid);
+
 	/*
 	 * Bump the command counter to ensure the next subcommand in the sequence
 	 * can see the changes so far
@@ -5615,6 +5620,8 @@ ATExecDropColumn(List **wqueue, Relation rel, const char *colName,
  * There is no such command in the grammar, but parse_utilcmd.c converts
  * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands.  This lets
  * us schedule creation of the index at the appropriate time during ALTER.
+ *
+ * Return value is the OID of the new index.
  */
 static Oid
 ATExecAddIndex(AlteredTableInfo *tab, Relation rel,
diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 2412843..040c721 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -2846,6 +2846,396 @@ deparse_AlterEnumStmt(Oid objectId, Node *parsetree)
 }
 
 static char *
+deparse_AlterTableStmt(StashedCommand *cmd)
+{
+	ObjTree	   *alterTableStmt;
+	ObjTree	   *tmp;
+	ObjTree	   *tmp2;
+	List	   *dpcontext;
+	Relation	rel;
+	List	   *subcmds = NIL;
+	ListCell   *cell;
+	char	   *command;
+
+	rel = heap_open(cmd->d.alterTable.objectId, AccessShareLock);
+	dpcontext = deparse_context_for(RelationGetRelationName(rel),
+									cmd->d.alterTable.objectId);
+
+	alterTableStmt =
+		new_objtree_VA("ALTER TABLE %{identity}D %{subcmds:, }s", 0);
+	tmp = new_objtree_for_qualname(rel->rd_rel->relnamespace,
+								   RelationGetRelationName(rel));
+	append_object_object(alterTableStmt, "identity", tmp);
+
+	foreach(cell, cmd->d.alterTable.subcmds)
+	{
+		StashedATSubcmd	*substashed = (StashedATSubcmd *) lfirst(cell);
+		AlterTableCmd	*subcmd = (AlterTableCmd *) substashed->parsetree;
+		ObjTree	   *tree;
+
+		Assert(IsA(subcmd, AlterTableCmd));
+
+		switch (subcmd->subtype)
+		{
+			case AT_AddColumn:
+			case AT_AddColumnRecurse:
+				/* XXX need to set the "recurse" bit somewhere? */
+				Assert(IsA(subcmd->def, ColumnDef));
+				tree = deparse_ColumnDef(rel, dpcontext, false,
+										 (ColumnDef *) subcmd->def);
+				tmp = new_objtree_VA("ADD COLUMN %{definition}s",
+									 2, "type", ObjTypeString, "add column",
+									 "definition", ObjTypeObject, tree);
+				subcmds = lappend(subcmds,
+								  new_object_object(NULL, tmp));
+				break;
+
+			case AT_DropColumnRecurse:
+			case AT_ValidateConstraintRecurse:
+			case AT_DropConstraintRecurse:
+			case AT_AddOidsRecurse:
+			case AT_AddIndexConstraint:
+			case AT_ReAddIndex:
+			case AT_ReAddConstraint:
+			case AT_ProcessedConstraint:
+			case AT_ReplaceRelOptions:
+				/* Subtypes used for internal operations; nothing to do here */
+				break;
+
+			case AT_AddColumnToView:
+				/* CREATE OR REPLACE VIEW -- nothing to do here */
+				break;
+
+			case AT_ColumnDefault:
+				if (subcmd->def == NULL)
+				{
+					tmp = new_objtree_VA("ALTER COLUMN %{column}I DROP DEFAULT",
+										 1, "type", ObjTypeString, "drop default");
+				}
+				else
+				{
+					List	   *dpcontext;
+					HeapTuple	attrtup;
+					AttrNumber	attno;
+
+					tmp = new_objtree_VA("ALTER COLUMN %{column}I SET DEFAULT %{definition}s",
+										 1, "type", ObjTypeString, "set default");
+
+					dpcontext = deparse_context_for(RelationGetRelationName(rel),
+													RelationGetRelid(rel));
+					attrtup = SearchSysCacheAttName(RelationGetRelid(rel), subcmd->name);
+					attno = ((Form_pg_attribute) GETSTRUCT(attrtup))->attnum;
+					append_string_object(tmp, "definition",
+										 RelationGetColumnDefault(rel, attno, dpcontext));
+					ReleaseSysCache(attrtup);
+				}
+				append_string_object(tmp, "column", subcmd->name);
+
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_DropNotNull:
+				tmp = new_objtree_VA("ALTER COLUMN %{column}I DROP NOT NULL",
+									 1, "type", ObjTypeString, "drop not null");
+				append_string_object(tmp, "column", subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_SetNotNull:
+				tmp = new_objtree_VA("ALTER COLUMN %{column}I SET NOT NULL",
+									 1, "type", ObjTypeString, "set not null");
+				append_string_object(tmp, "column", subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_SetStatistics:
+				/* not yet */
+				break;
+
+			case AT_SetOptions:
+				/* not yet */
+				break;
+
+			case AT_ResetOptions:
+				/* not yet */
+				break;
+
+			case AT_SetStorage:
+				Assert(IsA(subcmd->def, String));
+				tmp = new_objtree_VA("ALTER COLUMN %{column}I SET STORAGE %{storage}s",
+									 3, "type", ObjTypeString, "set storage",
+									 "column", ObjTypeString, subcmd->name,
+									 "storage", ObjTypeString,
+									 strVal((Value *) subcmd->def));
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_DropColumn:
+				tmp = new_objtree_VA("DROP COLUMN %{column}I",
+									 2, "type", ObjTypeString, "drop column",
+								 "column", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_AddIndex:
+				{
+					Oid			idxOid = substashed->oid;
+					IndexStmt  *istmt;
+					Relation	idx;
+					const char *idxname;
+					Oid			constrOid;
+
+					Assert(IsA(subcmd->def, IndexStmt));
+					istmt = (IndexStmt *) subcmd->def;
+
+					if (!istmt->isconstraint)
+						break;
+
+					idx = relation_open(idxOid, AccessShareLock);
+					idxname = RelationGetRelationName(idx);
+
+					constrOid = get_relation_constraint_oid(
+						cmd->d.alterTable.objectId, idxname, false);
+
+					tmp = new_objtree_VA("ADD CONSTRAINT %{name}I %{definition}s",
+										 3, "type", ObjTypeString, "add constraint",
+										 "name", ObjTypeString, idxname,
+										 "definition", ObjTypeString,
+										 pg_get_constraintdef_string(constrOid, false));
+					subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+
+					relation_close(idx, AccessShareLock);
+				}
+				break;
+
+			case AT_AddConstraint:
+			case AT_AddConstraintRecurse:
+				{
+					/* XXX need to set the "recurse" bit somewhere? */
+					Oid			constrOid = substashed->oid;
+
+					tmp = new_objtree_VA("ADD CONSTRAINT %{name}I %{definition}s",
+										 3, "type", ObjTypeString, "add constraint",
+										 "name", ObjTypeString, get_constraint_name(constrOid),
+										 "definition", ObjTypeString,
+										 pg_get_constraintdef_string(constrOid, false));
+					subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				}
+				break;
+
+			case AT_AlterConstraint:
+				break;
+
+			case AT_ValidateConstraint:
+				tmp = new_objtree_VA("VALIDATE CONSTRAINT %{constraint}I", 2,
+									 "type", ObjTypeString, "validate constraint",
+									 "constraint", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_DropConstraint:
+				tmp = new_objtree_VA("DROP CONSTRAINT %{constraint}I", 2,
+									 "type", ObjTypeString, "drop constraint",
+									 "constraint", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_AlterColumnType:
+				tmp = new_objtree_VA("ALTER COLUMN %{column}I SET DATA TYPE %{datatype}T collate_clause using_clause",
+									 2, "type", ObjTypeString, "alter column type",
+									 "column", ObjTypeString, subcmd->name);
+				/* FIXME figure out correct typid/typmod , collate clause, using_clause */
+				append_object_object(tmp, "datatype",
+									 new_objtree_for_type(INT4OID, -1));
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_AlterColumnGenericOptions:
+				break;
+
+			case AT_ChangeOwner:
+				tmp = new_objtree_VA("OWNER TO %{owner}I",
+									 2, "type", ObjTypeString, "change owner",
+									 "owner",  ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_ClusterOn:
+				tmp = new_objtree_VA("CLUSTER ON %{index}I", 2,
+									 "type", ObjTypeString, "cluster on",
+									 "index", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_DropCluster:
+				tmp = new_objtree_VA("SET WITHOUT CLUSTER", 1,
+									 "type", ObjTypeString, "set without cluster");
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_AddOids:
+				tmp = new_objtree_VA("SET WITH OIDS", 1,
+									 "type", ObjTypeString, "set with oids");
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_DropOids:
+				tmp = new_objtree_VA("SET WITHOUT OIDS", 1,
+									 "type", ObjTypeString, "set without oids");
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_SetTableSpace:
+				tmp = new_objtree_VA("SET TABLESPACE %{tablespace}I", 2,
+									 "type", ObjTypeString, "set tablespace",
+									 "tablespace", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_SetRelOptions:
+				break;
+
+			case AT_ResetRelOptions:
+				break;
+
+				/*
+				 * FIXME --- should we unify representation of all these
+				 * ENABLE/DISABLE TRIGGER commands??
+				 */
+			case AT_EnableTrig:
+				tmp = new_objtree_VA("ENABLE TRIGGER %{trigger}I", 2,
+									 "type", ObjTypeString, "enable trigger",
+									 "trigger", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_EnableAlwaysTrig:
+				tmp = new_objtree_VA("ENABLE ALWAYS TRIGGER %{trigger}I", 2,
+									 "type", ObjTypeString, "enable always trigger",
+									 "trigger", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_EnableReplicaTrig:
+				tmp = new_objtree_VA("ENABLE REPLICA TRIGGER %{trigger}I", 2,
+									 "type", ObjTypeString, "enable replica trigger",
+									 "trigger", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_DisableTrig:
+				tmp = new_objtree_VA("DISABLE TRIGGER %{trigger}I", 2,
+									 "type", ObjTypeString, "disable trigger",
+									 "trigger", ObjTypeString, subcmd->name);
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_EnableTrigAll:
+				tmp = new_objtree_VA("ENABLE TRIGGER ALL", 1,
+									 "type", ObjTypeString, "enable trigger all");
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_DisableTrigAll:
+				tmp = new_objtree_VA("DISABLE TRIGGER ALL", 1,
+									 "type", ObjTypeString, "disable trigger all");
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_EnableTrigUser:
+				tmp = new_objtree_VA("ENABLE TRIGGER USER", 1,
+									 "type", ObjTypeString, "enable trigger user");
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_DisableTrigUser:
+				tmp = new_objtree_VA("DISABLE TRIGGER USER", 1,
+									 "type", ObjTypeString, "disable trigger user");
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_EnableRule:
+				break;
+
+			case AT_EnableAlwaysRule:
+				break;
+
+			case AT_EnableReplicaRule:
+				break;
+
+			case AT_DisableRule:
+				break;
+
+			case AT_AddInherit:
+				/*
+				 * XXX this case is interesting: we cannot rely on parse node
+				 * because parent name might be unqualified; but there's no way
+				 * to extract it from catalog either, since we don't know which
+				 * of the parents is the new one.
+				 */
+				break;
+
+			case AT_DropInherit:
+				/* XXX ditto ... */
+				break;
+
+			case AT_AddOf:
+				break;
+
+			case AT_DropOf:
+				break;
+
+			case AT_ReplicaIdentity:
+				tmp = new_objtree_VA("REPLICA IDENTITY %{ident}s", 1,
+									 "type", ObjTypeString, "replica identity");
+				switch (((ReplicaIdentityStmt *) subcmd->def)->identity_type)
+				{
+					case REPLICA_IDENTITY_DEFAULT:
+						append_string_object(tmp, "ident", "DEFAULT");
+						break;
+					case REPLICA_IDENTITY_FULL:
+						append_string_object(tmp, "ident", "FULL");
+						break;
+					case REPLICA_IDENTITY_NOTHING:
+						append_string_object(tmp, "ident", "NOTHING");
+						break;
+					case REPLICA_IDENTITY_INDEX:
+						tmp2 = new_objtree_VA("USING INDEX %{index}I", 1,
+											  "index", ObjTypeString,
+											  ((ReplicaIdentityStmt *) subcmd->def)->name);
+						append_object_object(tmp, "ident", tmp2);
+						break;
+				}
+				subcmds = lappend(subcmds, new_object_object(NULL, tmp));
+				break;
+
+			case AT_GenericOptions:
+				break;
+
+			default:
+				elog(WARNING, "unsupported alter table subtype %d",
+					 subcmd->subtype);
+				break;
+		}
+	}
+
+	if (list_length(subcmds) == 0)
+	{
+		command = NULL;
+	}
+	else
+	{
+		append_array_object(alterTableStmt, "subcmds", subcmds);
+		command = jsonize_objtree(alterTableStmt);
+	}
+
+	free_objtree(alterTableStmt);
+	heap_close(rel, AccessShareLock);
+
+	return command;
+}
+
+static char *
 deparse_parsenode_cmd(StashedCommand *cmd)
 {
 	Oid			objectId;
@@ -2859,6 +3249,10 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 		case SCT_Basic:
 			objectId = cmd->d.basic.objectId;
 			break;
+		case SCT_AlterTable:
+			/* XXX needed? */
+			objectId = cmd->d.alterTable.objectId;
+			break;
 		default:
 			elog(ERROR, "unexpected deparse node type %d", cmd->type);
 	}
@@ -2954,7 +3348,7 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 			break;
 
 		case T_AlterTableStmt:
-			command = NULL;
+			command = deparse_AlterTableStmt(cmd);
 			break;
 
 		case T_AlterEnumStmt:
@@ -3013,6 +3407,7 @@ deparse_utility_command(StashedCommand *cmd)
 	switch (cmd->type)
 	{
 		case SCT_Basic:
+		case SCT_AlterTable:
 			command = deparse_parsenode_cmd(cmd);
 			break;
 		default:
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index beedb01..03547a6 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -982,6 +982,10 @@ ProcessUtilitySlow(Node *parsetree,
 						stmts = transformAlterTableStmt(relid, atstmt,
 														queryString);
 
+						/* ... ensure we have an event trigger context ... */
+						EventTriggerComplexCmdStart(parsetree, atstmt->relkind);
+						EventTriggerComplexCmdSetOid(relid);
+
 						/* ... and do it */
 						foreach(l, stmts)
 						{
@@ -995,19 +999,32 @@ ProcessUtilitySlow(Node *parsetree,
 							}
 							else
 							{
-								/* Recurse for anything else */
+								/*
+								 * Recurse for anything else.  If we need to do
+								 * so, "close" the current complex-command set,
+								 * and start a new one at the bottom; this is
+								 * needed to ensure the ordering of queued
+								 * commands is consistent with the way they are
+								 * executed here.
+								 */
+								EventTriggerComplexCmdEnd();
 								ProcessUtility(stmt,
 											   queryString,
 											   PROCESS_UTILITY_SUBCOMMAND,
 											   params,
 											   None_Receiver,
 											   NULL);
+								EventTriggerComplexCmdStart(parsetree, atstmt->relkind);
+								EventTriggerComplexCmdSetOid(relid);
 							}
 
 							/* Need CCI between commands */
 							if (lnext(l) != NULL)
 								CommandCounterIncrement();
 						}
+
+						/* done */
+						EventTriggerComplexCmdEnd();
 					}
 					else
 						ereport(NOTICE,
@@ -1156,6 +1173,7 @@ ProcessUtilitySlow(Node *parsetree,
 					stmt = transformIndexStmt(relid, stmt, queryString);
 
 					/* ... and do it */
+					EventTriggerComplexCmdStart(parsetree, OBJECT_INDEX);	/* relkind? */
 					objectId =
 						DefineIndex(relid,	/* OID of heap relation */
 									stmt,
@@ -1166,6 +1184,7 @@ ProcessUtilitySlow(Node *parsetree,
 									false); /* quiet */
 					EventTriggerStashCommand(objectId, OBJECT_INDEX,
 											 parsetree);
+					EventTriggerComplexCmdEnd();
 				}
 				break;
 
@@ -1249,8 +1268,10 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_ViewStmt:	/* CREATE VIEW */
+				EventTriggerComplexCmdStart(parsetree, OBJECT_VIEW);	/* XXX relkind? */
 				objectId = DefineView((ViewStmt *) parsetree, queryString);
 				EventTriggerStashCommand(objectId, OBJECT_VIEW, parsetree);
+				EventTriggerComplexCmdEnd();
 				break;
 
 			case T_CreateFunctionStmt:	/* CREATE FUNCTION */
@@ -1377,7 +1398,9 @@ ProcessUtilitySlow(Node *parsetree,
 				break;
 
 			case T_AlterTableSpaceMoveStmt:
+				EventTriggerComplexCmdStart(parsetree, OBJECT_TABLE);	/* XXX relkind? */
 				AlterTableSpaceMove((AlterTableSpaceMoveStmt *) parsetree);
+				EventTriggerComplexCmdEnd();
 				break;
 
 			case T_AlterOwnerStmt:
diff --git a/src/include/commands/event_trigger.h b/src/include/commands/event_trigger.h
index 8ddca3d..3e84cf7 100644
--- a/src/include/commands/event_trigger.h
+++ b/src/include/commands/event_trigger.h
@@ -56,5 +56,10 @@ extern void EventTriggerStashExtensionStart(void);
 extern void EventTriggerStashExtensionStop(void);
 extern void EventTriggerStashCommand(Oid objectId, ObjectType objtype,
 						 Node *parsetree);
+extern void EventTriggerComplexCmdStart(Node *parsetree, ObjectType objtype);
+extern void EventTriggerComplexCmdSetOid(Oid objectId);
+extern void EventTriggerRecordSubcmd(Node *subcmd, Oid relid,
+						 AttrNumber attnum, Oid newoid);
+extern void EventTriggerComplexCmdEnd(void);
 
 #endif   /* EVENT_TRIGGER_H */
diff --git a/src/include/tcop/deparse_utility.h b/src/include/tcop/deparse_utility.h
index 865e018..37b38f0 100644
--- a/src/include/tcop/deparse_utility.h
+++ b/src/include/tcop/deparse_utility.h
@@ -26,6 +26,7 @@
 typedef enum StashedCommandType
 {
 	SCT_Basic,
+	SCT_AlterTable
 } StashedCommandType;
 
 /*
@@ -42,6 +43,7 @@ typedef struct StashedCommand
 {
 	StashedCommandType type;
 	bool		in_extension;
+	List	   *subcmds;	/* list of StashedATSubcmd */
 	Node	   *parsetree;
 
 	union
@@ -51,6 +53,13 @@ typedef struct StashedCommand
 			Oid			objectId;
 			ObjectType	objtype;
 		} basic;
+
+		struct AlterTableCommand
+		{
+			Oid		objectId;
+			ObjectType objtype;
+			List   *subcmds;
+		} alterTable;
 	} d;
 } StashedCommand;
 
-- 
1.9.1

>From e71d30d3e066a44fca77458d76574da1710b89b4 Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Wed, 30 Apr 2014 12:37:41 +0530
Subject: [PATCH 24/36] deparse: Support CREATE OPERATOR FAMILY

---
 src/backend/tcop/deparse_utility.c | 45 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 040c721..09b5215 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -41,6 +41,7 @@
 #include "catalog/pg_language.h"
 #include "catalog/pg_operator.h"
 #include "catalog/pg_opclass.h"
+#include "catalog/pg_opfamily.h"
 #include "catalog/pg_proc.h"
 #include "catalog/pg_range.h"
 #include "catalog/pg_rewrite.h"
@@ -2846,6 +2847,45 @@ deparse_AlterEnumStmt(Oid objectId, Node *parsetree)
 }
 
 static char *
+deparse_CreateOpFamily(Oid objectId, Node *parsetree)
+{
+	HeapTuple   opfTup;
+	HeapTuple   amTup;
+	Form_pg_opfamily opfForm;
+	Form_pg_am  amForm;
+	ObjTree	   *copfStmt;
+	ObjTree	   *tmp;
+	char	   *command;
+
+	opfTup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(opfTup))
+		elog(ERROR, "cache lookup failed for operator family with OID %u", objectId);
+	opfForm = (Form_pg_opfamily) GETSTRUCT(opfTup);
+
+	amTup = SearchSysCache1(AMOID, ObjectIdGetDatum(opfForm->opfmethod));
+	if (!HeapTupleIsValid(amTup))
+		elog(ERROR, "cache lookup failed for access method %u",
+			 opfForm->opfmethod);
+	amForm = (Form_pg_am) GETSTRUCT(amTup);
+
+	copfStmt = new_objtree_VA("CREATE OPERATOR FAMILY %{identity}D USING %{amname}s",
+							  0);
+
+	tmp = new_objtree_for_qualname(opfForm->opfnamespace,
+								   NameStr(opfForm->opfname));
+	append_object_object(copfStmt, "identity", tmp);
+	append_string_object(copfStmt, "amname", NameStr(amForm->amname));
+
+	command = jsonize_objtree(copfStmt);
+	free_objtree(copfStmt);
+
+	ReleaseSysCache(amTup);
+	ReleaseSysCache(opfTup);
+
+	return command;
+}
+
+static char *
 deparse_AlterTableStmt(StashedCommand *cmd)
 {
 	ObjTree	   *alterTableStmt;
@@ -3338,10 +3378,13 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 		case T_CreateConversionStmt:
 		case T_CreateCastStmt:
 		case T_CreateOpClassStmt:
-		case T_CreateOpFamilyStmt:
 			command = NULL;
 			break;
 
+		case T_CreateOpFamilyStmt:
+			command = deparse_CreateOpFamily(objectId, parsetree);
+			break;
+
 			/* matviews */
 		case T_RefreshMatViewStmt:
 			command = NULL;
-- 
1.9.1

>From 3b8a7c993b0183cfd861ce6e8992bd2affbeb983 Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Wed, 30 Apr 2014 17:30:07 +0530
Subject: [PATCH 25/36] deparse: Support CREATE CONVERSION

---
 src/backend/tcop/deparse_utility.c | 44 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 09b5215..458e5d1 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -35,6 +35,7 @@
 #include "catalog/pg_class.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_constraint.h"
+#include "catalog/pg_conversion.h"
 #include "catalog/pg_depend.h"
 #include "catalog/pg_extension.h"
 #include "catalog/pg_inherits.h"
@@ -52,6 +53,7 @@
 #include "funcapi.h"
 #include "lib/ilist.h"
 #include "lib/stringinfo.h"
+#include "mb/pg_wchar.h"
 #include "nodes/makefuncs.h"
 #include "nodes/parsenodes.h"
 #include "parser/analyze.h"
@@ -2847,6 +2849,43 @@ deparse_AlterEnumStmt(Oid objectId, Node *parsetree)
 }
 
 static char *
+deparse_CreateConversion(Oid objectId, Node *parsetree)
+{
+	HeapTuple   conTup;
+	Form_pg_conversion conForm;
+	ObjTree	   *ccStmt;
+	char	   *command;
+
+	conTup = SearchSysCache1(CONDEFAULT, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(conTup))
+		elog(ERROR, "cache lookup failed for conversion with OID %u", objectId);
+	conForm = (Form_pg_conversion) GETSTRUCT(conTup);
+
+	ccStmt = new_objtree_VA("CREATE %{default}s CONVERSION %{identity}D FOR "
+							"%{source}L TO %{dest}L FROM %{function}D", 0);
+
+	append_string_object(ccStmt, "default",
+						 conForm->condefault ? "DEFAULT" : "");
+	append_object_object(ccStmt, "identity",
+						 new_objtree_for_qualname(conForm->connamespace,
+												  NameStr(conForm->conname)));
+	append_string_object(ccStmt, "source", (char *)
+						 pg_encoding_to_char(conForm->conforencoding));
+	append_string_object(ccStmt, "dest", (char *)
+						 pg_encoding_to_char(conForm->contoencoding));
+	append_object_object(ccStmt, "function",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 conForm->conproc));
+
+	command = jsonize_objtree(ccStmt);
+	free_objtree(ccStmt);
+
+	ReleaseSysCache(conTup);
+
+	return command;
+}
+
+static char *
 deparse_CreateOpFamily(Oid objectId, Node *parsetree)
 {
 	HeapTuple   opfTup;
@@ -3375,12 +3414,15 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 
 		case T_CreateTableAsStmt:
 		case T_CreatePLangStmt:
-		case T_CreateConversionStmt:
 		case T_CreateCastStmt:
 		case T_CreateOpClassStmt:
 			command = NULL;
 			break;
 
+		case T_CreateConversionStmt:
+			command = deparse_CreateConversion(objectId, parsetree);
+			break;
+
 		case T_CreateOpFamilyStmt:
 			command = deparse_CreateOpFamily(objectId, parsetree);
 			break;
-- 
1.9.1

>From b83fffb0e07b32d3a709d0cab386d59135b4c504 Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Mon, 5 May 2014 12:20:58 +0530
Subject: [PATCH 26/36] deparse: Support CREATE OPERATOR via DefineStmt

---
 src/backend/tcop/deparse_utility.c | 127 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 126 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 458e5d1..8ab47b1 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -632,6 +632,131 @@ get_persistence_str(char persistence)
 	}
 }
 
+static ObjTree *
+deparse_DefineStmt_Operator(Oid objectId, DefineStmt *define)
+{
+	HeapTuple   oprTup;
+	ObjTree	   *stmt;
+	ObjTree	   *tmp;
+	List	   *list;
+	Form_pg_operator oprForm;
+
+	oprTup = SearchSysCache1(OPEROID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(oprTup))
+		elog(ERROR, "cache lookup failed for operator with OID %u", objectId);
+	oprForm = (Form_pg_operator) GETSTRUCT(oprTup);
+
+	stmt = new_objtree_VA("CREATE OPERATOR %{identity}O (%{elems:, }s)", 0);
+
+	append_object_object(stmt, "identity",
+						 new_objtree_for_qualname(oprForm->oprnamespace,
+												  NameStr(oprForm->oprname)));
+
+	list = NIL;
+
+	tmp = new_objtree_VA("PROCEDURE=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 oprForm->oprcode));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	if (OidIsValid(oprForm->oprleft))
+	{
+		tmp = new_objtree_VA("LEFTARG=%{type}T", 0);
+		append_object_object(tmp, "type",
+							 new_objtree_for_type(oprForm->oprleft, -1));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(oprForm->oprright))
+	{
+		tmp = new_objtree_VA("RIGHTARG=%{type}T", 0);
+		append_object_object(tmp, "type",
+							 new_objtree_for_type(oprForm->oprright, -1));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(oprForm->oprcom))
+	{
+		tmp = new_objtree_VA("COMMUTATOR=%{oper}O", 0);
+		append_object_object(tmp, "oper",
+							 new_objtree_for_qualname_id(OperatorRelationId,
+														 oprForm->oprcom));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(oprForm->oprnegate))
+	{
+		tmp = new_objtree_VA("NEGATOR=%{oper}O", 0);
+		append_object_object(tmp, "oper",
+							 new_objtree_for_qualname_id(OperatorRelationId,
+														 oprForm->oprnegate));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(oprForm->oprrest))
+	{
+		tmp = new_objtree_VA("RESTRICT=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 oprForm->oprrest));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (OidIsValid(oprForm->oprjoin))
+	{
+		tmp = new_objtree_VA("JOIN=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 oprForm->oprjoin));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	if (oprForm->oprcanmerge)
+		list = lappend(list, new_object_object(NULL,
+											   new_objtree_VA("MERGES", 0)));
+	if (oprForm->oprcanhash)
+		list = lappend(list, new_object_object(NULL,
+											   new_objtree_VA("HASHES", 0)));
+
+	append_array_object(stmt, "elems", list);
+
+	ReleaseSysCache(oprTup);
+
+	return stmt;
+}
+
+static char *
+deparse_DefineStmt(Oid objectId, Node *parsetree)
+{
+	DefineStmt *define = (DefineStmt *) parsetree;
+	ObjTree	   *defStmt;
+	char	   *command;
+
+	switch (define->kind)
+	{
+		case OBJECT_OPERATOR:
+			defStmt = deparse_DefineStmt_Operator(objectId, define);
+			break;
+
+		default:
+		case OBJECT_AGGREGATE:
+		case OBJECT_TYPE:
+		case OBJECT_TSPARSER:
+		case OBJECT_TSDICTIONARY:
+		case OBJECT_TSTEMPLATE:
+		case OBJECT_TSCONFIGURATION:
+		case OBJECT_COLLATION:
+			elog(ERROR, "unsupported object kind");
+			return NULL;
+	}
+
+	command = jsonize_objtree(defStmt);
+	free_objtree(defStmt);
+
+	return command;
+}
+
 /*
  * deparse_CreateExtensionStmt
  *		deparse a CreateExtensionStmt
@@ -3381,7 +3506,7 @@ deparse_parsenode_cmd(StashedCommand *cmd)
 
 			/* other local objects */
 		case T_DefineStmt:
-			command = NULL;
+			command = deparse_DefineStmt(objectId, parsetree);
 			break;
 
 		case T_CreateExtensionStmt:
-- 
1.9.1

>From 0bc63764436a52c07c6729471438096b25fca02f Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Mon, 5 May 2014 13:22:58 +0530
Subject: [PATCH 27/36] deparse: Support CREATE COLLATION via DefineStmt

---
 src/backend/tcop/deparse_utility.c | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 8ab47b1..a6ca3cc 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -633,6 +633,33 @@ get_persistence_str(char persistence)
 }
 
 static ObjTree *
+deparse_DefineStmt_Collation(Oid objectId, DefineStmt *define)
+{
+	HeapTuple   colTup;
+	ObjTree	   *stmt;
+	Form_pg_collation colForm;
+
+	colTup = SearchSysCache1(COLLOID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(colTup))
+		elog(ERROR, "cache lookup failed for collation with OID %u", objectId);
+	colForm = (Form_pg_collation) GETSTRUCT(colTup);
+
+	stmt = new_objtree_VA("CREATE COLLATION %{identity}O "
+						  "(LC_COLLATE = %{collate}L,"
+						  " LC_CTYPE = %{ctype}L)", 0);
+
+	append_object_object(stmt, "identity",
+						 new_objtree_for_qualname(colForm->collnamespace,
+												  NameStr(colForm->collname)));
+	append_string_object(stmt, "collate", NameStr(colForm->collcollate));
+	append_string_object(stmt, "ctype", NameStr(colForm->collctype));
+
+	ReleaseSysCache(colTup);
+
+	return stmt;
+}
+
+static ObjTree *
 deparse_DefineStmt_Operator(Oid objectId, DefineStmt *define)
 {
 	HeapTuple   oprTup;
@@ -735,6 +762,10 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 
 	switch (define->kind)
 	{
+		case OBJECT_COLLATION:
+			defStmt = deparse_DefineStmt_Collation(objectId, define);
+			break;
+
 		case OBJECT_OPERATOR:
 			defStmt = deparse_DefineStmt_Operator(objectId, define);
 			break;
@@ -746,7 +777,6 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 		case OBJECT_TSDICTIONARY:
 		case OBJECT_TSTEMPLATE:
 		case OBJECT_TSCONFIGURATION:
-		case OBJECT_COLLATION:
 			elog(ERROR, "unsupported object kind");
 			return NULL;
 	}
-- 
1.9.1

>From 0f77fe48ea93cb9761168c70218fd9b14071993f Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Mon, 5 May 2014 14:12:18 +0530
Subject: [PATCH 28/36] deparse: Support CREATE TEXT SEARCH TEMPLATE via
 DefineStmt

---
 src/backend/tcop/deparse_utility.c | 52 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index a6ca3cc..777fd55 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -47,6 +47,7 @@
 #include "catalog/pg_range.h"
 #include "catalog/pg_rewrite.h"
 #include "catalog/pg_trigger.h"
+#include "catalog/pg_ts_template.h"
 #include "catalog/pg_type.h"
 #include "commands/defrem.h"
 #include "commands/sequence.h"
@@ -753,6 +754,52 @@ deparse_DefineStmt_Operator(Oid objectId, DefineStmt *define)
 	return stmt;
 }
 
+static ObjTree *
+deparse_DefineStmt_TSTemplate(Oid objectId, DefineStmt *define)
+{
+	HeapTuple   tstTup;
+	ObjTree	   *stmt;
+	ObjTree	   *tmp;
+	List	   *list;
+	Form_pg_ts_template tstForm;
+
+	tstTup = SearchSysCache1(TSTEMPLATEOID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(tstTup))
+		elog(ERROR, "cache lookup failed for text search template with OID %u",
+			 objectId);
+	tstForm = (Form_pg_ts_template) GETSTRUCT(tstTup);
+
+	stmt = new_objtree_VA("CREATE TEXT SEARCH TEMPLATE %{identity}D "
+						  "(%{elems:, }s)", 0);
+
+	append_object_object(stmt, "identity",
+						 new_objtree_for_qualname(tstForm->tmplnamespace,
+												  NameStr(tstForm->tmplname)));
+
+	list = NIL;
+
+	if (OidIsValid(tstForm->tmplinit))
+	{
+		tmp = new_objtree_VA("INIT=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 tstForm->tmplinit));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	tmp = new_objtree_VA("LEXIZE=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 tstForm->tmpllexize));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	append_array_object(stmt, "elems", list);
+
+	ReleaseSysCache(tstTup);
+
+	return stmt;
+}
+
 static char *
 deparse_DefineStmt(Oid objectId, Node *parsetree)
 {
@@ -770,12 +817,15 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 			defStmt = deparse_DefineStmt_Operator(objectId, define);
 			break;
 
+		case OBJECT_TSTEMPLATE:
+			defStmt = deparse_DefineStmt_TSTemplate(objectId, define);
+			break;
+
 		default:
 		case OBJECT_AGGREGATE:
 		case OBJECT_TYPE:
 		case OBJECT_TSPARSER:
 		case OBJECT_TSDICTIONARY:
-		case OBJECT_TSTEMPLATE:
 		case OBJECT_TSCONFIGURATION:
 			elog(ERROR, "unsupported object kind");
 			return NULL;
-- 
1.9.1

>From 268455aba42d647e2fd31916f4d12afcbcb09ab0 Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Mon, 5 May 2014 14:21:42 +0530
Subject: [PATCH 29/36] deparse: Support CREATE TEXT SEARCH PARSER via
 DefineStmt

---
 src/backend/tcop/deparse_utility.c | 70 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 69 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 777fd55..4e499cf 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -47,6 +47,7 @@
 #include "catalog/pg_range.h"
 #include "catalog/pg_rewrite.h"
 #include "catalog/pg_trigger.h"
+#include "catalog/pg_ts_parser.h"
 #include "catalog/pg_ts_template.h"
 #include "catalog/pg_type.h"
 #include "commands/defrem.h"
@@ -755,6 +756,70 @@ deparse_DefineStmt_Operator(Oid objectId, DefineStmt *define)
 }
 
 static ObjTree *
+deparse_DefineStmt_TSParser(Oid objectId, DefineStmt *define)
+{
+	HeapTuple   tspTup;
+	ObjTree	   *stmt;
+	ObjTree	   *tmp;
+	List	   *list;
+	Form_pg_ts_parser tspForm;
+
+	tspTup = SearchSysCache1(TSPARSEROID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(tspTup))
+		elog(ERROR, "cache lookup failed for text search parser with OID %u",
+			 objectId);
+	tspForm = (Form_pg_ts_parser) GETSTRUCT(tspTup);
+
+	stmt = new_objtree_VA("CREATE TEXT SEARCH PARSER %{identity}D "
+						  "(%{elems:, }s)", 0);
+
+	append_object_object(stmt, "identity",
+						 new_objtree_for_qualname(tspForm->prsnamespace,
+												  NameStr(tspForm->prsname)));
+
+	list = NIL;
+
+	tmp = new_objtree_VA("START=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 tspForm->prsstart));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	tmp = new_objtree_VA("GETTOKEN=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 tspForm->prstoken));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	tmp = new_objtree_VA("END=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 tspForm->prsend));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	tmp = new_objtree_VA("LEXTYPES=%{procedure}D", 0);
+	append_object_object(tmp, "procedure",
+						 new_objtree_for_qualname_id(ProcedureRelationId,
+													 tspForm->prslextype));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	if (OidIsValid(tspForm->prsheadline))
+	{
+		tmp = new_objtree_VA("HEADLINE=%{procedure}D", 0);
+		append_object_object(tmp, "procedure",
+							 new_objtree_for_qualname_id(ProcedureRelationId,
+														 tspForm->prsheadline));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	append_array_object(stmt, "elems", list);
+
+	ReleaseSysCache(tspTup);
+
+	return stmt;
+}
+
+static ObjTree *
 deparse_DefineStmt_TSTemplate(Oid objectId, DefineStmt *define)
 {
 	HeapTuple   tstTup;
@@ -817,6 +882,10 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 			defStmt = deparse_DefineStmt_Operator(objectId, define);
 			break;
 
+		case OBJECT_TSPARSER:
+			defStmt = deparse_DefineStmt_TSParser(objectId, define);
+			break;
+
 		case OBJECT_TSTEMPLATE:
 			defStmt = deparse_DefineStmt_TSTemplate(objectId, define);
 			break;
@@ -824,7 +893,6 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 		default:
 		case OBJECT_AGGREGATE:
 		case OBJECT_TYPE:
-		case OBJECT_TSPARSER:
 		case OBJECT_TSDICTIONARY:
 		case OBJECT_TSCONFIGURATION:
 			elog(ERROR, "unsupported object kind");
-- 
1.9.1

>From 2757be542d642065cdc3024f9f3bac32a0b7f827 Mon Sep 17 00:00:00 2001
From: Abhijit Menon-Sen <ams@2ndQuadrant.com>
Date: Mon, 5 May 2014 14:44:18 +0530
Subject: [PATCH 30/36] deparse: Support CREATE TEXT SEARCH DICTIONARY via
 DefineStmt

---
 src/backend/tcop/deparse_utility.c | 55 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 54 insertions(+), 1 deletion(-)

diff --git a/src/backend/tcop/deparse_utility.c b/src/backend/tcop/deparse_utility.c
index 4e499cf..9a325ac 100644
--- a/src/backend/tcop/deparse_utility.c
+++ b/src/backend/tcop/deparse_utility.c
@@ -47,6 +47,7 @@
 #include "catalog/pg_range.h"
 #include "catalog/pg_rewrite.h"
 #include "catalog/pg_trigger.h"
+#include "catalog/pg_ts_dict.h"
 #include "catalog/pg_ts_parser.h"
 #include "catalog/pg_ts_template.h"
 #include "catalog/pg_type.h"
@@ -820,6 +821,55 @@ deparse_DefineStmt_TSParser(Oid objectId, DefineStmt *define)
 }
 
 static ObjTree *
+deparse_DefineStmt_TSDictionary(Oid objectId, DefineStmt *define)
+{
+	HeapTuple   tsdTup;
+	ObjTree	   *stmt;
+	ObjTree	   *tmp;
+	List	   *list;
+	Datum		options;
+	bool		isnull;
+	Form_pg_ts_dict tsdForm;
+
+	tsdTup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(objectId));
+	if (!HeapTupleIsValid(tsdTup))
+		elog(ERROR, "cache lookup failed for text search dictionary "
+			 "with OID %u", objectId);
+	tsdForm = (Form_pg_ts_dict) GETSTRUCT(tsdTup);
+
+	stmt = new_objtree_VA("CREATE TEXT SEARCH DICTIONARY %{identity}D "
+						  "(%{elems:, }s)", 0);
+
+	append_object_object(stmt, "identity",
+						 new_objtree_for_qualname(tsdForm->dictnamespace,
+												  NameStr(tsdForm->dictname)));
+
+	list = NIL;
+
+	tmp = new_objtree_VA("TEMPLATE=%{template}D", 0);
+	append_object_object(tmp, "template",
+						 new_objtree_for_qualname_id(TSTemplateRelationId,
+													 tsdForm->dicttemplate));
+	list = lappend(list, new_object_object(NULL, tmp));
+
+	options = SysCacheGetAttr(TSDICTOID, tsdTup,
+							  Anum_pg_ts_dict_dictinitoption,
+							  &isnull);
+	if (!isnull)
+	{
+		tmp = new_objtree_VA("%{options}s", 0);
+		append_string_object(tmp, "options", TextDatumGetCString(options));
+		list = lappend(list, new_object_object(NULL, tmp));
+	}
+
+	append_array_object(stmt, "elems", list);
+
+	ReleaseSysCache(tsdTup);
+
+	return stmt;
+}
+
+static ObjTree *
 deparse_DefineStmt_TSTemplate(Oid objectId, DefineStmt *define)
 {
 	HeapTuple   tstTup;
@@ -886,6 +936,10 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 			defStmt = deparse_DefineStmt_TSParser(objectId, define);
 			break;
 
+		case OBJECT_TSDICTIONARY:
+			defStmt = deparse_DefineStmt_TSDictionary(objectId, define);
+			break;
+
 		case OBJECT_TSTEMPLATE:
 			defStmt = deparse_DefineStmt_TSTemplate(objectId, define);
 			break;
@@ -893,7 +947,6 @@ deparse_DefineStmt(Oid objectId, Node *parsetree)
 		default:
 		case OBJECT_AGGREGATE:
 		case OBJECT_TYPE:
-		case OBJECT_TSDICTIONARY:
 		case OBJECT_TSCONFIGURATION:
 			elog(ERROR, "unsupported object kind");
 			return NULL;
-- 
1.9.1