set_schema.5.patch

*** a/src/backend/catalog/dependency.c
--- b/src/backend/catalog/dependency.c
***************
*** 2706,2711 **** getObjectDescription(const ObjectAddress *object)
--- 2706,2726 ----
  }
  
  /*
+  * getObjectDescriptionOids: as above, except the object is specified by Oids
+  */
+ char *
+ getObjectDescriptionOids(Oid classid, Oid objid)
+ {
+ 	ObjectAddress	address;
+ 
+ 	address.classId = classid;
+ 	address.objectId = objid;
+ 	address.objectSubId = 0;
+ 
+ 	return getObjectDescription(&address);
+ }
+ 
+ /*
   * subroutine for getObjectDescription: describe a relation
   */
  static void
*** a/src/backend/catalog/namespace.c
--- b/src/backend/catalog/namespace.c
***************
*** 2340,2345 **** LookupCreationNamespace(const char *nspname)
--- 2340,2383 ----
  }
  
  /*
+  * Check new namespace validity in ALTER OBJECT ... SET SCHEMA ... and
+  * ereport(ERROR, ...) in case of any problem.
+  */
+ void
+ CheckSetNamespace(Oid oldNspOid, Oid nspOid, Oid classid, Oid objid,
+ 				  const char *name)
+ {
+ 	if (oldNspOid == nspOid)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_DUPLICATE_OBJECT),
+ 				 errmsg("%s already exists in schema \"%s\"",
+ 						getObjectDescriptionOids(classid, objid),
+ 						get_namespace_name(nspOid))));
+ 
+ 	/* disallow renaming into or out of temp schemas */
+ 	if (isAnyTempNamespace(nspOid) || isAnyTempNamespace(oldNspOid))
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 				 errmsg("cannot move objects into or out of temporary schemas")));
+ 
+ 	/* same for TOAST schema */
+ 	if (nspOid == PG_TOAST_NAMESPACE || oldNspOid == PG_TOAST_NAMESPACE)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 				 errmsg("cannot move objects into or out of TOAST schema")));
+ 
+ 	/* check for duplicate name (more friendly than unique-index failure) */
+ 	if (SearchSysCacheExists2(TYPENAMENSP,
+ 							  CStringGetDatum(name),
+ 							  ObjectIdGetDatum(nspOid)))
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_DUPLICATE_OBJECT),
+ 				 errmsg("%s already exists in schema \"%s\"",
+ 						getObjectDescriptionOids(classid, objid),
+ 						get_namespace_name(nspOid))));
+ }
+ 
+ /*
   * QualifiedNameGetCreationNamespace
   *		Given a possibly-qualified name for an object (in List-of-Values
   *		format), determine what namespace the object should be created in.
*** a/src/backend/commands/alter.c
--- b/src/backend/commands/alter.c
***************
*** 182,192 **** ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt)
--- 182,208 ----
  								   stmt->newschema);
  			break;
  
+ 		case OBJECT_CONVERSION:
+ 			AlterConversionNamespace(stmt->object, stmt->newschema);
+ 			break;
+ 
  		case OBJECT_FUNCTION:
  			AlterFunctionNamespace(stmt->object, stmt->objarg, false,
  								   stmt->newschema);
  			break;
  
+ 		case OBJECT_OPERATOR:
+ 			AlterOperatorNamespace(stmt->object, stmt->objarg, stmt->newschema);
+ 			break;
+ 
+ 		case OBJECT_OPCLASS:
+ 			AlterOpClassNamespace(stmt->object, stmt->objarg, stmt->newschema);
+ 			break;
+ 
+ 		case OBJECT_OPFAMILY:
+ 			AlterOpFamilyNamespace(stmt->object, stmt->objarg, stmt->newschema);
+ 			break;
+ 
  		case OBJECT_SEQUENCE:
  		case OBJECT_TABLE:
  		case OBJECT_VIEW:
***************
*** 195,200 **** ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt)
--- 211,232 ----
  								stmt->objectType, AccessExclusiveLock);
  			break;
  
+ 		case OBJECT_TSPARSER:
+ 			AlterTSParserNamespace(stmt->object, stmt->newschema);
+ 			break;
+ 
+ 		case OBJECT_TSDICTIONARY:
+ 			AlterTSDictionaryNamespace(stmt->object, stmt->newschema);
+ 			break;
+ 
+ 		case OBJECT_TSTEMPLATE:
+ 			AlterTSTemplateNamespace(stmt->object, stmt->newschema);
+ 			break;
+ 
+ 		case OBJECT_TSCONFIGURATION:
+ 			AlterTSConfigurationNamespace(stmt->object, stmt->newschema);
+ 			break;
+ 
  		case OBJECT_TYPE:
  		case OBJECT_DOMAIN:
  			AlterTypeNamespace(stmt->object, stmt->newschema);
*** a/src/backend/commands/conversioncmds.c
--- b/src/backend/commands/conversioncmds.c
***************
*** 19,24 ****
--- 19,25 ----
  #include "catalog/indexing.h"
  #include "catalog/pg_conversion.h"
  #include "catalog/pg_conversion_fn.h"
+ #include "catalog/pg_namespace.h"
  #include "catalog/pg_type.h"
  #include "commands/conversioncmds.h"
  #include "mb/pg_wchar.h"
***************
*** 30,37 ****
  #include "utils/rel.h"
  #include "utils/syscache.h"
  
! static void AlterConversionOwner_internal(Relation rel, Oid conversionOid,
  							  Oid newOwnerId);
  
  /*
   * CREATE CONVERSION
--- 31,40 ----
  #include "utils/rel.h"
  #include "utils/syscache.h"
  
! static void AlterConversionOwner_internal(Relation rel, Oid convOid,
  							  Oid newOwnerId);
+ static void AlterConversionNamespace_internal(Relation rel, Oid convOid,
+ 								  Oid nspOid);
  
  /*
   * CREATE CONVERSION
***************
*** 326,328 **** AlterConversionOwner_internal(Relation rel, Oid conversionOid, Oid newOwnerId)
--- 329,414 ----
  
  	heap_freetuple(tup);
  }
+ 
+ /*
+  * Execute ALTER CONVERSION SET SCHEMA
+  */
+ void
+ AlterConversionNamespace(List *name, const char *newschema)
+ {
+ 	Oid			convOid, nspOid;
+ 	Relation	rel;
+ 
+ 	rel = heap_open(ConversionRelationId, RowExclusiveLock);
+ 
+ 	convOid = get_conversion_oid(name, false);
+ 
+ 	/* get schema OID */
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterConversionNamespace_internal(rel, convOid, nspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ /*
+  * Change conversion schema, by oid
+  */
+ void
+ AlterConversionNamespace_oid(Oid convOid, Oid newNspOid)
+ {
+ 	Relation	rel;
+ 
+ 	rel = heap_open(ConversionRelationId, RowExclusiveLock);
+ 
+ 	AlterConversionNamespace_internal(rel, convOid, newNspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ static void
+ AlterConversionNamespace_internal(Relation rel, Oid convOid, Oid nspOid)
+ {
+ 	Oid			oldNspOid;
+ 	HeapTuple	tup;
+ 	Form_pg_conversion convForm;
+ 
+ 	Assert(RelationGetRelid(rel) == ConversionRelationId);
+ 
+ 	tup = SearchSysCacheCopy1(CONVOID, ObjectIdGetDatum(convOid));
+ 	if (!HeapTupleIsValid(tup)) /* should not happen */
+ 		elog(ERROR, "cache lookup failed for conversion %u", convOid);
+ 
+ 	convForm = (Form_pg_conversion) GETSTRUCT(tup);
+ 	oldNspOid = convForm->connamespace;
+ 
+ 	CheckSetNamespace(oldNspOid, nspOid,
+ 					  ConversionRelationId, convOid, NameStr(convForm->conname));
+ 
+ 	/* Superusers can always do it */
+ 	if (!superuser())
+ 	{
+ 		AclResult	aclresult;
+ 
+ 		/* Otherwise, must be owner of the existing object */
+ 		if (!pg_conversion_ownercheck(HeapTupleGetOid(tup), GetUserId()))
+ 			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CONVERSION,
+ 						   NameStr(convForm->conname));
+ 
+ 		/* owner must have CREATE privilege on namespace */
+ 		aclresult = pg_namespace_aclcheck(convForm->connamespace,
+ 										  GetUserId(),
+ 										  ACL_CREATE);
+ 		if (aclresult != ACLCHECK_OK)
+ 			aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
+ 						   get_namespace_name(convForm->connamespace));
+ 	}
+ 
+ 	convForm->connamespace = nspOid;
+ 	simple_heap_update(rel, &tup->t_self, tup);
+ 	CatalogUpdateIndexes(rel, tup);
+ 
+ 	/* update dependencies to point to the new schema */
+ 	changeDependencyFor(ConversionRelationId, convOid,
+ 						NamespaceRelationId, oldNspOid, nspOid);
+ }
*** a/src/backend/commands/functioncmds.c
--- b/src/backend/commands/functioncmds.c
***************
*** 1870,1882 **** AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
  					   const char *newschema)
  {
  	Oid			procOid;
- 	Oid			oldNspOid;
  	Oid			nspOid;
- 	HeapTuple	tup;
- 	Relation	procRel;
- 	Form_pg_proc proc;
- 
- 	procRel = heap_open(ProcedureRelationId, RowExclusiveLock);
  
  	/* get function OID */
  	if (isagg)
--- 1870,1876 ----
***************
*** 1889,1894 **** AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
--- 1883,1903 ----
  		aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_PROC,
  					   NameListToString(name));
  
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterFunctionNamespace_oid(procOid, nspOid);
+ }
+ 
+ void
+ AlterFunctionNamespace_oid(Oid procOid, Oid nspOid)
+ {
+ 	Oid			oldNspOid;
+ 	HeapTuple	tup;
+ 	Relation	procRel;
+ 	Form_pg_proc proc;
+ 
+ 	procRel = heap_open(ProcedureRelationId, RowExclusiveLock);
+ 
  	tup = SearchSysCacheCopy1(PROCOID, ObjectIdGetDatum(procOid));
  	if (!HeapTupleIsValid(tup))
  		elog(ERROR, "cache lookup failed for function %u", procOid);
***************
*** 1896,1910 **** AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
  
  	oldNspOid = proc->pronamespace;
  
- 	/* get schema OID and check its permissions */
- 	nspOid = LookupCreationNamespace(newschema);
- 
  	if (oldNspOid == nspOid)
  		ereport(ERROR,
  				(errcode(ERRCODE_DUPLICATE_FUNCTION),
  				 errmsg("function \"%s\" is already in schema \"%s\"",
! 						NameListToString(name),
! 						newschema)));
  
  	/* disallow renaming into or out of temp schemas */
  	if (isAnyTempNamespace(nspOid) || isAnyTempNamespace(oldNspOid))
--- 1905,1916 ----
  
  	oldNspOid = proc->pronamespace;
  
  	if (oldNspOid == nspOid)
  		ereport(ERROR,
  				(errcode(ERRCODE_DUPLICATE_FUNCTION),
  				 errmsg("function \"%s\" is already in schema \"%s\"",
! 						NameStr(proc->proname),
! 						get_namespace_name(nspOid))));
  
  	/* disallow renaming into or out of temp schemas */
  	if (isAnyTempNamespace(nspOid) || isAnyTempNamespace(oldNspOid))
***************
*** 1927,1933 **** AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
  				(errcode(ERRCODE_DUPLICATE_FUNCTION),
  				 errmsg("function \"%s\" already exists in schema \"%s\"",
  						NameStr(proc->proname),
! 						newschema)));
  
  	/* OK, modify the pg_proc row */
  
--- 1933,1939 ----
  				(errcode(ERRCODE_DUPLICATE_FUNCTION),
  				 errmsg("function \"%s\" already exists in schema \"%s\"",
  						NameStr(proc->proname),
! 						get_namespace_name(nspOid))));
  
  	/* OK, modify the pg_proc row */
  
***************
*** 1941,1947 **** AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
  	if (changeDependencyFor(ProcedureRelationId, procOid,
  							NamespaceRelationId, oldNspOid, nspOid) != 1)
  		elog(ERROR, "failed to change schema dependency for function \"%s\"",
! 			 NameListToString(name));
  
  	heap_freetuple(tup);
  
--- 1947,1953 ----
  	if (changeDependencyFor(ProcedureRelationId, procOid,
  							NamespaceRelationId, oldNspOid, nspOid) != 1)
  		elog(ERROR, "failed to change schema dependency for function \"%s\"",
! 			 NameStr(proc->proname));
  
  	heap_freetuple(tup);
  
*** a/src/backend/commands/opclasscmds.c
--- b/src/backend/commands/opclasscmds.c
***************
*** 81,86 **** static void AlterOpClassOwner_internal(Relation rel, HeapTuple tuple,
--- 81,90 ----
  						   Oid newOwnerId);
  static void AlterOpFamilyOwner_internal(Relation rel, HeapTuple tuple,
  							Oid newOwnerId);
+ static void AlterOpClassNamespace_internal(Relation rel, HeapTuple tup,
+ 			   				   Oid nspOid);
+ extern void AlterOpFamilyNamespace_internal(Relation rel, HeapTuple tup,
+ 								Oid nspOid);
  
  
  /*
***************
*** 1912,1917 **** AlterOpClassOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)
--- 1916,2012 ----
  }
  
  /*
+  * ALTER OPERATOR CLASS any_name USING access_method SET SCHEMA name
+  */
+ void
+ AlterOpClassNamespace(List *name, List *argam, const char *newschema)
+ {
+ 	Oid			amOid;
+ 	char       *access_method = linitial(argam);
+ 	Relation	rel;
+ 	HeapTuple	tup, origtup;
+ 	Oid			nspOid;
+ 
+ 	Assert(list_length(argam) == 1);
+ 
+ 	amOid = get_am_oid(access_method, false);
+ 
+ 	rel = heap_open(OperatorClassRelationId, RowExclusiveLock);
+ 
+ 	/* Look up the opclass. */
+ 	origtup = OpClassCacheLookup(amOid, name, false);
+ 	tup = heap_copytuple(origtup);
+ 	ReleaseSysCache(origtup);
+ 
+ 	/* get schema OID */
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterOpClassNamespace_internal(rel, tup, nspOid);
+ 
+ 	heap_freetuple(tup);
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterOpClassNamespace_oid(Oid opclassOid, Oid newNspOid)
+ {
+ 	HeapTuple	tup;
+ 	Relation	rel;
+ 
+ 	rel = heap_open(OperatorClassRelationId, RowExclusiveLock);
+ 
+ 	tup = SearchSysCacheCopy1(CLAOID, ObjectIdGetDatum(opclassOid));
+ 	if (!HeapTupleIsValid(tup))
+ 		elog(ERROR, "cache lookup failed for opclass %u", opclassOid);
+ 
+ 	AlterOpClassNamespace_internal(rel, tup, newNspOid);
+ 
+ 	heap_freetuple(tup);
+ 	heap_close(rel, NoLock);
+ }
+ 
+ static void
+ AlterOpClassNamespace_internal(Relation rel, HeapTuple tup, Oid nspOid)
+ {
+ 	Oid			oldNspOid;
+ 	Form_pg_opclass opcForm;
+ 
+ 	opcForm = (Form_pg_opclass) GETSTRUCT(tup);
+ 	oldNspOid = opcForm->opcnamespace;
+ 
+ 	CheckSetNamespace(oldNspOid, nspOid,
+ 					  OperatorClassRelationId, HeapTupleGetOid(tup),
+ 					  NameStr(opcForm->opcname));
+ 
+ 	/* Superusers can always do it */
+ 	if (!superuser())
+ 	{
+ 		AclResult	aclresult;
+ 
+ 		/* Otherwise, must be owner of the existing object */
+ 		if (!pg_opclass_ownercheck(HeapTupleGetOid(tup), GetUserId()))
+ 			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPCLASS,
+ 						   NameStr(opcForm->opcname));
+ 
+ 		/* New owner must have CREATE privilege on namespace */
+ 		aclresult = pg_namespace_aclcheck(nspOid, GetUserId(), ACL_CREATE);
+ 		if (aclresult != ACLCHECK_OK)
+ 			aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
+ 						   get_namespace_name(nspOid));
+ 	}
+ 
+ 	/* tup is a copy, so we can scribble directly on it */
+ 	opcForm->opcnamespace = nspOid;
+ 
+ 	simple_heap_update(rel, &tup->t_self, tup);
+ 	CatalogUpdateIndexes(rel, tup);
+ 
+ 	/* update dependencies to point to the new schema */
+ 	changeDependencyFor(OperatorClassRelationId, HeapTupleGetOid(tup),
+ 						NamespaceRelationId, oldNspOid, nspOid);
+ }
+ 
+ /*
   * Change opfamily owner by name
   */
  void
***************
*** 2067,2069 **** get_am_oid(const char *amname, bool missing_ok)
--- 2162,2290 ----
  				 errmsg("access method \"%s\" does not exist", amname)));
  	return oid;
  }
+ 
+ /*
+  * ALTER OPERATOR FAMILY any_name USING access_method SET SCHEMA name
+  */
+ void
+ AlterOpFamilyNamespace(List *name, List *argam, const char *newschema)
+ {
+ 	Oid			amOid;
+ 	char       *access_method = linitial(argam);
+ 	Relation	rel;
+ 	HeapTuple	tup;
+ 	char	   *opfname, *schemaname;
+ 	Oid			nspOid;
+ 
+ 	Assert(list_length(argam) == 1);
+ 	amOid = get_am_oid(access_method, false);
+ 
+ 	rel = heap_open(OperatorFamilyRelationId, RowExclusiveLock);
+ 
+ 	/*
+ 	 * Look up the opfamily
+ 	 */
+ 	DeconstructQualifiedName(name, &schemaname, &opfname);
+ 
+ 	if (schemaname)
+ 	{
+ 		Oid			namespaceOid;
+ 
+ 		namespaceOid = LookupExplicitNamespace(schemaname);
+ 
+ 		tup = SearchSysCacheCopy3(OPFAMILYAMNAMENSP,
+ 								  ObjectIdGetDatum(amOid),
+ 								  PointerGetDatum(opfname),
+ 								  ObjectIdGetDatum(namespaceOid));
+ 		if (!HeapTupleIsValid(tup))
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_UNDEFINED_OBJECT),
+ 					 errmsg("operator family \"%s\" does not exist for access method \"%s\"",
+ 							opfname, access_method)));
+ 	}
+ 	else
+ 	{
+ 		Oid			opfOid;
+ 
+ 		opfOid = OpfamilynameGetOpfid(amOid, opfname);
+ 		if (!OidIsValid(opfOid))
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_UNDEFINED_OBJECT),
+ 					 errmsg("operator family \"%s\" does not exist for access method \"%s\"",
+ 							opfname, access_method)));
+ 
+ 		tup = SearchSysCacheCopy1(OPFAMILYOID, ObjectIdGetDatum(opfOid));
+ 		if (!HeapTupleIsValid(tup))		/* should not happen */
+ 			elog(ERROR, "cache lookup failed for opfamily %u", opfOid);
+ 	}
+ 
+ 	/* get schema OID */
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterOpFamilyNamespace_internal(rel, tup, nspOid);
+ 
+ 	heap_freetuple(tup);
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterOpFamilyNamespace_oid(Oid opfamilyOid, Oid newNspOid)
+ {
+ 	HeapTuple	tup;
+ 	Relation	rel;
+ 
+ 	rel = heap_open(OperatorFamilyRelationId, RowExclusiveLock);
+ 
+ 	tup = SearchSysCacheCopy1(OPFAMILYOID, ObjectIdGetDatum(opfamilyOid));
+ 	if (!HeapTupleIsValid(tup))
+ 		elog(ERROR, "cache lookup failed for opfamily %u", opfamilyOid);
+ 
+ 	AlterOpFamilyNamespace_internal(rel, tup, newNspOid);
+ 
+ 	heap_freetuple(tup);
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterOpFamilyNamespace_internal(Relation rel, HeapTuple tup, Oid nspOid)
+ {
+ 	Oid			oldNspOid;
+ 	Form_pg_opfamily opfForm;
+ 
+ 	Assert(tup->t_tableOid == OperatorFamilyRelationId);
+ 	Assert(RelationGetRelid(rel) == OperatorFamilyRelationId);
+ 
+ 	opfForm = (Form_pg_opfamily) GETSTRUCT(tup);
+ 	oldNspOid = opfForm->opfnamespace;
+ 
+ 	CheckSetNamespace(oldNspOid, nspOid,
+ 					  OperatorFamilyRelationId, HeapTupleGetOid(tup),
+ 					  NameStr(opfForm->opfname));
+ 
+ 	/* Superusers can always do it */
+ 	if (!superuser())
+ 	{
+ 		AclResult	aclresult;
+ 
+ 		/* Otherwise, must be owner of the existing object */
+ 		if (!pg_opfamily_ownercheck(HeapTupleGetOid(tup), GetUserId()))
+ 			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPFAMILY,
+ 						   NameStr(opfForm->opfname));
+ 
+ 		/* owner must have CREATE privilege on namespace */
+ 		aclresult = pg_namespace_aclcheck(nspOid, GetUserId(), ACL_CREATE);
+ 		if (aclresult != ACLCHECK_OK)
+ 			aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
+ 						   get_namespace_name(nspOid));
+ 	}
+ 
+ 	/* tup is a copy, so we can scribble directly on it */
+ 	opfForm->opfnamespace = nspOid;
+ 
+ 	simple_heap_update(rel, &tup->t_self, tup);
+ 	CatalogUpdateIndexes(rel, tup);
+ 
+ 	/* update dependencies to point to the new schema */
+ 	changeDependencyFor(OperatorFamilyRelationId, HeapTupleGetOid(tup),
+ 						NamespaceRelationId, oldNspOid, nspOid);
+ }
*** a/src/backend/commands/operatorcmds.c
--- b/src/backend/commands/operatorcmds.c
***************
*** 39,44 ****
--- 39,45 ----
  #include "catalog/indexing.h"
  #include "catalog/namespace.h"
  #include "catalog/pg_operator.h"
+ #include "catalog/pg_namespace.h"
  #include "catalog/pg_type.h"
  #include "commands/defrem.h"
  #include "miscadmin.h"
***************
*** 52,57 ****
--- 53,59 ----
  
  
  static void AlterOperatorOwner_internal(Relation rel, Oid operOid, Oid newOwnerId);
+ static void AlterOperatorNamespace_internal(Relation rel, Oid operOid, Oid nspOid);
  
  /*
   * DefineOperator
***************
*** 452,454 **** AlterOperatorOwner_internal(Relation rel, Oid operOid, Oid newOwnerId)
--- 454,546 ----
  
  	heap_freetuple(tup);
  }
+ 
+ /*
+  * Execute ALTER OPERATOR SET SCHEMA
+  */
+ void
+ AlterOperatorNamespace(List *names, List *argtypes, const char *newschema)
+ {
+ 	List	   *operatorName = names;
+ 	TypeName   *typeName1 = (TypeName *) linitial(argtypes);
+ 	TypeName   *typeName2 = (TypeName *) lsecond(argtypes);
+ 	Oid			operOid, nspOid;
+ 	Relation	rel;
+ 
+ 	rel = heap_open(OperatorRelationId, RowExclusiveLock);
+ 
+ 	Assert(list_length(argtypes) == 2);
+ 	operOid = LookupOperNameTypeNames(NULL, operatorName,
+ 									  typeName1, typeName2,
+ 									  false, -1);
+ 
+ 	/* get schema OID */
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterOperatorNamespace_internal(rel, operOid, nspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterOperatorNamespace_oid(Oid operOid, Oid newNspOid)
+ {
+ 	Relation	rel;
+ 
+ 	rel = heap_open(OperatorRelationId, RowExclusiveLock);
+ 
+ 	AlterOperatorNamespace_internal(rel, operOid, newNspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ static void
+ AlterOperatorNamespace_internal(Relation rel, Oid operOid, Oid nspOid)
+ {
+ 	Form_pg_operator oprForm;
+ 	Oid			oldNspOid;
+ 	HeapTuple	tup;
+ 
+ 	Assert(RelationGetRelid(rel) == OperatorRelationId);
+ 
+ 	tup = SearchSysCacheCopy1(OPEROID, ObjectIdGetDatum(operOid));
+ 	if (!HeapTupleIsValid(tup)) /* should not happen */
+ 		elog(ERROR, "cache lookup failed for operator %u", operOid);
+ 
+ 	oprForm = (Form_pg_operator) GETSTRUCT(tup);
+ 	oldNspOid = oprForm->oprnamespace;
+ 
+ 	CheckSetNamespace(oldNspOid, nspOid,
+ 					  OperatorRelationId, operOid, NameStr(oprForm->oprname));
+ 
+ 	/* Superusers can always do it */
+ 	if (!superuser())
+ 	{
+ 		AclResult	aclresult;
+ 
+ 		/* Otherwise, must be owner of the existing object */
+ 		if (!pg_oper_ownercheck(operOid, GetUserId()))
+ 			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPER,
+ 						   NameStr(oprForm->oprname));
+ 
+ 		/* owner must have CREATE privilege on namespace */
+ 		aclresult = pg_namespace_aclcheck(oprForm->oprnamespace,
+ 										  GetUserId(),
+ 										  ACL_CREATE);
+ 		if (aclresult != ACLCHECK_OK)
+ 			aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
+ 						   get_namespace_name(oprForm->oprnamespace));
+ 	}
+ 
+ 	/* tup is a copy, so we can scribble directly on it */
+ 	oprForm->oprnamespace = nspOid;
+ 
+ 	simple_heap_update(rel, &tup->t_self, tup);
+ 	CatalogUpdateIndexes(rel, tup);
+ 
+ 	/* update dependencies to point to the new schema */
+ 	changeDependencyFor(OperatorRelationId, operOid,
+ 						NamespaceRelationId, oldNspOid, nspOid);
+ 
+ 	heap_freetuple(tup);
+ }
*** a/src/backend/commands/tsearchcmds.c
--- b/src/backend/commands/tsearchcmds.c
***************
*** 52,57 **** static void MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
--- 52,65 ----
  						 HeapTuple tup, Relation relMap);
  static void DropConfigurationMapping(AlterTSConfigurationStmt *stmt,
  						 HeapTuple tup, Relation relMap);
+ static void AlterTSParserNamespace_internal(Relation rel, Oid prsId,
+ 								Oid nspOid);
+ static void AlterTSDictionaryNamespace_internal(Relation rel, Oid dictId,
+ 									Oid nspOid);
+ static void AlterTSTemplateNamespace_internal(Relation rel, Oid tmplId,
+ 								  Oid nspOid);
+ static void AlterTSConfigurationNamespace_internal(Relation rel, Oid cfgId,
+ 									   Oid nspOid);
  
  
  /* --------------------- TS Parser commands ------------------------ */
***************
*** 393,398 **** RenameTSParser(List *oldname, const char *newname)
--- 401,473 ----
  	heap_freetuple(tup);
  }
  
+ /*
+  * ALTER TEXT SEARCH PARSER any_name SET SCHEMA name
+  */
+ void
+ AlterTSParserNamespace(List *name, const char *newschema)
+ {
+ 	Oid			prsId, nspOid;
+ 	Relation	rel;
+ 
+ 	rel = heap_open(TSParserRelationId, RowExclusiveLock);
+ 
+ 	prsId = get_ts_parser_oid(name, false);
+ 
+ 	/* get schema OID */
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterTSParserNamespace_internal(rel, prsId, nspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterTSParserNamespace_oid(Oid prsId, Oid newNspOid)
+ {
+ 	Relation	rel;
+ 
+ 	rel = heap_open(TSParserRelationId, RowExclusiveLock);
+ 
+ 	AlterTSParserNamespace_internal(rel, prsId, newNspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ static void
+ AlterTSParserNamespace_internal(Relation rel, Oid prsId, Oid nspOid)
+ {
+ 	HeapTuple	tup;
+ 	Oid			oldNspOid;
+ 	Form_pg_ts_parser prs;
+ 
+ 	if (!superuser())
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ 				 errmsg("must be superuser to rename text search parsers")));
+ 
+ 	tup = SearchSysCacheCopy1(TSPARSEROID, ObjectIdGetDatum(prsId));
+ 
+ 	if (!HeapTupleIsValid(tup)) /* should not happen */
+ 		elog(ERROR, "cache lookup failed for text search parser %u", prsId);
+ 
+ 	prs = (Form_pg_ts_parser) GETSTRUCT(tup);
+ 	oldNspOid = prs->prsnamespace;
+ 
+ 	CheckSetNamespace(oldNspOid, nspOid,
+ 					  TSParserRelationId, prsId, NameStr(prs->prsname));
+ 
+ 	prs->prsnamespace = nspOid;
+ 	simple_heap_update(rel, &tup->t_self, tup);
+ 	CatalogUpdateIndexes(rel, tup);
+ 
+ 	/* update dependencies to point to the new schema */
+ 	changeDependencyFor(TSParserRelationId, prsId,
+ 						NamespaceRelationId, oldNspOid, nspOid);
+ 
+ 	heap_freetuple(tup);
+ }
+ 
  /* ---------------------- TS Dictionary commands -----------------------*/
  
  /*
***************
*** 620,625 **** RenameTSDictionary(List *oldname, const char *newname)
--- 695,781 ----
  }
  
  /*
+  * ALTER TEXT SEARCH PARSER any_name SET SCHEMA name
+  */
+ void
+ AlterTSDictionaryNamespace(List *name, const char *newschema)
+ {
+ 	Oid			dictId, nspOid;
+ 	Relation	rel;
+ 
+ 	rel = heap_open(TSDictionaryRelationId, RowExclusiveLock);
+ 
+ 	dictId = get_ts_dict_oid(name, false);
+ 
+ 	/* get schema OID */
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterTSDictionaryNamespace_internal(rel, dictId, nspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterTSDictionaryNamespace_oid(Oid dictId, Oid newNspOid)
+ {
+ 	Relation	rel;
+ 
+ 	rel = heap_open(TSDictionaryRelationId, RowExclusiveLock);
+ 
+ 	AlterTSDictionaryNamespace_internal(rel, dictId, newNspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterTSDictionaryNamespace_internal(Relation rel, Oid dictId, Oid nspOid)
+ {
+ 	HeapTuple	tup;
+ 	Oid			oldNspOid;
+ 	Form_pg_ts_dict dict;
+ 
+ 	tup = SearchSysCacheCopy1(TSDICTOID, ObjectIdGetDatum(dictId));
+ 
+ 	if (!HeapTupleIsValid(tup)) /* should not happen */
+ 		elog(ERROR, "cache lookup failed for text search dictionary %u",
+ 			 dictId);
+ 
+ 	dict = ((Form_pg_ts_dict) GETSTRUCT(tup));
+ 	oldNspOid = dict->dictnamespace;
+ 
+ 	CheckSetNamespace(oldNspOid, nspOid,
+ 					  TSDictionaryRelationId, dictId,
+ 					  NameStr(dict->dictname));
+ 
+ 	/* Superusers can always do it */
+ 	if (!superuser())
+ 	{
+ 		AclResult	aclresult;
+ 
+ 		/* Otherwise, must be owner of the existing object */
+ 		if (!pg_ts_dict_ownercheck(dictId, GetUserId()))
+ 			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSDICTIONARY,
+ 						   NameStr(dict->dictname));
+ 
+ 		/* owner must have CREATE privilege on namespace */
+ 		aclresult = pg_namespace_aclcheck(oldNspOid, GetUserId(), ACL_CREATE);
+ 		if (aclresult != ACLCHECK_OK)
+ 			aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
+ 						   get_namespace_name(oldNspOid));
+ 	}
+ 
+ 	dict->dictnamespace = nspOid;
+ 	simple_heap_update(rel, &tup->t_self, tup);
+ 	CatalogUpdateIndexes(rel, tup);
+ 
+ 	/* update dependencies to point to the new schema */
+ 	changeDependencyFor(TSDictionaryRelationId, dictId,
+ 						NamespaceRelationId, oldNspOid, nspOid);
+ 
+ 	heap_freetuple(tup);
+ }
+ 
+ /*
   * DROP TEXT SEARCH DICTIONARY
   */
  void
***************
*** 1100,1105 **** RenameTSTemplate(List *oldname, const char *newname)
--- 1256,1330 ----
  }
  
  /*
+  * ALTER TEXT SEARCH TEMPLATE any_name SET SCHEMA name
+  */
+ void
+ AlterTSTemplateNamespace(List *name, const char *newschema)
+ {
+ 	Oid			tmplId, nspOid;
+ 	Relation	rel;
+ 
+ 	rel = heap_open(TSTemplateRelationId, RowExclusiveLock);
+ 
+ 	tmplId = get_ts_template_oid(name, false);
+ 
+ 	/* get schema OID */
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterTSTemplateNamespace_internal(rel, tmplId, nspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterTSTemplateNamespace_oid(Oid tmplId, Oid newNspOid)
+ {
+ 	Relation	rel;
+ 
+ 	rel = heap_open(TSTemplateRelationId, RowExclusiveLock);
+ 
+ 	AlterTSTemplateNamespace_internal(rel, tmplId, newNspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterTSTemplateNamespace_internal(Relation rel, Oid tmplId, Oid nspOid)
+ {
+ 	HeapTuple	tup;
+ 	Oid			oldNspOid;
+ 	Form_pg_ts_template tmpl;
+ 
+ 	if (!superuser())
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ 			   errmsg("must be superuser to rename text search templates")));
+ 
+ 	tup = SearchSysCacheCopy1(TSTEMPLATEOID, ObjectIdGetDatum(tmplId));
+ 
+ 	if (!HeapTupleIsValid(tup)) /* should not happen */
+ 		elog(ERROR, "cache lookup failed for text search template %u",
+ 			 tmplId);
+ 
+ 	tmpl = (Form_pg_ts_template) GETSTRUCT(tup);
+ 	oldNspOid = tmpl->tmplnamespace;
+ 
+ 	CheckSetNamespace(oldNspOid, nspOid,
+ 					  TSTemplateRelationId, tmplId, NameStr(tmpl->tmplname));
+ 
+ 	tmpl->tmplnamespace = nspOid;
+ 	simple_heap_update(rel, &tup->t_self, tup);
+ 	CatalogUpdateIndexes(rel, tup);
+ 
+ 	/* update dependencies to point to the new schema */
+ 	changeDependencyFor(TSTemplateRelationId, tmplId,
+ 						NamespaceRelationId, oldNspOid, nspOid);
+ 
+ 	heap_freetuple(tup);
+ }
+ 
+ 
+ /*
   * DROP TEXT SEARCH TEMPLATE
   */
  void
***************
*** 1498,1503 **** RenameTSConfiguration(List *oldname, const char *newname)
--- 1723,1807 ----
  }
  
  /*
+  * ALTER TEXT SEARCH CONFIGURATION any_name SET SCHEMA name
+  */
+ void
+ AlterTSConfigurationNamespace(List *name, const char *newschema)
+ {
+ 	Oid			cfgId, nspOid;
+ 	Relation	rel;
+ 
+ 	rel = heap_open(TSConfigRelationId, RowExclusiveLock);
+ 
+ 	cfgId = get_ts_config_oid(name, false);
+ 
+ 	/* get schema OID */
+ 	nspOid = LookupCreationNamespace(newschema);
+ 
+ 	AlterTSConfigurationNamespace_internal(rel, cfgId, nspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterTSConfigurationNamespace_oid(Oid cfgId, Oid newNspOid)
+ {
+ 	Relation	rel;
+ 
+ 	rel = heap_open(TSConfigRelationId, RowExclusiveLock);
+ 
+ 	AlterTSConfigurationNamespace_internal(rel, cfgId, newNspOid);
+ 
+ 	heap_close(rel, NoLock);
+ }
+ 
+ void
+ AlterTSConfigurationNamespace_internal(Relation rel, Oid cfgId, Oid nspOid)
+ {
+ 	HeapTuple	tup;
+ 	Oid			oldNspOid;
+ 	Form_pg_ts_config cfg;
+ 
+ 	tup = SearchSysCacheCopy1(TSCONFIGOID, ObjectIdGetDatum(cfgId));
+ 
+ 	if (!HeapTupleIsValid(tup)) /* should not happen */
+ 		elog(ERROR, "cache lookup failed for text search configuration %u",
+ 			 cfgId);
+ 
+ 	cfg = (Form_pg_ts_config) GETSTRUCT(tup);
+ 	oldNspOid = cfg->cfgnamespace;
+ 
+ 	CheckSetNamespace(oldNspOid, nspOid,
+ 					  TSConfigRelationId, cfgId, NameStr(cfg->cfgname));
+ 
+ 	/* Superusers can always do it */
+ 	if (!superuser())
+ 	{
+ 		AclResult	aclresult;
+ 
+ 		/* Otherwise, must be owner of the existing object */
+ 		if (!pg_ts_config_ownercheck(cfgId, GetUserId()))
+ 			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSCONFIGURATION,
+ 						   NameStr(cfg->cfgname));
+ 
+ 		/* owner must have CREATE privilege on namespace */
+ 		aclresult = pg_namespace_aclcheck(oldNspOid, GetUserId(), ACL_CREATE);
+ 		aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
+ 					   get_namespace_name(oldNspOid));
+ 	}
+ 
+ 	cfg->cfgnamespace = nspOid;
+ 	simple_heap_update(rel, &tup->t_self, tup);
+ 	CatalogUpdateIndexes(rel, tup);
+ 
+ 	/* update dependencies to point to the new schema */
+ 	changeDependencyFor(TSConfigRelationId, cfgId,
+ 						NamespaceRelationId, oldNspOid, nspOid);
+ 
+ 	heap_freetuple(tup);
+ }
+ 
+ /*
   * DROP TEXT SEARCH CONFIGURATION
   */
  void
*** a/src/backend/parser/gram.y
--- b/src/backend/parser/gram.y
***************
*** 6040,6045 **** AlterObjectSchemaStmt:
--- 6040,6053 ----
  					n->newschema = $7;
  					$$ = (Node *)n;
  				}
+ 			| ALTER CONVERSION_P any_name SET SCHEMA name
+ 				{
+ 					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+ 					n->objectType = OBJECT_CONVERSION;
+ 					n->object = $3;
+ 					n->newschema = $6;
+ 					$$ = (Node *)n;
+ 				}
  			| ALTER DOMAIN_P any_name SET SCHEMA name
  				{
  					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
***************
*** 6057,6062 **** AlterObjectSchemaStmt:
--- 6065,6097 ----
  					n->newschema = $6;
  					$$ = (Node *)n;
  				}
+ 			| ALTER OPERATOR any_operator oper_argtypes SET SCHEMA name
+ 				{
+ 					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+ 					n->objectType = OBJECT_OPERATOR;
+ 					n->object = $3;
+ 					n->objarg = $4;
+ 					n->newschema = $7;
+ 					$$ = (Node *)n;
+ 				}
+ 			| ALTER OPERATOR CLASS any_name USING access_method SET SCHEMA name
+ 				{
+ 					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+ 					n->objectType = OBJECT_OPCLASS;
+ 					n->object = $4;
+ 					n->objarg = list_make1($6);
+ 					n->newschema = $9;
+ 					$$ = (Node *)n;
+ 				}
+ 			| ALTER OPERATOR FAMILY any_name USING access_method SET SCHEMA name
+ 				{
+ 					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+ 					n->objectType = OBJECT_OPFAMILY;
+ 					n->object = $4;
+ 					n->objarg = list_make1($6);
+ 					n->newschema = $9;
+ 					$$ = (Node *)n;
+ 				}
  			| ALTER TABLE relation_expr SET SCHEMA name
  				{
  					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
***************
*** 6065,6070 **** AlterObjectSchemaStmt:
--- 6100,6137 ----
  					n->newschema = $6;
  					$$ = (Node *)n;
  				}
+ 			| ALTER TEXT_P SEARCH PARSER any_name SET SCHEMA name
+ 				{
+ 					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+ 					n->objectType = OBJECT_TSPARSER;
+ 					n->object = $5;
+ 					n->newschema = $8;
+ 					$$ = (Node *)n;
+ 				}
+ 			| ALTER TEXT_P SEARCH DICTIONARY any_name SET SCHEMA name
+ 				{
+ 					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+ 					n->objectType = OBJECT_TSDICTIONARY;
+ 					n->object = $5;
+ 					n->newschema = $8;
+ 					$$ = (Node *)n;
+ 				}
+ 			| ALTER TEXT_P SEARCH TEMPLATE any_name SET SCHEMA name
+ 				{
+ 					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+ 					n->objectType = OBJECT_TSTEMPLATE;
+ 					n->object = $5;
+ 					n->newschema = $8;
+ 					$$ = (Node *)n;
+ 				}
+ 			| ALTER TEXT_P SEARCH CONFIGURATION any_name SET SCHEMA name
+ 				{
+ 					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
+ 					n->objectType = OBJECT_TSCONFIGURATION;
+ 					n->object = $5;
+ 					n->newschema = $8;
+ 					$$ = (Node *)n;
+ 				}
  			| ALTER SEQUENCE qualified_name SET SCHEMA name
  				{
  					AlterObjectSchemaStmt *n = makeNode(AlterObjectSchemaStmt);
*** a/src/backend/tcop/utility.c
--- b/src/backend/tcop/utility.c
***************
*** 1694,1702 **** CreateCommandTag(Node *parsetree)
--- 1694,1714 ----
  				case OBJECT_AGGREGATE:
  					tag = "ALTER AGGREGATE";
  					break;
+ 				case OBJECT_CONVERSION:
+ 					tag = "ALTER CONVERSION";
+ 					break;
  				case OBJECT_DOMAIN:
  					tag = "ALTER DOMAIN";
  					break;
+ 				case OBJECT_OPERATOR:
+ 					tag = "ALTER OPERATOR";
+ 					break;
+ 				case OBJECT_OPCLASS:
+ 					tag = "ALTER OPERATOR CLASS";
+ 					break;
+ 				case OBJECT_OPFAMILY:
+ 					tag = "ALTER OPERATOR FAMILY";
+ 					break;
  				case OBJECT_FUNCTION:
  					tag = "ALTER FUNCTION";
  					break;
*** a/src/include/catalog/dependency.h
--- b/src/include/catalog/dependency.h
***************
*** 166,171 **** extern ObjectClass getObjectClass(const ObjectAddress *object);
--- 166,173 ----
  
  extern char *getObjectDescription(const ObjectAddress *object);
  
+ extern char *getObjectDescriptionOids(Oid classid, Oid objid);
+ 
  extern ObjectAddresses *new_object_addresses(void);
  
  extern void add_exact_object_address(const ObjectAddress *object,
*** a/src/include/catalog/namespace.h
--- b/src/include/catalog/namespace.h
***************
*** 94,99 **** extern Oid	LookupExplicitNamespace(const char *nspname);
--- 94,101 ----
  extern Oid	get_namespace_oid(const char *nspname, bool missing_ok);
  
  extern Oid	LookupCreationNamespace(const char *nspname);
+ extern void CheckSetNamespace(Oid oldNspOid, Oid nspOid, Oid classid,
+ 							  Oid objid, const char *name);
  extern Oid	QualifiedNameGetCreationNamespace(List *names, char **objname_p);
  extern RangeVar *makeRangeVarFromNameList(List *names);
  extern char *NameListToString(List *names);
*** a/src/include/commands/conversioncmds.h
--- b/src/include/commands/conversioncmds.h
***************
*** 22,26 **** extern void DropConversionsCommand(DropStmt *drop);
--- 22,29 ----
  extern void RenameConversion(List *name, const char *newname);
  extern void AlterConversionOwner(List *name, Oid newOwnerId);
  extern void AlterConversionOwner_oid(Oid conversionOid, Oid newOwnerId);
+ extern void AlterConversionNamespace(List *name, const char *newschema);
+ extern void AlterConversionNamespace_oid(Oid convOid, Oid newNspOid);
+ 
  
  #endif   /* CONVERSIONCMDS_H */
*** a/src/include/commands/defrem.h
--- b/src/include/commands/defrem.h
***************
*** 66,71 **** extern void DropCast(DropCastStmt *stmt);
--- 66,72 ----
  extern void DropCastById(Oid castOid);
  extern void AlterFunctionNamespace(List *name, List *argtypes, bool isagg,
  					   const char *newschema);
+ extern void AlterFunctionNamespace_oid(Oid procOid, Oid nspOid);
  extern void ExecuteDoStmt(DoStmt *stmt);
  extern Oid get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok);
  
***************
*** 78,83 **** extern void AlterOperatorOwner(List *name, TypeName *typeName1,
--- 79,86 ----
  extern void AlterOperatorOwner_oid(Oid operOid, Oid newOwnerId);
  extern Oid get_opclass_oid(Oid amID, List *opclassname, bool missing_ok);
  extern Oid get_opfamily_oid(Oid amID, List *opfamilyname, bool missing_ok);
+ extern void AlterOperatorNamespace_oid(Oid operOid, Oid newNspOid);
+ extern void AlterOperatorNamespace(List *names, List *argtypes, const char *newschema);
  
  /* commands/aggregatecmds.c */
  extern void DefineAggregate(List *name, List *args, bool oldstyle,
***************
*** 100,114 **** extern void RenameOpClass(List *name, const char *access_method, const char *new
--- 103,123 ----
  extern void RenameOpFamily(List *name, const char *access_method, const char *newname);
  extern void AlterOpClassOwner(List *name, const char *access_method, Oid newOwnerId);
  extern void AlterOpClassOwner_oid(Oid opclassOid, Oid newOwnerId);
+ extern void AlterOpClassNamespace(List *name, List *argam, const char *newschema);
+ extern void AlterOpClassNamespace_oid(Oid opclassOid, Oid newNspOid);
  extern void AlterOpFamilyOwner(List *name, const char *access_method, Oid newOwnerId);
  extern void AlterOpFamilyOwner_oid(Oid opfamilyOid, Oid newOwnerId);
  extern Oid get_am_oid(const char *amname, bool missing_ok);
+ extern void AlterOpFamilyNamespace(List *name, List *argam, const char *newschema);
+ extern void AlterOpFamilyNamespace_oid(Oid opfamilyOid, Oid newNspOid);
  
  /* commands/tsearchcmds.c */
  extern void DefineTSParser(List *names, List *parameters);
  extern void RenameTSParser(List *oldname, const char *newname);
  extern void RemoveTSParsers(DropStmt *drop);
  extern void RemoveTSParserById(Oid prsId);
+ extern void AlterTSParserNamespace(List *name, const char *newschema);
+ extern void AlterTSParserNamespace_oid(Oid prsId, Oid newNspOid);
  
  extern void DefineTSDictionary(List *names, List *parameters);
  extern void RenameTSDictionary(List *oldname, const char *newname);
***************
*** 116,129 **** extern void RemoveTSDictionaries(DropStmt *drop);
--- 125,144 ----
  extern void RemoveTSDictionaryById(Oid dictId);
  extern void AlterTSDictionary(AlterTSDictionaryStmt *stmt);
  extern void AlterTSDictionaryOwner(List *name, Oid newOwnerId);
+ extern void AlterTSDictionaryNamespace(List *name, const char *newschema);
+ extern void AlterTSDictionaryNamespace_oid(Oid dictId, Oid newNspOid);
  
  extern void DefineTSTemplate(List *names, List *parameters);
  extern void RenameTSTemplate(List *oldname, const char *newname);
+ extern void AlterTSTemplateNamespace(List *name, const char *newschema);
+ extern void AlterTSTemplateNamespace_oid(Oid tmplId, Oid newNspOid);
  extern void RemoveTSTemplates(DropStmt *stmt);
  extern void RemoveTSTemplateById(Oid tmplId);
  
  extern void DefineTSConfiguration(List *names, List *parameters);
  extern void RenameTSConfiguration(List *oldname, const char *newname);
+ extern void AlterTSConfigurationNamespace(List *name, const char *newschema);
+ extern void AlterTSConfigurationNamespace_oid(Oid cfgId, Oid newNspOid);
  extern void RemoveTSConfigurations(DropStmt *stmt);
  extern void RemoveTSConfigurationById(Oid cfgId);
  extern void AlterTSConfiguration(AlterTSConfigurationStmt *stmt);