Adjust many backend functions to return OID rather than void.

Extracted from a larger patch by Dimitri Fontaine.  It is hoped that
this will provide infrastructure for enriching the new event trigger
functionality, but it seems possibly useful for other purposes as
well.

Author: robertmhaas

src/backend/catalog/pg_aggregate.c

@@ -42,7 +42,7 @@ static Oid lookup_agg_function(List *fnName, int nargs, Oid *input_types,
 /*
  * AggregateCreate
  */
-void
+Oid
 AggregateCreate(const char *aggName,
 				Oid aggNamespace,
 				Oid *aggArgTypes,
@@ -316,6 +316,8 @@ AggregateCreate(const char *aggName,
 		referenced.objectSubId = 0;
 		recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 	}
+
+	return procOid;
 }
 
 /*

src/backend/catalog/pg_operator.c

@@ -326,7 +326,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.
  */
-void
+Oid
 OperatorCreate(const char *operatorName,
 			   Oid operatorNamespace,
 			   Oid leftTypeId,
@@ -565,6 +565,8 @@ OperatorCreate(const char *operatorName,
 
 	if (OidIsValid(commutatorId) || OidIsValid(negatorId))
 		OperatorUpd(operatorObjectId, commutatorId, negatorId);
+
+	return operatorObjectId;
 }
 
 /*

src/backend/commands/aggregatecmds.c

@@ -46,7 +46,7 @@
  * is specified by a BASETYPE element in the parameters.  Otherwise,
  * "args" defines the input type(s).
  */
-void
+Oid
 DefineAggregate(List *name, List *args, bool oldstyle, List *parameters)
 {
 	char	   *aggName;
@@ -216,23 +216,23 @@ DefineAggregate(List *name, List *args, bool oldstyle, List *parameters)
 	/*
 	 * Most of the argument-checking is done inside of AggregateCreate
 	 */
-	AggregateCreate(aggName,	/* aggregate name */
-					aggNamespace,		/* namespace */
-					aggArgTypes,	/* input data type(s) */
-					numArgs,
-					transfuncName,		/* step function name */
-					finalfuncName,		/* final function name */
-					sortoperatorName,	/* sort operator name */
-					transTypeId,	/* transition data type */
-					initval);	/* initial condition */
+	return AggregateCreate(aggName,	/* aggregate name */
+						   aggNamespace,		/* namespace */
+						   aggArgTypes,	/* input data type(s) */
+						   numArgs,
+						   transfuncName,		/* step function name */
+						   finalfuncName,		/* final function name */
+						   sortoperatorName,	/* sort operator name */
+						   transTypeId,	/* transition data type */
+						   initval);	/* initial condition */
 }
 
 
 /*
  * RenameAggregate
  *		Rename an aggregate.
  */
-void
+Oid
 RenameAggregate(List *name, List *args, const char *newname)
 {
 	Oid			procOid;
@@ -286,4 +286,6 @@ RenameAggregate(List *name, List *args, const char *newname)
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return procOid;
 }

src/backend/commands/alter.c

@@ -50,153 +50,126 @@
  * Executes an ALTER OBJECT / RENAME TO statement.	Based on the object
  * type, the function appropriate to that type is executed.
  */
-void
+Oid
 ExecRenameStmt(RenameStmt *stmt)
 {
 	switch (stmt->renameType)
 	{
 		case OBJECT_AGGREGATE:
-			RenameAggregate(stmt->object, stmt->objarg, stmt->newname);
-			break;
+			return RenameAggregate(stmt->object, stmt->objarg, stmt->newname);
 
 		case OBJECT_COLLATION:
-			RenameCollation(stmt->object, stmt->newname);
-			break;
+			return RenameCollation(stmt->object, stmt->newname);
 
 		case OBJECT_CONSTRAINT:
-			RenameConstraint(stmt);
-			break;
+			return RenameConstraint(stmt);
 
 		case OBJECT_CONVERSION:
-			RenameConversion(stmt->object, stmt->newname);
-			break;
+			return RenameConversion(stmt->object, stmt->newname);
 
 		case OBJECT_DATABASE:
-			RenameDatabase(stmt->subname, stmt->newname);
-			break;
+			return RenameDatabase(stmt->subname, stmt->newname);
 
 		case OBJECT_FDW:
-			RenameForeignDataWrapper(stmt->subname, stmt->newname);
-			break;
+			return RenameForeignDataWrapper(stmt->subname, stmt->newname);
 
 		case OBJECT_FOREIGN_SERVER:
-			RenameForeignServer(stmt->subname, stmt->newname);
-			break;
+			return RenameForeignServer(stmt->subname, stmt->newname);
 
 		case OBJECT_EVENT_TRIGGER:
-			RenameEventTrigger(stmt->subname, stmt->newname);
-			break;
+			return RenameEventTrigger(stmt->subname, stmt->newname);
 
 		case OBJECT_FUNCTION:
-			RenameFunction(stmt->object, stmt->objarg, stmt->newname);
-			break;
+			return RenameFunction(stmt->object, stmt->objarg, stmt->newname);
 
 		case OBJECT_LANGUAGE:
-			RenameLanguage(stmt->subname, stmt->newname);
-			break;
+			return RenameLanguage(stmt->subname, stmt->newname);
 
 		case OBJECT_OPCLASS:
-			RenameOpClass(stmt->object, stmt->subname, stmt->newname);
-			break;
+			return RenameOpClass(stmt->object, stmt->subname, stmt->newname);
 
 		case OBJECT_OPFAMILY:
-			RenameOpFamily(stmt->object, stmt->subname, stmt->newname);
-			break;
+			return RenameOpFamily(stmt->object, stmt->subname, stmt->newname);
 
 		case OBJECT_ROLE:
-			RenameRole(stmt->subname, stmt->newname);
-			break;
+			return RenameRole(stmt->subname, stmt->newname);
 
 		case OBJECT_SCHEMA:
-			RenameSchema(stmt->subname, stmt->newname);
-			break;
+			return RenameSchema(stmt->subname, stmt->newname);
 
 		case OBJECT_TABLESPACE:
-			RenameTableSpace(stmt->subname, stmt->newname);
-			break;
+			return RenameTableSpace(stmt->subname, stmt->newname);
 
 		case OBJECT_TABLE:
 		case OBJECT_SEQUENCE:
 		case OBJECT_VIEW:
 		case OBJECT_INDEX:
 		case OBJECT_FOREIGN_TABLE:
-			RenameRelation(stmt);
-			break;
+			return RenameRelation(stmt);
 
 		case OBJECT_COLUMN:
 		case OBJECT_ATTRIBUTE:
-			renameatt(stmt);
-			break;
+			return renameatt(stmt);
 
 		case OBJECT_TRIGGER:
-			renametrig(stmt);
-			break;
+			return renametrig(stmt);
 
 		case OBJECT_TSPARSER:
-			RenameTSParser(stmt->object, stmt->newname);
-			break;
+			return RenameTSParser(stmt->object, stmt->newname);
 
 		case OBJECT_TSDICTIONARY:
-			RenameTSDictionary(stmt->object, stmt->newname);
-			break;
+			return RenameTSDictionary(stmt->object, stmt->newname);
 
 		case OBJECT_TSTEMPLATE:
-			RenameTSTemplate(stmt->object, stmt->newname);
-			break;
+			return RenameTSTemplate(stmt->object, stmt->newname);
 
 		case OBJECT_TSCONFIGURATION:
-			RenameTSConfiguration(stmt->object, stmt->newname);
-			break;
+			return RenameTSConfiguration(stmt->object, stmt->newname);
 
 		case OBJECT_DOMAIN:
 		case OBJECT_TYPE:
-			RenameType(stmt);
-			break;
+			return RenameType(stmt);
 
 		default:
 			elog(ERROR, "unrecognized rename stmt type: %d",
 				 (int) stmt->renameType);
+			return InvalidOid;			/* keep compiler happy */
 	}
 }
 
 /*
  * Executes an ALTER OBJECT / SET SCHEMA statement.  Based on the object
  * type, the function appropriate to that type is executed.
  */
-void
+Oid
 ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt)
 {
 	switch (stmt->objectType)
 	{
 		case OBJECT_AGGREGATE:
-			AlterFunctionNamespace(stmt->object, stmt->objarg, true,
-								   stmt->newschema);
-			break;
+			return AlterFunctionNamespace(stmt->object, stmt->objarg, true,
+										  stmt->newschema);
 
 		case OBJECT_COLLATION:
-			AlterCollationNamespace(stmt->object, stmt->newschema);
-			break;
+			return AlterCollationNamespace(stmt->object, stmt->newschema);
 
 		case OBJECT_EXTENSION:
-			AlterExtensionNamespace(stmt->object, stmt->newschema);
-			break;
+			return AlterExtensionNamespace(stmt->object, stmt->newschema);
 
 		case OBJECT_FUNCTION:
-			AlterFunctionNamespace(stmt->object, stmt->objarg, false,
-								   stmt->newschema);
-			break;
+			return AlterFunctionNamespace(stmt->object, stmt->objarg, false,
+										  stmt->newschema);
 
 		case OBJECT_SEQUENCE:
 		case OBJECT_TABLE:
 		case OBJECT_VIEW:
 		case OBJECT_FOREIGN_TABLE:
-			AlterTableNamespace(stmt);
-			break;
+			return AlterTableNamespace(stmt);
 
 		case OBJECT_TYPE:
 		case OBJECT_DOMAIN:
-			AlterTypeNamespace(stmt->object, stmt->newschema, stmt->objectType);
-			break;
+			return AlterTypeNamespace(stmt->object, stmt->newschema,
+									  stmt->objectType);
 
 			/* generic code path */
 		case OBJECT_CONVERSION:
@@ -228,12 +201,15 @@ ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt)
 				AlterObjectNamespace_internal(catalog, address.objectId,
 											  nspOid);
 				heap_close(catalog, RowExclusiveLock);
+
+				return address.objectId;
 			}
 			break;
 
 		default:
 			elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
 				 (int) stmt->objectType);
+			return InvalidOid;	/* keep compiler happy */
 	}
 }
 
@@ -435,38 +411,35 @@ AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid)
  * Executes an ALTER OBJECT / OWNER TO statement.  Based on the object
  * type, the function appropriate to that type is executed.
  */
-void
+Oid
 ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
 {
 	Oid			newowner = get_role_oid(stmt->newowner, false);
 
 	switch (stmt->objectType)
 	{
 		case OBJECT_DATABASE:
-			AlterDatabaseOwner(strVal(linitial(stmt->object)), newowner);
-			break;
+			return AlterDatabaseOwner(strVal(linitial(stmt->object)), newowner);
 
 		case OBJECT_SCHEMA:
-			AlterSchemaOwner(strVal(linitial(stmt->object)), newowner);
-			break;
+			return AlterSchemaOwner(strVal(linitial(stmt->object)), newowner);
 
 		case OBJECT_TYPE:
 		case OBJECT_DOMAIN:		/* same as TYPE */
-			AlterTypeOwner(stmt->object, newowner, stmt->objectType);
+			return AlterTypeOwner(stmt->object, newowner, stmt->objectType);
 			break;
 
 		case OBJECT_FDW:
-			AlterForeignDataWrapperOwner(strVal(linitial(stmt->object)),
-										 newowner);
-			break;
+			return AlterForeignDataWrapperOwner(strVal(linitial(stmt->object)),
+												newowner);
 
 		case OBJECT_FOREIGN_SERVER:
-			AlterForeignServerOwner(strVal(linitial(stmt->object)), newowner);
-			break;
+			return AlterForeignServerOwner(strVal(linitial(stmt->object)),
+										   newowner);
 
 		case OBJECT_EVENT_TRIGGER:
-			AlterEventTriggerOwner(strVal(linitial(stmt->object)), newowner);
-			break;
+			return AlterEventTriggerOwner(strVal(linitial(stmt->object)),
+										  newowner);
 
 		/* Generic cases */
 		case OBJECT_AGGREGATE:
@@ -508,12 +481,16 @@ ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
 
 				AlterObjectOwner_internal(catalog, address.objectId, newowner);
 				heap_close(catalog, RowExclusiveLock);
+
+				return address.objectId;
 			}
 			break;
 
 		default:
 			elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
 				 (int) stmt->objectType);
+
+			return InvalidOid;	/* keep compiler happy */
 	}
 }