src/backend/commands/alter.c - hawq - Git at Google

 /*-------------------------------------------------------------------------
  *
  * alter.c
  *	  Drivers for generic alter commands
  *
  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
  *	  $PostgreSQL: pgsql/src/backend/commands/alter.c,v 1.20 2006/07/14 14:52:18 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"

 #include "catalog/namespace.h"
 #include "commands/alter.h"
 #include "commands/conversioncmds.h"
 #include "commands/dbcommands.h"
 #include "commands/defrem.h"
 #include "commands/extprotocolcmds.h"
 #include "commands/filespace.h"
 #include "commands/filesystemcmds.h"
 #include "commands/proclang.h"
 #include "commands/schemacmds.h"
 #include "commands/tablecmds.h"
 #include "commands/tablespace.h"
 #include "commands/trigger.h"
 #include "commands/typecmds.h"
 #include "commands/user.h"
 #include "miscadmin.h"
 #include "parser/parse_clause.h"
 #include "tcop/utility.h"
 #include "utils/acl.h"
 #include "utils/lsyscache.h"

 #include "cdb/cdbvars.h"
 #include "cdb/cdbdisp.h"


 /*
  * Executes an ALTER OBJECT / RENAME TO statement.	Based on the object
  * type, the function appropriate to that type is executed.
  */
 void
 ExecRenameStmt(RenameStmt *stmt)
 {
 	switch (stmt->renameType)
 	{
 		case OBJECT_AGGREGATE:
 			RenameAggregate(stmt->object, stmt->objarg, stmt->newname);
 			break;

 		case OBJECT_CONVERSION:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 					(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename conversion statement yet") ));
 			}
 			RenameConversion(stmt->object, stmt->newname);
 			break;

 		case OBJECT_DATABASE:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename database statement yet") ));
 			}
 			RenameDatabase(stmt->subname, stmt->newname);
 			break;

 		case OBJECT_EXTPROTOCOL:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename protocol statement yet") ));
 			}
 			RenameExtProtocol(stmt->subname, stmt->newname);
 			break;

 		case OBJECT_FUNCTION:
 			RenameFunction(stmt->object, stmt->objarg, stmt->newname);
 			break;

 		case OBJECT_LANGUAGE:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename language statement yet") ));
 			}
 			RenameLanguage(stmt->subname, stmt->newname);
 			break;

 		case OBJECT_OPCLASS:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename operator class statement yet") ));
 			}
 			RenameOpClass(stmt->object, stmt->subname, stmt->newname);
 			break;

 		case OBJECT_ROLE:
 			RenameRole(stmt->subname, stmt->newname);
 			break;

 		case OBJECT_SCHEMA:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename schema statement yet") ));
 			}
 			RenameSchema(stmt->subname, stmt->newname);
 			break;

 		case OBJECT_TABLESPACE:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename tablespace statement yet") ));
 			}
 			RenameTableSpace(stmt->subname, stmt->newname);
 			break;

 		case OBJECT_FILESPACE:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename filespace statement yet") ));
 			}
 			RenameFileSpace(stmt->subname, stmt->newname);
 			break;

 		case OBJECT_FILESYSTEM:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename filesystem statement yet") ));
 			}
 			RenameFileSystem(stmt->subname, stmt->newname);
 			break;

 		case OBJECT_INDEX:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename index statement yet") ));
 			}

 		case OBJECT_TABLE:
 		{
 			stmt->objid = RangeVarGetRelid(stmt->relation, false, false /*allowHcatalog*/);
 			CheckRelationOwnership(stmt->objid, true);

 			/*
 			 * RENAME TABLE requires that we (still) hold
 			 * CREATE rights on the containing namespace, as
 			 * well as ownership of the table.
 			 */
 			Oid			namespaceId = get_rel_namespace(stmt->objid);
 			AclResult	aclresult;

 			aclresult = pg_namespace_aclcheck(namespaceId,
 											  GetUserId(),
 											  ACL_CREATE);
 			if (aclresult != ACLCHECK_OK)
 				aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
 							   get_namespace_name(namespaceId));

 			renamerel(stmt->objid, stmt->newname, stmt);
 			break;
 		}

 		case OBJECT_TRIGGER:
 			if (!gp_called_by_pgdump)
 			{
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename trigger statement yet") ));
 			}

 		case OBJECT_COLUMN:
 			{
 				Oid			relid;

 				relid = RangeVarGetRelid(stmt->relation, false, false /*allowHcatalog*/);
 				CheckRelationOwnership(relid, true);

 				switch (stmt->renameType)
 				{
 					case OBJECT_COLUMN:
 						renameatt(relid,
 								  stmt->subname,		/* old att name */
 								  stmt->newname,		/* new att name */
 								  interpretInhOption(stmt->relation->inhOpt),	/* recursive? */
 								  false);		/* recursing already? */
 						break;
 					case OBJECT_TRIGGER:
 						renametrig(relid,
 								   stmt->subname,		/* old att name */
 								   stmt->newname);		/* new att name */
 						break;
 					default:
 						 /* can't happen */ ;
 				}
 				break;
 			}

 		default:
 			elog(ERROR, "unrecognized rename stmt type: %d",
 				 (int) stmt->renameType);
 	}
 }

 /*
  * Executes an ALTER OBJECT / SET SCHEMA statement.  Based on the object
  * type, the function appropriate to that type is executed.
  */
 void
 ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt)
 {
 	switch (stmt->objectType)
 	{
 		case OBJECT_AGGREGATE:
 			AlterFunctionNamespace(stmt->object, stmt->objarg, true,
 								   stmt->newschema);
 			break;

 		case OBJECT_FUNCTION:
 			AlterFunctionNamespace(stmt->object, stmt->objarg, false,
 								   stmt->newschema);
 			break;

 		case OBJECT_SEQUENCE:
 			ereport(ERROR,
 			                            (errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter sequence schema statement yet") ));
 		case OBJECT_TABLE:
 			AlterTableNamespace(stmt->relation, stmt->newschema);
 			break;

 		case OBJECT_TYPE:
 		  /* Permissions are checked inside the function. */
 			AlterTypeNamespace(stmt->object, stmt->newschema);
 			break;

 		case OBJECT_DOMAIN:
 			ereport(ERROR,
                             (errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter domain schema statement yet") ));
 			AlterTypeNamespace(stmt->object, stmt->newschema);
 			break;

 		default:
 			elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
 				 (int) stmt->objectType);
 	}
 }

 /*
  * Executes an ALTER OBJECT / OWNER TO statement.  Based on the object
  * type, the function appropriate to that type is executed.
  */
 void
 ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
 {
 	Oid			newowner = get_roleid_checked(stmt->newowner);

 	switch (stmt->objectType)
 	{
 		case OBJECT_AGGREGATE:
 			AlterAggregateOwner(stmt->object, stmt->objarg, newowner);
 			break;

 		case OBJECT_CONVERSION:
 			if (!gp_called_by_pgdump)
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter conversion owner statement yet") ));
 			AlterConversionOwner(stmt->object, newowner);
 			break;

 		case OBJECT_DATABASE:
 			if (!gp_called_by_pgdump)
 							ereport(ERROR,
 									(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter database owner statement yet") ));
 			AlterDatabaseOwner(strVal(linitial(stmt->object)), newowner);
 			break;

 		case OBJECT_FUNCTION:
 			AlterFunctionOwner(stmt->object, stmt->objarg, newowner);
 			break;

 		case OBJECT_OPERATOR:
 			Assert(list_length(stmt->objarg) == 2);
 			AlterOperatorOwner(stmt->object,
 							   (TypeName *) linitial(stmt->objarg),
 							   (TypeName *) lsecond(stmt->objarg),
 							   newowner);
 			break;

 		case OBJECT_OPCLASS:
 			if (!gp_called_by_pgdump)
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter operator class owner statement yet") ));
 			AlterOpClassOwner(stmt->object, stmt->addname, newowner);
 			break;

 		case OBJECT_SCHEMA:
 			if (!gp_called_by_pgdump)
 							ereport(ERROR,
 									(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter schema owner statement yet") ));
 			AlterSchemaOwner(strVal(linitial(stmt->object)), newowner);
 			break;

 		case OBJECT_TABLESPACE:
 			if (!gp_called_by_pgdump)
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter tablespace owner statement yet") ));
 			AlterTableSpaceOwner(strVal(linitial(stmt->object)), newowner);
 			break;

 		case OBJECT_FILESPACE:
 			if (!gp_called_by_pgdump)
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter filespace owner statement yet") ));
 			AlterFileSpaceOwner(stmt->object, newowner);
 			break;

 		case OBJECT_TYPE:
 		case OBJECT_DOMAIN:		/* same as TYPE */
 			if (!gp_called_by_pgdump)
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter type owner statement yet") ));
 			AlterTypeOwner(stmt->object, newowner);
 			break;

 		case OBJECT_FDW:
 			if (!gp_called_by_pgdump)
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter foreign data wrapper owner statement yet") ));
 			AlterForeignDataWrapperOwner(strVal(linitial(stmt->object)),
 										 newowner);
 			break;

 		case OBJECT_FOREIGN_SERVER:
 			if (!gp_called_by_pgdump)
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter foreign server owner statement yet") ));
 			AlterForeignServerOwner(strVal(linitial(stmt->object)), newowner);
 			break;

 		case OBJECT_EXTPROTOCOL:
 			if (!gp_called_by_pgdump)
 				ereport(ERROR,
 						(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter external protocol owner statement yet") ));
 			AlterExtProtocolOwner(strVal(linitial(stmt->object)), newowner);
 			break;

 		default:
 			elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
 				 (int) stmt->objectType);
 	}
 }
	/*-------------------------------------------------------------------------
	*
	* alter.c
	* Drivers for generic alter commands
	*
	* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
	* Portions Copyright (c) 1994, Regents of the University of California
	*
	*
	* IDENTIFICATION
	* $PostgreSQL: pgsql/src/backend/commands/alter.c,v 1.20 2006/07/14 14:52:18 momjian Exp $
	*
	*-------------------------------------------------------------------------
	*/
	#include "postgres.h"

	#include "catalog/namespace.h"
	#include "commands/alter.h"
	#include "commands/conversioncmds.h"
	#include "commands/dbcommands.h"
	#include "commands/defrem.h"
	#include "commands/extprotocolcmds.h"
	#include "commands/filespace.h"
	#include "commands/filesystemcmds.h"
	#include "commands/proclang.h"
	#include "commands/schemacmds.h"
	#include "commands/tablecmds.h"
	#include "commands/tablespace.h"
	#include "commands/trigger.h"
	#include "commands/typecmds.h"
	#include "commands/user.h"
	#include "miscadmin.h"
	#include "parser/parse_clause.h"
	#include "tcop/utility.h"
	#include "utils/acl.h"
	#include "utils/lsyscache.h"

	#include "cdb/cdbvars.h"
	#include "cdb/cdbdisp.h"


	/*
	* Executes an ALTER OBJECT / RENAME TO statement. Based on the object
	* type, the function appropriate to that type is executed.
	*/
	void
	ExecRenameStmt(RenameStmt *stmt)
	{
	switch (stmt->renameType)
	{
	case OBJECT_AGGREGATE:
	RenameAggregate(stmt->object, stmt->objarg, stmt->newname);
	break;

	case OBJECT_CONVERSION:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename conversion statement yet") ));
	}
	RenameConversion(stmt->object, stmt->newname);
	break;

	case OBJECT_DATABASE:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename database statement yet") ));
	}
	RenameDatabase(stmt->subname, stmt->newname);
	break;

	case OBJECT_EXTPROTOCOL:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename protocol statement yet") ));
	}
	RenameExtProtocol(stmt->subname, stmt->newname);
	break;

	case OBJECT_FUNCTION:
	RenameFunction(stmt->object, stmt->objarg, stmt->newname);
	break;

	case OBJECT_LANGUAGE:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename language statement yet") ));
	}
	RenameLanguage(stmt->subname, stmt->newname);
	break;

	case OBJECT_OPCLASS:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename operator class statement yet") ));
	}
	RenameOpClass(stmt->object, stmt->subname, stmt->newname);
	break;

	case OBJECT_ROLE:
	RenameRole(stmt->subname, stmt->newname);
	break;

	case OBJECT_SCHEMA:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename schema statement yet") ));
	}
	RenameSchema(stmt->subname, stmt->newname);
	break;

	case OBJECT_TABLESPACE:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename tablespace statement yet") ));
	}
	RenameTableSpace(stmt->subname, stmt->newname);
	break;

	case OBJECT_FILESPACE:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename filespace statement yet") ));
	}
	RenameFileSpace(stmt->subname, stmt->newname);
	break;

	case OBJECT_FILESYSTEM:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename filesystem statement yet") ));
	}
	RenameFileSystem(stmt->subname, stmt->newname);
	break;

	case OBJECT_INDEX:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename index statement yet") ));
	}

	case OBJECT_TABLE:
	{
	stmt->objid = RangeVarGetRelid(stmt->relation, false, false /allowHcatalog/);
	CheckRelationOwnership(stmt->objid, true);

	/*
	* RENAME TABLE requires that we (still) hold
	* CREATE rights on the containing namespace, as
	* well as ownership of the table.
	*/
	Oid namespaceId = get_rel_namespace(stmt->objid);
	AclResult aclresult;

	aclresult = pg_namespace_aclcheck(namespaceId,
	GetUserId(),
	ACL_CREATE);
	if (aclresult != ACLCHECK_OK)
	aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
	get_namespace_name(namespaceId));

	renamerel(stmt->objid, stmt->newname, stmt);
	break;
	}

	case OBJECT_TRIGGER:
	if (!gp_called_by_pgdump)
	{
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support rename trigger statement yet") ));
	}

	case OBJECT_COLUMN:
	{
	Oid relid;

	relid = RangeVarGetRelid(stmt->relation, false, false /allowHcatalog/);
	CheckRelationOwnership(relid, true);

	switch (stmt->renameType)
	{
	case OBJECT_COLUMN:
	renameatt(relid,
	stmt->subname, /* old att name */
	stmt->newname, /* new att name */
	interpretInhOption(stmt->relation->inhOpt), /* recursive? */
	false); /* recursing already? */
	break;
	case OBJECT_TRIGGER:
	renametrig(relid,
	stmt->subname, /* old att name */
	stmt->newname); /* new att name */
	break;
	default:
	/* can't happen */ ;
	}
	break;
	}

	default:
	elog(ERROR, "unrecognized rename stmt type: %d",
	(int) stmt->renameType);
	}
	}

	/*
	* Executes an ALTER OBJECT / SET SCHEMA statement. Based on the object
	* type, the function appropriate to that type is executed.
	*/
	void
	ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt)
	{
	switch (stmt->objectType)
	{
	case OBJECT_AGGREGATE:
	AlterFunctionNamespace(stmt->object, stmt->objarg, true,
	stmt->newschema);
	break;

	case OBJECT_FUNCTION:
	AlterFunctionNamespace(stmt->object, stmt->objarg, false,
	stmt->newschema);
	break;

	case OBJECT_SEQUENCE:
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter sequence schema statement yet") ));
	case OBJECT_TABLE:
	AlterTableNamespace(stmt->relation, stmt->newschema);
	break;

	case OBJECT_TYPE:
	/* Permissions are checked inside the function. */
	AlterTypeNamespace(stmt->object, stmt->newschema);
	break;

	case OBJECT_DOMAIN:
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter domain schema statement yet") ));
	AlterTypeNamespace(stmt->object, stmt->newschema);
	break;

	default:
	elog(ERROR, "unrecognized AlterObjectSchemaStmt type: %d",
	(int) stmt->objectType);
	}
	}

	/*
	* Executes an ALTER OBJECT / OWNER TO statement. Based on the object
	* type, the function appropriate to that type is executed.
	*/
	void
	ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
	{
	Oid newowner = get_roleid_checked(stmt->newowner);

	switch (stmt->objectType)
	{
	case OBJECT_AGGREGATE:
	AlterAggregateOwner(stmt->object, stmt->objarg, newowner);
	break;

	case OBJECT_CONVERSION:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter conversion owner statement yet") ));
	AlterConversionOwner(stmt->object, newowner);
	break;

	case OBJECT_DATABASE:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter database owner statement yet") ));
	AlterDatabaseOwner(strVal(linitial(stmt->object)), newowner);
	break;

	case OBJECT_FUNCTION:
	AlterFunctionOwner(stmt->object, stmt->objarg, newowner);
	break;

	case OBJECT_OPERATOR:
	Assert(list_length(stmt->objarg) == 2);
	AlterOperatorOwner(stmt->object,
	(TypeName *) linitial(stmt->objarg),
	(TypeName *) lsecond(stmt->objarg),
	newowner);
	break;

	case OBJECT_OPCLASS:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter operator class owner statement yet") ));
	AlterOpClassOwner(stmt->object, stmt->addname, newowner);
	break;

	case OBJECT_SCHEMA:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter schema owner statement yet") ));
	AlterSchemaOwner(strVal(linitial(stmt->object)), newowner);
	break;

	case OBJECT_TABLESPACE:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter tablespace owner statement yet") ));
	AlterTableSpaceOwner(strVal(linitial(stmt->object)), newowner);
	break;

	case OBJECT_FILESPACE:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter filespace owner statement yet") ));
	AlterFileSpaceOwner(stmt->object, newowner);
	break;

	case OBJECT_TYPE:
	case OBJECT_DOMAIN: /* same as TYPE */
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter type owner statement yet") ));
	AlterTypeOwner(stmt->object, newowner);
	break;

	case OBJECT_FDW:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter foreign data wrapper owner statement yet") ));
	AlterForeignDataWrapperOwner(strVal(linitial(stmt->object)),
	newowner);
	break;

	case OBJECT_FOREIGN_SERVER:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter foreign server owner statement yet") ));
	AlterForeignServerOwner(strVal(linitial(stmt->object)), newowner);
	break;

	case OBJECT_EXTPROTOCOL:
	if (!gp_called_by_pgdump)
	ereport(ERROR,
	(errcode(ERRCODE_CDB_FEATURE_NOT_YET), errmsg("Cannot support alter external protocol owner statement yet") ));
	AlterExtProtocolOwner(strVal(linitial(stmt->object)), newowner);
	break;

	default:
	elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
	(int) stmt->objectType);
	}
	}