Change many routines to return ObjectAddress rather than OID

The changed routines are mostly those that can be directly called by
ProcessUtilitySlow; the intention is to make the affected object
information more precise, in support for future event trigger changes.
Originally it was envisioned that the OID of the affected object would
be enough, and in most cases that is correct, but upon actually
implementing the event trigger changes it turned out that ObjectAddress
is more widely useful.

Additionally, some command execution routines grew an output argument
that's an object address which provides further info about the executed
command.  To wit:

* for ALTER DOMAIN / ADD CONSTRAINT, it corresponds to the address of
  the new constraint

* for ALTER OBJECT / SET SCHEMA, it corresponds to the address of the
  schema that originally contained the object.

* for ALTER EXTENSION {ADD, DROP} OBJECT, it corresponds to the address
  of the object added to or dropped from the extension.

There's no user-visible change in this commit, and no functional change
either.

Discussion: 20150218213255.GC6717@tamriel.snowman.net
Reviewed-By: Stephen Frost, Andres Freund

Author: alvherre

src/backend/bootstrap/bootparse.y

@@ -251,7 +251,8 @@ Boot_CreateStmt:
 													  (Datum) 0,
 													  false,
 													  true,
-													  false);
+													  false,
+													  NULL);
 						elog(DEBUG4, "relation created with OID %u", id);
 					}
 					do_end();

src/backend/catalog/heap.c

@@ -89,7 +89,7 @@ static void AddNewRelationTuple(Relation pg_class_desc,
 					char relkind,
 					Datum relacl,
 					Datum reloptions);
-static Oid AddNewRelationType(const char *typeName,
+static ObjectAddress AddNewRelationType(const char *typeName,
 				   Oid typeNamespace,
 				   Oid new_rel_oid,
 				   char new_rel_kind,
@@ -935,7 +935,7 @@ AddNewRelationTuple(Relation pg_class_desc,
  *		define a composite type corresponding to the new relation
  * --------------------------------
  */
-static Oid
+static ObjectAddress
 AddNewRelationType(const char *typeName,
 				   Oid typeNamespace,
 				   Oid new_rel_oid,
@@ -1006,6 +1006,9 @@ AddNewRelationType(const char *typeName,
  *	allow_system_table_mods: TRUE to allow creation in system namespaces
  *	is_internal: is this a system-generated catalog?
  *
+ * Output parameters:
+ *	typaddress: if not null, gets the object address of the new pg_type entry
+ *
  * Returns the OID of the new relation
  * --------------------------------
  */
@@ -1029,14 +1032,16 @@ heap_create_with_catalog(const char *relname,
 						 Datum reloptions,
 						 bool use_user_acl,
 						 bool allow_system_table_mods,
-						 bool is_internal)
+						 bool is_internal,
+						 ObjectAddress *typaddress)
 {
 	Relation	pg_class_desc;
 	Relation	new_rel_desc;
 	Acl		   *relacl;
 	Oid			existing_relid;
 	Oid			old_type_oid;
 	Oid			new_type_oid;
+	ObjectAddress new_type_addr;
 	Oid			new_array_oid = InvalidOid;
 
 	pg_class_desc = heap_open(RelationRelationId, RowExclusiveLock);
@@ -1187,13 +1192,16 @@ heap_create_with_catalog(const char *relname,
 	 * creating the same type name in parallel but hadn't committed yet when
 	 * we checked for a duplicate name above.
 	 */
-	new_type_oid = AddNewRelationType(relname,
-									  relnamespace,
-									  relid,
-									  relkind,
-									  ownerid,
-									  reltypeid,
-									  new_array_oid);
+	new_type_addr = AddNewRelationType(relname,
+									   relnamespace,
+									   relid,
+									   relkind,
+									   ownerid,
+									   reltypeid,
+									   new_array_oid);
+	new_type_oid = new_type_addr.objectId;
+	if (typaddress)
+		*typaddress = new_type_addr;
 
 	/*
 	 * Now make the array type if wanted.

src/backend/catalog/objectaddress.c

@@ -531,6 +531,12 @@ ObjectTypeMap[] =
 	{ "policy", OBJECT_POLICY }
 };
 
+const ObjectAddress InvalidObjectAddress =
+{
+	InvalidOid,
+	InvalidOid,
+	0
+};
 
 static ObjectAddress get_object_address_unqualified(ObjectType objtype,
 							   List *qualname, bool missing_ok);

src/backend/catalog/pg_aggregate.c

@@ -43,7 +43,7 @@ static Oid lookup_agg_function(List *fnName, int nargs, Oid *input_types,
 /*
  * AggregateCreate
  */
-Oid
+ObjectAddress
 AggregateCreate(const char *aggName,
 				Oid aggNamespace,
 				char aggKind,
@@ -522,32 +522,33 @@ AggregateCreate(const char *aggName,
 	 * aggregate.  (This could fail if there's already a conflicting entry.)
 	 */
 
-	procOid = ProcedureCreate(aggName,
-							  aggNamespace,
-							  false,	/* no replacement */
-							  false,	/* doesn't return a set */
-							  finaltype,		/* returnType */
-							  GetUserId(),		/* proowner */
-							  INTERNALlanguageId,		/* languageObjectId */
-							  InvalidOid,		/* no validator */
-							  "aggregate_dummy",		/* placeholder proc */
-							  NULL,		/* probin */
-							  true,		/* isAgg */
-							  false,	/* isWindowFunc */
-							  false,	/* security invoker (currently not
+	myself = ProcedureCreate(aggName,
+							 aggNamespace,
+							 false,		/* no replacement */
+							 false,		/* doesn't return a set */
+							 finaltype, /* returnType */
+							 GetUserId(),		/* proowner */
+							 INTERNALlanguageId,		/* languageObjectId */
+							 InvalidOid,		/* no validator */
+							 "aggregate_dummy", /* placeholder proc */
+							 NULL,		/* probin */
+							 true,		/* isAgg */
+							 false,		/* isWindowFunc */
+							 false,		/* security invoker (currently not
 										 * definable for agg) */
-							  false,	/* isLeakProof */
-							  false,	/* isStrict (not needed for agg) */
-							  PROVOLATILE_IMMUTABLE,	/* volatility (not
+							 false,		/* isLeakProof */
+							 false,		/* isStrict (not needed for agg) */
+							 PROVOLATILE_IMMUTABLE,		/* volatility (not
 														 * needed for agg) */
-							  parameterTypes,	/* paramTypes */
-							  allParameterTypes,		/* allParamTypes */
-							  parameterModes,	/* parameterModes */
-							  parameterNames,	/* parameterNames */
-							  parameterDefaults,		/* parameterDefaults */
-							  PointerGetDatum(NULL),	/* proconfig */
-							  1,	/* procost */
-							  0);		/* prorows */
+							 parameterTypes,	/* paramTypes */
+							 allParameterTypes, /* allParamTypes */
+							 parameterModes,	/* parameterModes */
+							 parameterNames,	/* parameterNames */
+							 parameterDefaults, /* parameterDefaults */
+							 PointerGetDatum(NULL),		/* proconfig */
+							 1, /* procost */
+							 0);	/* prorows */
+	procOid = myself.objectId;
 
 	/*
 	 * Okay to create the pg_aggregate entry.
@@ -599,9 +600,6 @@ AggregateCreate(const char *aggName,
 	 * on aggTransType since we depend on it indirectly through transfn.
 	 * Likewise for aggmTransType if any.
 	 */
-	myself.classId = ProcedureRelationId;
-	myself.objectId = procOid;
-	myself.objectSubId = 0;
 
 	/* Depends on transition function */
 	referenced.classId = ProcedureRelationId;
@@ -654,7 +652,7 @@ AggregateCreate(const char *aggName,
 		recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 	}
 
-	return procOid;
+	return myself;
 }
 
 /*

src/backend/catalog/pg_conversion.c

@@ -37,7 +37,7 @@
  *
  * Add a new tuple to pg_conversion.
  */
-Oid
+ObjectAddress
 ConversionCreate(const char *conname, Oid connamespace,
 				 Oid conowner,
 				 int32 conforencoding, int32 contoencoding,
@@ -141,7 +141,7 @@ ConversionCreate(const char *conname, Oid connamespace,
 	heap_freetuple(tup);
 	heap_close(rel, RowExclusiveLock);
 
-	return oid;
+	return myself;
 }
 
 /*

src/backend/catalog/pg_operator.c

@@ -61,7 +61,7 @@ static Oid get_other_operator(List *otherOp,
 				   Oid leftTypeId, Oid rightTypeId,
 				   bool isCommutator);
 
-static void makeOperatorDependencies(HeapTuple tuple);
+static ObjectAddress makeOperatorDependencies(HeapTuple tuple);
 
 
 /*
@@ -325,7 +325,7 @@ OperatorShellMake(const char *operatorName,
  * Forward declaration is used only for this purpose, it is
  * not available to the user as it is for type definition.
  */
-Oid
+ObjectAddress
 OperatorCreate(const char *operatorName,
 			   Oid operatorNamespace,
 			   Oid leftTypeId,
@@ -352,6 +352,7 @@ OperatorCreate(const char *operatorName,
 	NameData	oname;
 	TupleDesc	tupDesc;
 	int			i;
+	ObjectAddress address;
 
 	/*
 	 * Sanity checks
@@ -540,7 +541,7 @@ OperatorCreate(const char *operatorName,
 	CatalogUpdateIndexes(pg_operator_desc, tup);
 
 	/* Add dependencies for the entry */
-	makeOperatorDependencies(tup);
+	address = makeOperatorDependencies(tup);
 
 	/* Post creation hook for new operator */
 	InvokeObjectPostCreateHook(OperatorRelationId, operatorObjectId, 0);
@@ -564,7 +565,7 @@ OperatorCreate(const char *operatorName,
 	if (OidIsValid(commutatorId) || OidIsValid(negatorId))
 		OperatorUpd(operatorObjectId, commutatorId, negatorId);
 
-	return operatorObjectId;
+	return address;
 }
 
 /*
@@ -764,7 +765,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
  * NB: the OidIsValid tests in this routine are necessary, in case
  * the given operator is a shell.
  */
-static void
+static ObjectAddress
 makeOperatorDependencies(HeapTuple tuple)
 {
 	Form_pg_operator oper = (Form_pg_operator) GETSTRUCT(tuple);
@@ -860,4 +861,6 @@ makeOperatorDependencies(HeapTuple tuple)
 
 	/* Dependency on extension */
 	recordDependencyOnCurrentExtension(&myself, true);
+
+	return myself;
 }

src/backend/catalog/pg_proc.c

@@ -64,7 +64,7 @@ static bool match_prosrc_to_literal(const char *prosrc, const char *literal,
  * not "ArrayType *", to avoid importing array.h into pg_proc_fn.h.
  * ----------------------------------------------------------------
  */
-Oid
+ObjectAddress
 ProcedureCreate(const char *procedureName,
 				Oid procNamespace,
 				bool replace,
@@ -703,7 +703,7 @@ ProcedureCreate(const char *procedureName,
 			AtEOXact_GUC(true, save_nestlevel);
 	}
 
-	return retval;
+	return myself;
 }
 
 

src/backend/catalog/pg_type.c

@@ -52,7 +52,7 @@ Oid			binary_upgrade_next_pg_type_oid = InvalidOid;
  *		with correct ones, and "typisdefined" will be set to true.
  * ----------------------------------------------------------------
  */
-Oid
+ObjectAddress
 TypeShellMake(const char *typeName, Oid typeNamespace, Oid ownerId)
 {
 	Relation	pg_type_desc;
@@ -63,6 +63,7 @@ TypeShellMake(const char *typeName, Oid typeNamespace, Oid ownerId)
 	bool		nulls[Natts_pg_type];
 	Oid			typoid;
 	NameData	name;
+	ObjectAddress address;
 
 	Assert(PointerIsValid(typeName));
 
@@ -171,26 +172,28 @@ TypeShellMake(const char *typeName, Oid typeNamespace, Oid ownerId)
 	/* Post creation hook for new shell type */
 	InvokeObjectPostCreateHook(TypeRelationId, typoid, 0);
 
+	ObjectAddressSet(address, TypeRelationId, typoid);
+
 	/*
 	 * clean up and return the type-oid
 	 */
 	heap_freetuple(tup);
 	heap_close(pg_type_desc, RowExclusiveLock);
 
-	return typoid;
+	return address;
 }
 
 /* ----------------------------------------------------------------
  *		TypeCreate
  *
  *		This does all the necessary work needed to define a new type.
  *
- *		Returns the OID assigned to the new type.  If newTypeOid is
- *		zero (the normal case), a new OID is created; otherwise we
- *		use exactly that OID.
+ *		Returns the ObjectAddress assigned to the new type.
+ *		If newTypeOid is zero (the normal case), a new OID is created;
+ *		otherwise we use exactly that OID.
  * ----------------------------------------------------------------
  */
-Oid
+ObjectAddress
 TypeCreate(Oid newTypeOid,
 		   const char *typeName,
 		   Oid typeNamespace,
@@ -233,6 +236,7 @@ TypeCreate(Oid newTypeOid,
 	NameData	name;
 	int			i;
 	Acl		   *typacl = NULL;
+	ObjectAddress address;
 
 	/*
 	 * We assume that the caller validated the arguments individually, but did
@@ -488,12 +492,14 @@ TypeCreate(Oid newTypeOid,
 	/* Post creation hook for new type */
 	InvokeObjectPostCreateHook(TypeRelationId, typeObjectId, 0);
 
+	ObjectAddressSet(address, TypeRelationId, typeObjectId);
+
 	/*
 	 * finish up
 	 */
 	heap_close(pg_type_desc, RowExclusiveLock);
 
-	return typeObjectId;
+	return address;
 }
 
 /*

src/backend/catalog/toasting.c

@@ -289,7 +289,8 @@ create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid,
 										   reloptions,
 										   false,
 										   true,
-										   true);
+										   true,
+										   NULL);
 	Assert(toast_relid != InvalidOid);
 
 	/* make the toast relation visible, else heap_open will fail */

src/backend/commands/aggregatecmds.c

@@ -51,7 +51,7 @@
  * isn't an ordered-set aggregate.
  * "parameters" is a list of DefElem representing the agg's definition clauses.
  */
-Oid
+ObjectAddress
 DefineAggregate(List *name, List *args, bool oldstyle, List *parameters,
 				const char *queryString)
 {