Anonymous avatar Anonymous committed c504513

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.

Comments (0)

Files changed (39)

src/backend/catalog/pg_aggregate.c

 /*
  * AggregateCreate
  */
-void
+Oid
 AggregateCreate(const char *aggName,
 				Oid aggNamespace,
 				Oid *aggArgTypes,
 		referenced.objectSubId = 0;
 		recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 	}
+
+	return procOid;
 }
 
 /*

src/backend/catalog/pg_operator.c

  * 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,
 
 	if (OidIsValid(commutatorId) || OidIsValid(negatorId))
 		OperatorUpd(operatorObjectId, commutatorId, negatorId);
+
+	return operatorObjectId;
 }
 
 /*

src/backend/commands/aggregatecmds.c

  * 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;
 	/*
 	 * 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;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return procOid;
 }

src/backend/commands/alter.c

  * 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:
 				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 */
 	}
 }
 
  * 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:
 
 				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 */
 	}
 }
 

src/backend/commands/collationcmds.c

 /*
  * CREATE COLLATION
  */
-void
+Oid
 DefineCollation(List *names, List *parameters)
 {
 	char	   *collName;
 	/* check that the locales can be loaded */
 	CommandCounterIncrement();
 	(void) pg_newlocale_from_collation(newoid);
+
+	return newoid;
 }
 
 /*
  * Rename collation
  */
-void
+Oid
 RenameCollation(List *name, const char *newname)
 {
 	Oid			collationOid;
 	heap_freetuple(tup);
 
 	heap_close(rel, RowExclusiveLock);
+
+	return collationOid;
 }
 
 /*
  * Execute ALTER COLLATION SET SCHEMA
  */
-void
+Oid
 AlterCollationNamespace(List *name, const char *newschema)
 {
 	Oid			collOid,
 	nspOid = LookupCreationNamespace(newschema);
 
 	AlterCollationNamespace_oid(collOid, nspOid);
+
+	return collOid;
 }
 
 /*

src/backend/commands/conversioncmds.c

 /*
  * CREATE CONVERSION
  */
-void
+Oid
 CreateConversionCommand(CreateConversionStmt *stmt)
 {
 	Oid			namespaceId;
 	 * All seem ok, go ahead (possible failure would be a duplicate conversion
 	 * name)
 	 */
-	ConversionCreate(conversion_name, namespaceId, GetUserId(),
-					 from_encoding, to_encoding, funcoid, stmt->def);
+	return ConversionCreate(conversion_name, namespaceId, GetUserId(),
+							from_encoding, to_encoding, funcoid, stmt->def);
 }
 
 /*
  * Rename conversion
  */
-void
+Oid
 RenameConversion(List *name, const char *newname)
 {
 	Oid			conversionOid;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return conversionOid;
 }

src/backend/commands/dbcommands.c

 /*
  * Rename database
  */
-void
+Oid
 RenameDatabase(const char *oldname, const char *newname)
 {
 	Oid			db_id;
 	 * Close pg_database, but keep lock till commit.
 	 */
 	heap_close(rel, NoLock);
+
+	return db_id;
 }
 
 
 /*
  * ALTER DATABASE name OWNER TO newowner
  */
-void
+Oid
 AlterDatabaseOwner(const char *dbname, Oid newOwnerId)
 {
+	Oid			db_id;
 	HeapTuple	tuple;
 	Relation	rel;
 	ScanKeyData scankey;
 				(errcode(ERRCODE_UNDEFINED_DATABASE),
 				 errmsg("database \"%s\" does not exist", dbname)));
 
+	db_id = HeapTupleGetOid(tuple);
 	datForm = (Form_pg_database) GETSTRUCT(tuple);
 
 	/*
 
 	/* Close pg_database, but keep lock till commit */
 	heap_close(rel, NoLock);
+
+	return db_id;
 }
 
 

src/backend/commands/event_trigger.c

 /*
  * Rename event trigger
  */
-void
+Oid
 RenameEventTrigger(const char *trigname, const char *newname)
 {
+	Oid			evtId;
 	HeapTuple	tup;
 	Relation	rel;
 	Form_pg_event_trigger evtForm;
 		aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_EVENT_TRIGGER,
 					   trigname);
 
+	evtId = HeapTupleGetOid(tup);
+
 	evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);
 
 	/* tuple is a copy, so we can rename it now */
 
 	heap_freetuple(tup);
 	heap_close(rel, RowExclusiveLock);
+
+	return evtId;
 }
 
 
 /*
  * Change event trigger's owner -- by name
  */
-void
+Oid
 AlterEventTriggerOwner(const char *name, Oid newOwnerId)
 {
+	Oid			evtOid;
 	HeapTuple	tup;
 	Relation	rel;
 
 				(errcode(ERRCODE_UNDEFINED_OBJECT),
 				 errmsg("event trigger \"%s\" does not exist", name)));
 
+	evtOid = HeapTupleGetOid(tup);
+
 	AlterEventTriggerOwner_internal(rel, tup, newOwnerId);
 
 	heap_freetuple(tup);
 
 	heap_close(rel, RowExclusiveLock);
+
+	return evtOid;
 }
 
 /*

src/backend/commands/extension.c

 /*
  * CREATE EXTENSION
  */
-void
+Oid
 CreateExtension(CreateExtensionStmt *stmt)
 {
 	DefElem    *d_schema = NULL;
 					(errcode(ERRCODE_DUPLICATE_OBJECT),
 					 errmsg("extension \"%s\" already exists, skipping",
 							stmt->extname)));
-			return;
+			return InvalidOid;
 		}
 		else
 			ereport(ERROR,
 	 */
 	ApplyExtensionUpdates(extensionOid, pcontrol,
 						  versionName, updateVersions);
+
+	return extensionOid;
 }
 
 /*
 /*
  * Execute ALTER EXTENSION SET SCHEMA
  */
-void
+Oid
 AlterExtensionNamespace(List *names, const char *newschema)
 {
 	char	   *extensionName;
 	if (extForm->extnamespace == nspOid)
 	{
 		heap_close(extRel, RowExclusiveLock);
-		return;
+		return InvalidOid;
 	}
 
 	/* Check extension is supposed to be relocatable */
 	/* update dependencies to point to the new schema */
 	changeDependencyFor(ExtensionRelationId, extensionOid,
 						NamespaceRelationId, oldNspOid, nspOid);
+
+	return extensionOid;
 }
 
 /*

src/backend/commands/foreigncmds.c

 /*
  * Rename foreign-data wrapper
  */
-void
+Oid
 RenameForeignDataWrapper(const char *oldname, const char *newname)
 {
+	Oid			fdwId;
 	HeapTuple	tup;
 	Relation	rel;
 
 				(errcode(ERRCODE_UNDEFINED_OBJECT),
 			 errmsg("foreign-data wrapper \"%s\" does not exist", oldname)));
 
+	fdwId = HeapTupleGetOid(tup);
+
 	/* make sure the new name doesn't exist */
 	if (SearchSysCacheExists1(FOREIGNDATAWRAPPERNAME, CStringGetDatum(newname)))
 		ereport(ERROR,
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return fdwId;
 }
 
 
 /*
  * Rename foreign server
  */
-void
+Oid
 RenameForeignServer(const char *oldname, const char *newname)
 {
+	Oid			srvId;
 	HeapTuple	tup;
 	Relation	rel;
 
 				(errcode(ERRCODE_UNDEFINED_OBJECT),
 				 errmsg("server \"%s\" does not exist", oldname)));
 
+	srvId = HeapTupleGetOid(tup);
+
 	/* make sure the new name doesn't exist */
 	if (SearchSysCacheExists1(FOREIGNSERVERNAME, CStringGetDatum(newname)))
 		ereport(ERROR,
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return srvId;
 }
 
 
  *
  * Note restrictions in the "_internal" function, above.
  */
-void
+Oid
 AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId)
 {
+	Oid			fdwId;
 	HeapTuple	tup;
 	Relation	rel;
 
 				(errcode(ERRCODE_UNDEFINED_OBJECT),
 				 errmsg("foreign-data wrapper \"%s\" does not exist", name)));
 
+	fdwId = HeapTupleGetOid(tup);
+
 	AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);
 
 	heap_freetuple(tup);
 
 	heap_close(rel, RowExclusiveLock);
+
+	return fdwId;
 }
 
 /*
 /*
  * Change foreign server owner -- by name
  */
-void
+Oid
 AlterForeignServerOwner(const char *name, Oid newOwnerId)
 {
+	Oid			servOid;
 	HeapTuple	tup;
 	Relation	rel;
 
 				(errcode(ERRCODE_UNDEFINED_OBJECT),
 				 errmsg("server \"%s\" does not exist", name)));
 
+	servOid = HeapTupleGetOid(tup);
+
 	AlterForeignServerOwner_internal(rel, tup, newOwnerId);
 
 	heap_freetuple(tup);
 
 	heap_close(rel, RowExclusiveLock);
+
+	return servOid;
 }
 
 /*

src/backend/commands/functioncmds.c

  * CreateFunction
  *	 Execute a CREATE FUNCTION utility statement.
  */
-void
+Oid
 CreateFunction(CreateFunctionStmt *stmt, const char *queryString)
 {
 	char	   *probin_str;
 	 * And now that we have all the parameters, and know we're permitted to do
 	 * so, go ahead and create the function.
 	 */
-	ProcedureCreate(funcname,
-					namespaceId,
-					stmt->replace,
-					returnsSet,
-					prorettype,
-					GetUserId(),
-					languageOid,
-					languageValidator,
-					prosrc_str, /* converted to text later */
-					probin_str, /* converted to text later */
-					false,		/* not an aggregate */
-					isWindowFunc,
-					security,
-					isLeakProof,
-					isStrict,
-					volatility,
-					parameterTypes,
-					PointerGetDatum(allParameterTypes),
-					PointerGetDatum(parameterModes),
-					PointerGetDatum(parameterNames),
-					parameterDefaults,
-					PointerGetDatum(proconfig),
-					procost,
-					prorows);
+	return ProcedureCreate(funcname,
+						   namespaceId,
+						   stmt->replace,
+						   returnsSet,
+						   prorettype,
+						   GetUserId(),
+						   languageOid,
+						   languageValidator,
+						   prosrc_str, /* converted to text later */
+						   probin_str, /* converted to text later */
+						   false,		/* not an aggregate */
+						   isWindowFunc,
+						   security,
+						   isLeakProof,
+						   isStrict,
+						   volatility,
+						   parameterTypes,
+						   PointerGetDatum(allParameterTypes),
+						   PointerGetDatum(parameterModes),
+						   PointerGetDatum(parameterNames),
+						   parameterDefaults,
+						   PointerGetDatum(proconfig),
+						   procost,
+						   prorows);
 }
 
 
 /*
  * Rename function
  */
-void
+Oid
 RenameFunction(List *name, List *argtypes, const char *newname)
 {
 	Oid			procOid;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return procOid;
 }
 
 /*
  *
  * These commands are identical except for the lookup procedure, so share code.
  */
-void
+Oid
 AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
 					   const char *newschema)
 {
 	nspOid = LookupCreationNamespace(newschema);
 
 	AlterFunctionNamespace_oid(procOid, nspOid);
+
+	return procOid;
 }
 
 Oid

src/backend/commands/opclasscmds.c

 /*
  * Rename opclass
  */
-void
+Oid
 RenameOpClass(List *name, const char *access_method, const char *newname)
 {
 	Oid			opcOid;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return opcOid;
 }
 
 /*
  * Rename opfamily
  */
-void
+Oid
 RenameOpFamily(List *name, const char *access_method, const char *newname)
 {
 	Oid			opfOid;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return opfOid;
 }
 
 /*

src/backend/commands/operatorcmds.c

  *
  * 'parameters' is a list of DefElem
  */
-void
+Oid
 DefineOperator(List *names, List *parameters)
 {
 	char	   *oprName;
 	/*
 	 * now have OperatorCreate do all the work..
 	 */
-	OperatorCreate(oprName,		/* operator name */
-				   oprNamespace,	/* namespace */
-				   typeId1,		/* left type id */
-				   typeId2,		/* right type id */
-				   functionOid, /* function for operator */
-				   commutatorName,		/* optional commutator operator name */
-				   negatorName, /* optional negator operator name */
-				   restrictionOid,		/* optional restrict. sel. procedure */
-				   joinOid,		/* optional join sel. procedure name */
-				   canMerge,	/* operator merges */
-				   canHash);	/* operator hashes */
+	return
+		OperatorCreate(oprName,		/* operator name */
+					   oprNamespace,	/* namespace */
+					   typeId1,		/* left type id */
+					   typeId2,		/* right type id */
+					   functionOid, /* function for operator */
+					   commutatorName,		/* optional commutator operator name */
+					   negatorName, /* optional negator operator name */
+					   restrictionOid,		/* optional restrict. sel. procedure */
+					   joinOid,		/* optional join sel. procedure name */
+					   canMerge,	/* operator merges */
+					   canHash);	/* operator hashes */
 }
 
-
 /*
  * Guts of operator deletion.
  */

src/backend/commands/proclang.c

 /*
  * Rename language
  */
-void
+Oid
 RenameLanguage(const char *oldname, const char *newname)
 {
+	Oid			lanId;
 	HeapTuple	tup;
 	Relation	rel;
 
 				(errcode(ERRCODE_UNDEFINED_OBJECT),
 				 errmsg("language \"%s\" does not exist", oldname)));
 
+	lanId = HeapTupleGetOid(tup);
+
 	/* make sure the new name doesn't exist */
 	if (SearchSysCacheExists1(LANGNAME, CStringGetDatum(newname)))
 		ereport(ERROR,
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return lanId;
 }
 
 /*

src/backend/commands/schemacmds.c

 /*
  * CREATE SCHEMA
  */
-void
+Oid
 CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString)
 {
 	const char *schemaName = stmt->schemaname;
 				(errcode(ERRCODE_DUPLICATE_SCHEMA),
 				 errmsg("schema \"%s\" already exists, skipping",
 						schemaName)));
-		return;
+		return InvalidOid;
 	}
 
 	/*
 
 	/* Reset current user and security context */
 	SetUserIdAndSecContext(saved_uid, save_sec_context);
+
+	return namespaceId;
 }
 
 /*
 /*
  * Rename schema
  */
-void
+Oid
 RenameSchema(const char *oldname, const char *newname)
 {
+	Oid			nspOid;
 	HeapTuple	tup;
 	Relation	rel;
 	AclResult	aclresult;
 				(errcode(ERRCODE_UNDEFINED_SCHEMA),
 				 errmsg("schema \"%s\" does not exist", oldname)));
 
+	nspOid = HeapTupleGetOid(tup);
+
 	/* make sure the new name doesn't exist */
 	if (OidIsValid(get_namespace_oid(newname, true)))
 		ereport(ERROR,
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return nspOid;
 }
 
 void
 /*
  * Change schema owner
  */
-void
+Oid
 AlterSchemaOwner(const char *name, Oid newOwnerId)
 {
+	Oid			nspOid;
 	HeapTuple	tup;
 	Relation	rel;
 
 				(errcode(ERRCODE_UNDEFINED_SCHEMA),
 				 errmsg("schema \"%s\" does not exist", name)));
 
+	nspOid = HeapTupleGetOid(tup);
+
 	AlterSchemaOwner_internal(tup, rel, newOwnerId);
 
 	ReleaseSysCache(tup);
 
 	heap_close(rel, RowExclusiveLock);
+
+	return nspOid;
 }
 
 static void

src/backend/commands/sequence.c

  * DefineSequence
  *				Creates a new sequence relation
  */
-void
+Oid
 DefineSequence(CreateSeqStmt *seq)
 {
 	FormData_pg_sequence new;
 		process_owned_by(rel, owned_by);
 
 	heap_close(rel, NoLock);
+
+	return seqoid;
 }
 
 /*
  *
  * Modify the definition of a sequence relation
  */
-void
+Oid
 AlterSequence(AlterSeqStmt *stmt)
 {
 	Oid			relid;
 		ereport(NOTICE,
 				(errmsg("relation \"%s\" does not exist, skipping",
 						stmt->sequence->relname)));
-		return;
+		return InvalidOid;
 	}
 
 	init_sequence(relid, &elm, &seqrel);
 		process_owned_by(seqrel, owned_by);
 
 	relation_close(seqrel, NoLock);
+
+	return relid;
 }
 
 

src/backend/commands/tablecmds.c

 	Relation	targetrelation;
 	Relation	attrelation;
 	HeapTuple	atttup;
-	Form_pg_attribute attform;
+	Form_pg_attribute	attform;
 	int			attnum;
 
 	/*
 /*
  *		renameatt		- changes the name of a attribute in a relation
  */
-void
+Oid
 renameatt(RenameStmt *stmt)
 {
 	Oid			relid;
 		ereport(NOTICE,
 				(errmsg("relation \"%s\" does not exist, skipping",
 						stmt->relation->relname)));
-		return;
+		return InvalidOid;
 	}
 
 	renameatt_internal(relid,
 					   false,	/* recursing? */
 					   0,		/* expected inhcount */
 					   stmt->behavior);
+
+	/* This is an ALTER TABLE command so it's about the relid */
+	return relid;
 }
 
 
 /*
  * same logic as renameatt_internal
  */
-static void
+static Oid
 rename_constraint_internal(Oid myrelid,
 						   Oid mytypid,
 						   const char *oldconname,
 
 	if (targetrelation)
 		relation_close(targetrelation, NoLock); /* close rel but keep lock */
+
+	return constraintOid;
 }
 
-void
+Oid
 RenameConstraint(RenameStmt *stmt)
 {
 	Oid			relid = InvalidOid;
 										 NULL);
 	}
 
-	rename_constraint_internal(relid, typid,
-							   stmt->subname,
-							   stmt->newname,
-		 stmt->relation ? interpretInhOption(stmt->relation->inhOpt) : false,	/* recursive? */
-							   false,	/* recursing? */
-							   0 /* expected inhcount */ );
+	return
+		rename_constraint_internal(relid, typid,
+								   stmt->subname,
+								   stmt->newname,
+								   stmt->relation ? interpretInhOption(stmt->relation->inhOpt) : false,	/* recursive? */
+								   false,	/* recursing? */
+								   0 /* expected inhcount */ );
+
 }
 
 /*
  * Execute ALTER TABLE/INDEX/SEQUENCE/VIEW/FOREIGN TABLE RENAME
  */
-void
+Oid
 RenameRelation(RenameStmt *stmt)
 {
 	Oid			relid;
 		ereport(NOTICE,
 				(errmsg("relation \"%s\" does not exist, skipping",
 						stmt->relation->relname)));
-		return;
+		return InvalidOid;
 	}
 
 	/* Do the work */
 	RenameRelationInternal(relid, stmt->newname);
+
+	return relid;
 }
 
 /*
 /*
  * Execute ALTER TABLE SET SCHEMA
  */
-void
+Oid
 AlterTableNamespace(AlterObjectSchemaStmt *stmt)
 {
 	Relation	rel;
 		ereport(NOTICE,
 				(errmsg("relation \"%s\" does not exist, skipping",
 						stmt->relation->relname)));
-		return;
+		return InvalidOid;
 	}
 
 	rel = relation_open(relid, NoLock);
 
 	/* close rel, but keep lock until commit */
 	relation_close(rel, NoLock);
+
+	return relid;
 }
 
 /*

src/backend/commands/tablespace.c

 /*
  * Rename a tablespace
  */
-void
+Oid
 RenameTableSpace(const char *oldname, const char *newname)
 {
+	Oid			tspId;
 	Relation	rel;
 	ScanKeyData entry[1];
 	HeapScanDesc scan;
 				 errmsg("tablespace \"%s\" does not exist",
 						oldname)));
 
+	tspId = HeapTupleGetOid(tup);
 	newtuple = heap_copytuple(tup);
 	newform = (Form_pg_tablespace) GETSTRUCT(newtuple);
 
 	CatalogUpdateIndexes(rel, newtuple);
 
 	heap_close(rel, NoLock);
+
+	return tspId;
 }
 
 /*

src/backend/commands/trigger.c

  *		modify tgname in trigger tuple
  *		update row in catalog
  */
-void
+Oid
 renametrig(RenameStmt *stmt)
 {
+	Oid			tgoid;
 	Relation	targetrel;
 	Relation	tgrel;
 	HeapTuple	tuple;
 								SnapshotNow, 2, key);
 	if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
 	{
+		tgoid = HeapTupleGetOid(tuple);
 		/*
 		 * Update pg_trigger tuple with new tgname.
 		 */
 	 * Close rel, but keep exclusive lock!
 	 */
 	relation_close(targetrel, NoLock);
+
+	return tgoid;
 }
 
 

src/backend/commands/tsearchcmds.c

 /*
  * CREATE TEXT SEARCH PARSER
  */
-void
+Oid
 DefineTSParser(List *names, List *parameters)
 {
 	char	   *prsname;
 	heap_freetuple(tup);
 
 	heap_close(prsRel, RowExclusiveLock);
+
+	return prsOid;
 }
 
 /*
 /*
  * ALTER TEXT SEARCH PARSER RENAME
  */
-void
+Oid
 RenameTSParser(List *oldname, const char *newname)
 {
 	HeapTuple	tup;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return prsId;
 }
 
 /* ---------------------- TS Dictionary commands -----------------------*/
 /*
  * CREATE TEXT SEARCH DICTIONARY
  */
-void
+Oid
 DefineTSDictionary(List *names, List *parameters)
 {
 	ListCell   *pl;
 	heap_freetuple(tup);
 
 	heap_close(dictRel, RowExclusiveLock);
+
+	return dictOid;
 }
 
 /*
  * ALTER TEXT SEARCH DICTIONARY RENAME
  */
-void
+Oid
 RenameTSDictionary(List *oldname, const char *newname)
 {
 	HeapTuple	tup;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return dictId;
 }
 
 /*
 /*
  * CREATE TEXT SEARCH TEMPLATE
  */
-void
+Oid
 DefineTSTemplate(List *names, List *parameters)
 {
 	ListCell   *pl;
 	bool		nulls[Natts_pg_ts_template];
 	NameData	dname;
 	int			i;
-	Oid			dictOid;
+	Oid			tmplOid;
 	Oid			namespaceoid;
 	char	   *tmplname;
 
 
 	tup = heap_form_tuple(tmplRel->rd_att, values, nulls);
 
-	dictOid = simple_heap_insert(tmplRel, tup);
+	tmplOid = simple_heap_insert(tmplRel, tup);
 
 	CatalogUpdateIndexes(tmplRel, tup);
 
 
 	/* Post creation hook for new text search template */
 	InvokeObjectAccessHook(OAT_POST_CREATE,
-						   TSTemplateRelationId, dictOid, 0, NULL);
+						   TSTemplateRelationId, tmplOid, 0, NULL);
 
 	heap_freetuple(tup);
 
 	heap_close(tmplRel, RowExclusiveLock);
+
+	return tmplOid;
 }
 
 /*
  * ALTER TEXT SEARCH TEMPLATE RENAME
  */
-void
+Oid
 RenameTSTemplate(List *oldname, const char *newname)
 {
 	HeapTuple	tup;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return tmplId;
 }
 
 /*
 /*
  * CREATE TEXT SEARCH CONFIGURATION
  */
-void
+Oid
 DefineTSConfiguration(List *names, List *parameters)
 {
 	Relation	cfgRel;
 	if (mapRel)
 		heap_close(mapRel, RowExclusiveLock);
 	heap_close(cfgRel, RowExclusiveLock);
+
+	return cfgOid;
 }
 
 /*
  * ALTER TEXT SEARCH CONFIGURATION RENAME
  */
-void
+Oid
 RenameTSConfiguration(List *oldname, const char *newname)
 {
 	HeapTuple	tup;
 
 	heap_close(rel, NoLock);
 	heap_freetuple(tup);
+
+	return cfgId;
 }
 
 /*

src/backend/commands/typecmds.c

  * DefineType
  *		Registers a new base type.
  */
-void
+Oid
 DefineType(List *names, List *parameters)
 {
 	char	   *typeName;
 		 * creating the shell type was all we're supposed to do.
 		 */
 		if (parameters == NIL)
-			return;
+			return InvalidOid;
 	}
 	else
 	{
 	/* alignment must be 'i' or 'd' for arrays */
 	alignment = (alignment == 'd') ? 'd' : 'i';
 
-	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 */
+	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 */
 
 	pfree(array_type);
+
+	return typoid;
 }
 
 /*
  * DefineDomain
  *		Registers a new domain.
  */
-void
+Oid
 DefineDomain(CreateDomainStmt *stmt)
 {
 	char	   *domainName;
 	 * Now we can clean up.
 	 */
 	ReleaseSysCache(typeTup);
+
+	return domainoid;
 }
 
 
 /*
  * Execute ALTER TYPE RENAME
  */
-void
+Oid
 RenameType(RenameStmt *stmt)
 {
 	List	   *names = stmt->object;
 
 	/* Clean up */
 	heap_close(rel, RowExclusiveLock);
+
+	return typeOid;
 }
 
 /*
  * Change the owner of a type.
  */
-void
+Oid
 AlterTypeOwner(List *names, Oid newOwnerId, ObjectType objecttype)
 {
 	TypeName   *typename;
 
 	/* Clean up */
 	heap_close(rel, RowExclusiveLock);
+
+	return typeOid;
 }
 
 /*
 /*
  * Execute ALTER TYPE SET SCHEMA
  */
-void
+Oid
 AlterTypeNamespace(List *names, const char *newschema, ObjectType objecttype)
 {
 	TypeName   *typename;
 	objsMoved = new_object_addresses();
 	AlterTypeNamespace_oid(typeOid, nspOid, objsMoved);
 	free_object_addresses(objsMoved);
+
+	return typeOid;
 }
 
 Oid

src/backend/commands/user.c

 /*
  * Rename role
  */
-void
+Oid
 RenameRole(const char *oldname, const char *newname)
 {
 	HeapTuple	oldtuple,
 	 * Close pg_authid, but keep lock till commit.
 	 */
 	heap_close(rel, NoLock);
+
+	return roleid;
 }
 
 /*

src/backend/commands/view.c

  * DefineView
  *		Execute a CREATE VIEW command.
  */
-void
+Oid
 DefineView(ViewStmt *stmt, const char *queryString)
 {
 	Query	   *viewParse;
 	 * Now create the rules associated with the view.
 	 */
 	DefineViewRules(viewOid, viewParse, stmt->replace);
+
+	return viewOid;
 }

src/include/catalog/pg_operator.h

 /*
  * function prototypes
  */
-extern void OperatorCreate(const char *operatorName,
+extern Oid OperatorCreate(const char *operatorName,
 			   Oid operatorNamespace,
 			   Oid leftTypeId,
 			   Oid rightTypeId,

src/include/commands/alter.h

 #include "nodes/parsenodes.h"
 #include "utils/relcache.h"
 
-extern void ExecRenameStmt(RenameStmt *stmt);
+extern Oid ExecRenameStmt(RenameStmt *stmt);
 
-extern void ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt);
+extern Oid ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt);
 extern Oid	AlterObjectNamespace_oid(Oid classId, Oid objid, Oid nspOid,
 						 ObjectAddresses *objsMoved);
 extern Oid	AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid);
 
-extern void ExecAlterOwnerStmt(AlterOwnerStmt *stmt);
+extern Oid ExecAlterOwnerStmt(AlterOwnerStmt *stmt);
 extern void AlterObjectOwner_internal(Relation catalog, Oid objectId,
 						  Oid new_ownerId);
 

src/include/commands/collationcmds.h

 
 #include "nodes/parsenodes.h"
 
-extern void DefineCollation(List *names, List *parameters);
-extern void RenameCollation(List *name, const char *newname);
-extern void AlterCollationNamespace(List *name, const char *newschema);
+extern Oid DefineCollation(List *names, List *parameters);
+extern Oid RenameCollation(List *name, const char *newname);
+extern Oid AlterCollationNamespace(List *name, const char *newschema);
 extern Oid	AlterCollationNamespace_oid(Oid collOid, Oid newNspOid);
 
 #endif   /* COLLATIONCMDS_H */

src/include/commands/conversioncmds.h

 
 #include "nodes/parsenodes.h"
 
-extern void CreateConversionCommand(CreateConversionStmt *parsetree);
-extern void RenameConversion(List *name, const char *newname);
+extern Oid CreateConversionCommand(CreateConversionStmt *parsetree);
+extern Oid RenameConversion(List *name, const char *newname);
 
 #endif   /* CONVERSIONCMDS_H */

src/include/commands/dbcommands.h

 
 extern void createdb(const CreatedbStmt *stmt);
 extern void dropdb(const char *dbname, bool missing_ok);
-extern void RenameDatabase(const char *oldname, const char *newname);
+extern Oid RenameDatabase(const char *oldname, const char *newname);
 extern void AlterDatabase(AlterDatabaseStmt *stmt, bool isTopLevel);
 extern void AlterDatabaseSet(AlterDatabaseSetStmt *stmt);
-extern void AlterDatabaseOwner(const char *dbname, Oid newOwnerId);
+extern Oid AlterDatabaseOwner(const char *dbname, Oid newOwnerId);
 
 extern Oid	get_database_oid(const char *dbname, bool missingok);
 extern char *get_database_name(Oid dbid);

src/include/commands/defrem.h

 extern Oid	GetDefaultOpClass(Oid type_id, Oid am_id);
 
 /* commands/functioncmds.c */
-extern void CreateFunction(CreateFunctionStmt *stmt, const char *queryString);
+extern Oid CreateFunction(CreateFunctionStmt *stmt, const char *queryString);
 extern void RemoveFunctionById(Oid funcOid);
 extern void SetFunctionReturnType(Oid funcOid, Oid newRetType);
 extern void SetFunctionArgType(Oid funcOid, int argIndex, Oid newArgType);
-extern void RenameFunction(List *name, List *argtypes, const char *newname);
+extern Oid RenameFunction(List *name, List *argtypes, const char *newname);
 extern void AlterFunction(AlterFunctionStmt *stmt);
 extern void CreateCast(CreateCastStmt *stmt);
 extern void DropCastById(Oid castOid);
-extern void AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
-					   const char *newschema);
+extern Oid AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
+								  const char *newschema);
 extern Oid	AlterFunctionNamespace_oid(Oid procOid, Oid nspOid);
 extern void ExecuteDoStmt(DoStmt *stmt);
 extern Oid	get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok);
 
 /* commands/operatorcmds.c */
-extern void DefineOperator(List *names, List *parameters);
+extern Oid DefineOperator(List *names, List *parameters);
 extern void RemoveOperatorById(Oid operOid);
 
 /* commands/aggregatecmds.c */
-extern void DefineAggregate(List *name, List *args, bool oldstyle,
+extern Oid DefineAggregate(List *name, List *args, bool oldstyle,
 				List *parameters);
-extern void RenameAggregate(List *name, List *args, const char *newname);
+extern Oid RenameAggregate(List *name, List *args, const char *newname);
 
 /* commands/opclasscmds.c */
 extern void DefineOpClass(CreateOpClassStmt *stmt);
 extern void RemoveOpFamilyById(Oid opfamilyOid);
 extern void RemoveAmOpEntryById(Oid entryOid);
 extern void RemoveAmProcEntryById(Oid entryOid);
-extern void RenameOpClass(List *name, const char *access_method, const char *newname);
-extern void RenameOpFamily(List *name, const char *access_method, const char *newname);
+extern Oid RenameOpClass(List *name, const char *access_method, const char *newname);
+extern Oid RenameOpFamily(List *name, const char *access_method, const char *newname);
 extern Oid	get_am_oid(const char *amname, bool missing_ok);
 extern Oid	get_opclass_oid(Oid amID, List *opclassname, bool missing_ok);
 extern Oid	get_opfamily_oid(Oid amID, List *opfamilyname, bool missing_ok);
 
 /* commands/tsearchcmds.c */
-extern void DefineTSParser(List *names, List *parameters);
-extern void RenameTSParser(List *oldname, const char *newname);
+extern Oid DefineTSParser(List *names, List *parameters);
+extern Oid RenameTSParser(List *oldname, const char *newname);
 extern void RemoveTSParserById(Oid prsId);
 
-extern void DefineTSDictionary(List *names, List *parameters);
-extern void RenameTSDictionary(List *oldname, const char *newname);
+extern Oid DefineTSDictionary(List *names, List *parameters);
+extern Oid RenameTSDictionary(List *oldname, const char *newname);
 extern void RemoveTSDictionaryById(Oid dictId);
 extern void AlterTSDictionary(AlterTSDictionaryStmt *stmt);
 
-extern void DefineTSTemplate(List *names, List *parameters);
-extern void RenameTSTemplate(List *oldname, const char *newname);
+extern Oid DefineTSTemplate(List *names, List *parameters);
+extern Oid RenameTSTemplate(List *oldname, const char *newname);
 extern void RemoveTSTemplateById(Oid tmplId);
 
-extern void DefineTSConfiguration(List *names, List *parameters);
-extern void RenameTSConfiguration(List *oldname, const char *newname);
+extern Oid DefineTSConfiguration(List *names, List *parameters);
+extern Oid RenameTSConfiguration(List *oldname, const char *newname);
 extern void RemoveTSConfigurationById(Oid cfgId);
 extern void AlterTSConfiguration(AlterTSConfigurationStmt *stmt);
 
 extern List *deserialize_deflist(Datum txt);
 
 /* commands/foreigncmds.c */
-extern void RenameForeignServer(const char *oldname, const char *newname);
-extern void RenameForeignDataWrapper(const char *oldname, const char *newname);
-extern void AlterForeignServerOwner(const char *name, Oid newOwnerId);
+extern Oid RenameForeignServer(const char *oldname, const char *newname);
+extern Oid RenameForeignDataWrapper(const char *oldname, const char *newname);
+extern Oid AlterForeignServerOwner(const char *name, Oid newOwnerId);
 extern void AlterForeignServerOwner_oid(Oid, Oid newOwnerId);
-extern void AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId);
+extern Oid AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId);
 extern void AlterForeignDataWrapperOwner_oid(Oid fwdId, Oid newOwnerId);
 extern void CreateForeignDataWrapper(CreateFdwStmt *stmt);
 extern void AlterForeignDataWrapper(AlterFdwStmt *stmt);

src/include/commands/extension.h

 extern Oid	CurrentExtensionObject;
 
 
-extern void CreateExtension(CreateExtensionStmt *stmt);
+extern Oid CreateExtension(CreateExtensionStmt *stmt);
 
 extern void RemoveExtensionById(Oid extId);
 
 extern Oid	get_extension_oid(const char *extname, bool missing_ok);
 extern char *get_extension_name(Oid ext_oid);
 
-extern void AlterExtensionNamespace(List *names, const char *newschema);
+extern Oid AlterExtensionNamespace(List *names, const char *newschema);
 
 extern void AlterExtensionOwner_oid(Oid extensionOid, Oid newOwnerId);
 

src/include/commands/proclang.h

 
 extern void CreateProceduralLanguage(CreatePLangStmt *stmt);
 extern void DropProceduralLanguageById(Oid langOid);
-extern void RenameLanguage(const char *oldname, const char *newname);
+extern Oid RenameLanguage(const char *oldname, const char *newname);
 extern bool PLTemplateExists(const char *languageName);
 extern Oid	get_language_oid(const char *langname, bool missing_ok);
 

src/include/commands/schemacmds.h

 
 #include "nodes/parsenodes.h"
 
-extern void CreateSchemaCommand(CreateSchemaStmt *parsetree,
+extern Oid CreateSchemaCommand(CreateSchemaStmt *parsetree,
 					const char *queryString);
 
 extern void RemoveSchemaById(Oid schemaOid);
 
-extern void RenameSchema(const char *oldname, const char *newname);
-extern void AlterSchemaOwner(const char *name, Oid newOwnerId);
+extern Oid RenameSchema(const char *oldname, const char *newname);
+extern Oid AlterSchemaOwner(const char *name, Oid newOwnerId);
 extern void AlterSchemaOwner_oid(Oid schemaOid, Oid newOwnerId);
 
 #endif   /* SCHEMACMDS_H */

src/include/commands/sequence.h

 
 extern Datum pg_sequence_parameters(PG_FUNCTION_ARGS);
 
-extern void DefineSequence(CreateSeqStmt *stmt);
-extern void AlterSequence(AlterSeqStmt *stmt);
+extern Oid DefineSequence(CreateSeqStmt *stmt);
+extern Oid AlterSequence(AlterSeqStmt *stmt);
 extern void ResetSequence(Oid seq_relid);
 
 extern void seq_redo(XLogRecPtr lsn, XLogRecord *rptr);

src/include/commands/tablecmds.h

 
 extern void SetRelationHasSubclass(Oid relationId, bool relhassubclass);
 
-extern void renameatt(RenameStmt *stmt);
+extern Oid renameatt(RenameStmt *stmt);
 
-extern void RenameConstraint(RenameStmt *stmt);
+extern Oid RenameConstraint(RenameStmt *stmt);
 
-extern void RenameRelation(RenameStmt *stmt);
+extern Oid RenameRelation(RenameStmt *stmt);
 
 extern void RenameRelationInternal(Oid myrelid,
 					   const char *newrelname);

src/include/commands/tablespace.h

 
 extern void CreateTableSpace(CreateTableSpaceStmt *stmt);
 extern void DropTableSpace(DropTableSpaceStmt *stmt);
-extern void RenameTableSpace(const char *oldname, const char *newname);
+extern Oid RenameTableSpace(const char *oldname, const char *newname);
 extern void AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt);
 
 extern void TablespaceCreateDbspace(Oid spcNode, Oid dbNode, bool isRedo);

src/include/commands/trigger.h

 extern void RemoveTriggerById(Oid trigOid);
 extern Oid	get_trigger_oid(Oid relid, const char *name, bool missing_ok);
 
-extern void renametrig(RenameStmt *stmt);
+extern Oid renametrig(RenameStmt *stmt);
 
 extern void EnableDisableTrigger(Relation rel, const char *tgname,
 					 char fires_when, bool skip_system);

src/include/commands/typecmds.h

 
 #define DEFAULT_TYPDELIM		','
 
-extern void DefineType(List *names, List *parameters);
+extern Oid DefineType(List *names, List *parameters);
 extern void RemoveTypeById(Oid typeOid);
-extern void DefineDomain(CreateDomainStmt *stmt);
+extern Oid DefineDomain(CreateDomainStmt *stmt);
 extern void DefineEnum(CreateEnumStmt *stmt);
 extern void DefineRange(CreateRangeStmt *stmt);
 extern void AlterEnum(AlterEnumStmt *stmt, bool isTopLevel);
 
 extern List *GetDomainConstraints(Oid typeOid);
 
-extern void RenameType(RenameStmt *stmt);
-extern void AlterTypeOwner(List *names, Oid newOwnerId, ObjectType objecttype);
+extern Oid RenameType(RenameStmt *stmt);
+extern Oid AlterTypeOwner(List *names, Oid newOwnerId, ObjectType objecttype);
 extern void AlterTypeOwnerInternal(Oid typeOid, Oid newOwnerId,
 					   bool hasDependEntry);
-extern void AlterTypeNamespace(List *names, const char *newschema, ObjectType objecttype);
+extern Oid AlterTypeNamespace(List *names, const char *newschema, ObjectType objecttype);
 extern Oid	AlterTypeNamespace_oid(Oid typeOid, Oid nspOid, ObjectAddresses *objsMoved);
 extern Oid	AlterTypeNamespaceInternal(Oid typeOid, Oid nspOid,
 						   bool isImplicitArray,

src/include/commands/user.h

 extern void AlterRoleSet(AlterRoleSetStmt *stmt);
 extern void DropRole(DropRoleStmt *stmt);
 extern void GrantRole(GrantRoleStmt *stmt);
-extern void RenameRole(const char *oldname, const char *newname);
+extern Oid RenameRole(const char *oldname, const char *newname);
 extern void DropOwnedObjects(DropOwnedStmt *stmt);
 extern void ReassignOwnedObjects(ReassignOwnedStmt *stmt);
 

src/include/commands/view.h

 
 #include "nodes/parsenodes.h"
 
-extern void DefineView(ViewStmt *stmt, const char *queryString);
+extern Oid DefineView(ViewStmt *stmt, const char *queryString);
 
 #endif   /* VIEW_H */
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.