[BUG?] strange behavior in ALTER TABLE ... RENAME TO on inherited columns

Index: src/test/regress/sql/inherit.sql
===================================================================
*** src/test/regress/sql/inherit.sql	(revision 2388)
--- src/test/regress/sql/inherit.sql	(working copy)
*************** CREATE TABLE inh_error1 () INHERITS (t1,
*** 336,338 ****
--- 336,352 ----
  CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
  
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ 
+ -- Test for renaming
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (b int, c int);
+ CREATE TABLE t3 (d int) INHERITS(t1, t2);
+ ALTER TABLE t1 RENAME a TO x;
+ ALTER TABLE t1 RENAME b TO y;	-- to be failed
+ ALTER TABLE t3 RENAME d TO z;
+ SELECT * FROM t3;
+ DROP TABLE t3;
+ DROP TABLE t2;
+ DROP TABLE t1;
+ 
+ 
Index: src/test/regress/expected/inherit.out
===================================================================
*** src/test/regress/expected/inherit.out	(revision 2388)
--- src/test/regress/expected/inherit.out	(working copy)
*************** NOTICE:  merging column "a" with inherit
*** 1057,1059 ****
--- 1057,1076 ----
  ERROR:  column "a" has a storage parameter conflict
  DETAIL:  MAIN versus EXTENDED
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ -- Test for renaming
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (b int, c int);
+ CREATE TABLE t3 (d int) INHERITS(t1, t2);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 RENAME a TO x;
+ ALTER TABLE t1 RENAME b TO y;	-- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ ALTER TABLE t3 RENAME d TO z;
+ SELECT * FROM t3;
+  x | b | c | z 
+ ---+---+---+---
+ (0 rows)
+ 
+ DROP TABLE t3;
+ DROP TABLE t2;
+ DROP TABLE t1;
Index: src/backend/commands/tablecmds.c
===================================================================
*** src/backend/commands/tablecmds.c	(revision 2388)
--- src/backend/commands/tablecmds.c	(working copy)
*************** renameatt(Oid myrelid,
*** 2024,2029 ****
--- 2024,2040 ----
  				 errmsg("cannot rename inherited column \"%s\"",
  						oldattname)));
  
+ 	/*
+ 	 * If the attribute is inherited from multiple parents, forbid
+ 	 * the renaming, because we don't have any reasonable way to keep
+ 	 * integrity in whole of the inheritance relationship.
+ 	 */
+ 	if (attform->attinhcount > 1)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ 				 (errmsg("cannot rename multiple inherited column \"%s\"",
+ 						 oldattname))));
+ 
  	/* should not already exist */
  	/* this test is deliberately not attisdropped-aware */
  	if (SearchSysCacheExists(ATTNAME,

*** src/test/regress/sql/inherit.sql	(revision 2486)
--- src/test/regress/sql/inherit.sql	(working copy)
***************
*** 336,338 ****
--- 336,350 ----
  CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
  
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ 
+ -- Test for renaming
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (b int, c int);
+ CREATE TABLE t3 (d int) INHERITS(t1, t2);
+ ALTER TABLE t1 RENAME a TO x;
+ ALTER TABLE t1 RENAME b TO y;		-- to be failed
+ ALTER TABLE t3 RENAME d TO z;
+ SELECT * FROM t3;
+ DROP TABLE t3;
+ DROP TABLE t2;
+ DROP TABLE t1;
*** src/test/regress/expected/inherit.out	(revision 2486)
--- src/test/regress/expected/inherit.out	(working copy)
***************
*** 1057,1059 ****
--- 1057,1076 ----
  ERROR:  column "a" has a storage parameter conflict
  DETAIL:  MAIN versus EXTENDED
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ -- Test for renaming
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (b int, c int);
+ CREATE TABLE t3 (d int) INHERITS(t1, t2);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 RENAME a TO x;
+ ALTER TABLE t1 RENAME b TO y;		-- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ ALTER TABLE t3 RENAME d TO z;
+ SELECT * FROM t3;
+  x | b | c | z 
+ ---+---+---+---
+ (0 rows)
+ 
+ DROP TABLE t3;
+ DROP TABLE t2;
+ DROP TABLE t1;
*** src/backend/commands/tablecmds.c	(revision 2486)
--- src/backend/commands/tablecmds.c	(working copy)
***************
*** 2024,2029 ****
--- 2024,2040 ----
  				 errmsg("cannot rename inherited column \"%s\"",
  						oldattname)));
  
+ 	/*
+ 	 * if the attribute is multiple inherited, forbid the renaming,
+ 	 * even if we are already inside a recursive rename, because we
+ 	 * have no reasonable way to keep its integrity.
+ 	 */
+ 	if (attform->attinhcount > 1)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ 				 (errmsg("cannot rename multiple inherited column \"%s\"",
+ 						 oldattname))));
+ 
  	/* should not already exist */
  	/* this test is deliberately not attisdropped-aware */
  	if (SearchSysCacheExists(ATTNAME,

Index: src/test/regress/sql/inherit.sql
===================================================================
*** src/test/regress/sql/inherit.sql	(revision 2531)
--- src/test/regress/sql/inherit.sql	(working copy)
*************** CREATE TABLE inh_error1 () INHERITS (t1,
*** 334,336 ****
--- 334,348 ----
  CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
  
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ 
+ -- Test for renaming
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (b int, c int);
+ CREATE TABLE t3 (d int) INHERITS(t1, t2);
+ ALTER TABLE t1 RENAME a TO x;
+ ALTER TABLE t1 RENAME b TO y;		-- to be failed
+ ALTER TABLE t3 RENAME d TO z;
+ SELECT * FROM t3;
+ DROP TABLE t3;
+ DROP TABLE t2;
+ DROP TABLE t1;
Index: src/test/regress/expected/inherit.out
===================================================================
*** src/test/regress/expected/inherit.out	(revision 2531)
--- src/test/regress/expected/inherit.out	(working copy)
*************** NOTICE:  merging column "a" with inherit
*** 1053,1055 ****
--- 1053,1072 ----
  ERROR:  column "a" has a storage parameter conflict
  DETAIL:  MAIN versus EXTENDED
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ -- Test for renaming
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (b int, c int);
+ CREATE TABLE t3 (d int) INHERITS(t1, t2);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 RENAME a TO x;
+ ALTER TABLE t1 RENAME b TO y;		-- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ ALTER TABLE t3 RENAME d TO z;
+ SELECT * FROM t3;
+  x | b | c | z 
+ ---+---+---+---
+ (0 rows)
+ 
+ DROP TABLE t3;
+ DROP TABLE t2;
+ DROP TABLE t1;
Index: src/backend/commands/tablecmds.c
===================================================================
*** src/backend/commands/tablecmds.c	(revision 2531)
--- src/backend/commands/tablecmds.c	(working copy)
*************** renameatt(Oid myrelid,
*** 2009,2014 ****
--- 2009,2025 ----
  				 errmsg("cannot rename inherited column \"%s\"",
  						oldattname)));
  
+ 	/*
+ 	 * if the attribute is multiple inherited, forbid the renaming,
+ 	 * even if we are already inside a recursive rename, because we
+ 	 * have no reasonable way to keep its integrity.
+ 	 */
+ 	if (attform->attinhcount > 1)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ 				 (errmsg("cannot rename multiple inherited column \"%s\"",
+ 						 oldattname))));
+ 
  	/* new name should not already exist */
  
  	/* this test is deliberately not attisdropped-aware */

Index: base/src/test/regress/sql/inherit.sql
===================================================================
*** base/src/test/regress/sql/inherit.sql	(revision 2538)
--- base/src/test/regress/sql/inherit.sql	(working copy)
*************** CREATE TABLE inh_error1 () INHERITS (t1,
*** 334,336 ****
--- 334,348 ----
  CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
  
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ 
+ -- Test for renaming
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (b int, c int);
+ CREATE TABLE t3 (d int) INHERITS(t1, t2);
+ ALTER TABLE t1 RENAME a TO x;
+ ALTER TABLE t1 RENAME b TO y;		-- to be failed
+ ALTER TABLE t3 RENAME d TO z;
+ SELECT * FROM t3;
+ DROP TABLE t3;
+ DROP TABLE t2;
+ DROP TABLE t1;
Index: base/src/test/regress/expected/inherit.out
===================================================================
*** base/src/test/regress/expected/inherit.out	(revision 2538)
--- base/src/test/regress/expected/inherit.out	(working copy)
*************** NOTICE:  merging column "a" with inherit
*** 1053,1055 ****
--- 1053,1072 ----
  ERROR:  column "a" has a storage parameter conflict
  DETAIL:  MAIN versus EXTENDED
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ -- Test for renaming
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (b int, c int);
+ CREATE TABLE t3 (d int) INHERITS(t1, t2);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 RENAME a TO x;
+ ALTER TABLE t1 RENAME b TO y;		-- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ ALTER TABLE t3 RENAME d TO z;
+ SELECT * FROM t3;
+  x | b | c | z 
+ ---+---+---+---
+ (0 rows)
+ 
+ DROP TABLE t3;
+ DROP TABLE t2;
+ DROP TABLE t1;
Index: base/src/include/commands/tablecmds.h
===================================================================
*** base/src/include/commands/tablecmds.h	(revision 2538)
--- base/src/include/commands/tablecmds.h	(working copy)
*************** extern void ExecuteTruncate(TruncateStmt
*** 42,47 ****
--- 42,48 ----
  extern void renameatt(Oid myrelid,
  		  const char *oldattname,
  		  const char *newattname,
+ 		  int expected_inhcount,
  		  bool recurse,
  		  bool recursing);
  
Index: base/src/include/catalog/pg_inherits_fn.h
===================================================================
*** base/src/include/catalog/pg_inherits_fn.h	(revision 2538)
--- base/src/include/catalog/pg_inherits_fn.h	(working copy)
***************
*** 19,24 ****
--- 19,28 ----
  
  extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
  extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode);
+ extern void find_all_inheritors_with_inhcount(Oid parentrelId,
+ 											  LOCKMODE lockmode,
+ 											  List **child_oids,
+ 											  List **child_inhs);
  extern bool has_subclass(Oid relationId);
  extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
  
Index: base/src/backend/commands/tablecmds.c
===================================================================
*** base/src/backend/commands/tablecmds.c	(revision 2538)
--- base/src/backend/commands/tablecmds.c	(working copy)
*************** void
*** 1908,1913 ****
--- 1908,1914 ----
  renameatt(Oid myrelid,
  		  const char *oldattname,
  		  const char *newattname,
+ 		  int expected_inhcount,
  		  bool recurse,
  		  bool recursing)
  {
*************** renameatt(Oid myrelid,
*** 1948,1971 ****
  	 */
  	if (recurse)
  	{
! 		ListCell   *child;
! 		List	   *children;
! 
! 		children = find_all_inheritors(myrelid, AccessExclusiveLock);
  
  		/*
! 		 * find_all_inheritors does the recursive search of the inheritance
! 		 * hierarchy, so all we have to do is process all of the relids in the
! 		 * list that it returns.
  		 */
! 		foreach(child, children)
  		{
! 			Oid			childrelid = lfirst_oid(child);
  
! 			if (childrelid == myrelid)
  				continue;
  			/* note we need not recurse again */
! 			renameatt(childrelid, oldattname, newattname, false, true);
  		}
  	}
  	else
--- 1949,1998 ----
  	 */
  	if (recurse)
  	{
! 		List	   *child_oids, *child_inhs;
! 		ListCell   *lo, *li;
  
  		/*
! 		 * If we cound find an expected inhcount larger than 1,
! 		 * t means the relation has diamond inheritance tree.
! 		 *
! 		 * If an attribute to be renamed is inherited from multiple
! 		 * parent relations independently defined then merged, it
! 		 * is problematic to rename the attribute, because anohter
! 		 * inheritance tree assumes the child relation still has the
! 		 * inherited attributes, but it will be incorrect.
! 		 * So, we have to forbide to rename an attribute which is
! 		 * inherited from multiple parent relations.
! 		 *
! 		 * However, we have an exception case when the attribute is
! 		 * inherited from multiple parent relations, but these ones
! 		 * eventually have same origion.
! 		 * For example, when TBL_A is inherited by TBL_X and TBL_Y,
! 		 * these tables are inherited by TBL_XY, the TBL_XY indeed
! 		 * has multiple parent relations and its attributes was
! 		 * merged. But, these have same origin, and we have no reason
! 		 * to prevent renaming them.
! 		 *
! 		 * So, we check whether the child relation has diamond
! 		 * inheritance, or not, here. If pg_attribute.attinhcount is
! 		 * larger than expected inhcount, it means the attribute was
! 		 * merged with any other attributes come from other parent
! 		 * relations.
  		 */
! 		find_all_inheritors_with_inhcount(myrelid, AccessExclusiveLock,
! 										  &child_oids, &child_inhs);
! 
! 		forboth (lo, child_oids, li, child_inhs)
  		{
! 			Oid		child_relid = lfirst_oid(lo);
! 			int		child_inhcount = lfirst_int(li);
  
! 			if (child_relid == myrelid)
  				continue;
+ 
  			/* note we need not recurse again */
! 			renameatt(child_relid, oldattname, newattname,
! 					  child_inhcount, false, true);
  		}
  	}
  	else
*************** renameatt(Oid myrelid,
*** 2009,2014 ****
--- 2036,2052 ----
  				 errmsg("cannot rename inherited column \"%s\"",
  						oldattname)));
  
+ 	/*
+ 	 * if the attribute is multiple inherited, forbid the renaming,
+ 	 * even if we are already inside a recursive rename, because we
+ 	 * have no reasonable way to keep its integrity.
+ 	 */
+ 	if (attform->attinhcount > expected_inhcount)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ 				 (errmsg("cannot rename multiple inherited column \"%s\"",
+ 						 oldattname))));
+ 
  	/* new name should not already exist */
  
  	/* this test is deliberately not attisdropped-aware */
Index: base/src/backend/commands/alter.c
===================================================================
*** base/src/backend/commands/alter.c	(revision 2538)
--- base/src/backend/commands/alter.c	(working copy)
*************** ExecRenameStmt(RenameStmt *stmt)
*** 125,130 ****
--- 125,131 ----
  						renameatt(relid,
  								  stmt->subname,		/* old att name */
  								  stmt->newname,		/* new att name */
+ 								  1,			/* expected inhcount */
  								  interpretInhOption(stmt->relation->inhOpt),	/* recursive? */
  								  false);		/* recursing already? */
  						break;
Index: base/src/backend/catalog/pg_inherits.c
===================================================================
*** base/src/backend/catalog/pg_inherits.c	(revision 2538)
--- base/src/backend/catalog/pg_inherits.c	(working copy)
*************** find_all_inheritors(Oid parentrelId, LOC
*** 190,195 ****
--- 190,256 ----
  	return rels_list;
  }
  
+ /*
+  * find_all_inheritors_with_inhcount
+  *
+  * It is same as find_all_inheritors, except for it returns an excepted
+  * inhcount for each children.
+  */
+ void
+ find_all_inheritors_with_inhcount(Oid parentrelId, LOCKMODE lockmode,
+ 								  List **child_oids, List **child_inhs)
+ {
+ 	List	   *children, *rels_oids, *rels_inhs;
+ 	ListCell   *lc, *lo, *li;
+ 
+ 	/*
+ 	 * The root of the inheritance tree always has 1 as an expected
+ 	 * inhcount.
+ 	 */
+ 	rels_oids = list_make1_oid(parentrelId);
+ 	rels_inhs = list_make1_int(1);
+ 
+ 	children = find_inheritance_children(parentrelId, lockmode);
+ 	foreach (lc, children)
+ 	{
+ 		Oid		cur_relid = lfirst_oid(lc);
+ 		List   *cur_children;
+ 		bool	found = false;
+ 
+ 		forboth (lo, rels_oids, li, rels_inhs)
+ 		{
+ 			/*
+ 			 * If we found a duplicated relation within a certain inheritance
+ 			 * tree, it means a diamond-inheritance. So, we increment its
+ 			 * expected inhcount without appending an element to the list.
+ 			 */
+ 			if (lfirst_oid(lo) == cur_relid)
+ 			{
+ 				lfirst_int(li)++;
+ 				found = true;
+ 				break;
+ 			}
+ 		}
+ 
+ 		if (!found)
+ 		{
+ 			rels_oids = lappend_oid(rels_oids, cur_relid);
+ 			rels_inhs = lappend_int(rels_inhs, 1);
+ 		}
+ 
+ 		/*
+ 		 * Unlike find_all_inheritors(), we need to walk on child relations
+ 		 * that have diamond inheritance tree, because this function has to
+ 		 * return correct expected inhecount to the caller.
+ 		 */
+ 		cur_children = find_inheritance_children(cur_relid, lockmode);
+ 
+ 		children = list_concat(children, cur_children);
+ 	}
+ 
+ 	*child_oids = rels_oids;
+ 	*child_inhs = rels_inhs;
+ }
  
  /*
   * has_subclass - does this relation have any children?

*** a/src/backend/catalog/pg_inherits.c
--- b/src/backend/catalog/pg_inherits.c
***************
*** 28,33 ****
--- 28,34 ----
  #include "parser/parse_type.h"
  #include "storage/lmgr.h"
  #include "utils/fmgroids.h"
+ #include "utils/lsyscache.h"
  #include "utils/syscache.h"
  #include "utils/tqual.h"
  
***************
*** 190,195 **** find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
--- 191,257 ----
  	return rels_list;
  }
  
+ /*
+  * find_column_origin
+  *
+  * It returns a list of relation OIDs that defines the given column originally.
+  * In most cases, a certain column has one origin, unless it (or its parent)
+  * has multiple inheritance tree.
+  * Note that it returns a unique OID for diamond-type inheritance tree, because
+  * it shares same origin.
+  */
+ List *
+ find_column_origin(Oid relOid, const char *colName)
+ {
+ 	Relation	inhRel;
+ 	SysScanDesc	scan;
+ 	ScanKeyData	skey[1];
+ 	HeapTuple	tuple;
+ 	List	   *results = NIL;
+ 
+ 	/*
+ 	 * This relation does not contain the given column, is also means
+ 	 * the parent relation also.
+ 	 */
+ 	if (get_attnum(relOid, colName) == InvalidAttrNumber)
+ 		return NIL;
+ 
+ 	inhRel = heap_open(InheritsRelationId, AccessShareLock);
+ 
+ 	ScanKeyInit(&skey[0],
+ 				Anum_pg_inherits_inhrelid,
+ 				BTEqualStrategyNumber, F_OIDEQ,
+ 				ObjectIdGetDatum(relOid));
+ 
+ 	scan = systable_beginscan(inhRel, InheritsRelidSeqnoIndexId,
+ 							  true, SnapshotNow, 1, &skey);
+ 
+ 	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+ 	{
+ 		Form_pg_inherits	inhForm = (Form_pg_inherits) GETSTRUCT(tuple);
+ 		List	   *temp;
+ 
+ 		temp = find_column_origin(inhForm->inhparent, colName);
+ 		if (temp == NIL)
+ 			continue;
+ 
+ 		/*
+ 		 * Add to the queue only those children not already seen. This avoids
+ 		 * making duplicate entries in case of multiple inheritance paths from
+ 		 * the same parent.  (It'll also keep us from getting into an infinite
+ 		 * loop, though theoretically there can't be any cycles in the
+ 		 * inheritance graph anyway.)
+ 		 */
+ 		results = list_concat_unique_oid(results, temp);
+ 	}
+ 	systable_endscan(scan);
+ 	heap_close(inhRel, AccessShareLock);
+ 
+ 	if (results == NIL)
+ 		results = list_make1_oid(relOid);
+ 
+ 	return results;
+ }
  
  /*
   * has_subclass - does this relation have any children?
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 2009,2014 **** renameatt(Oid myrelid,
--- 2009,2025 ----
  				 errmsg("cannot rename inherited column \"%s\"",
  						oldattname)));
  
+ 	/*
+ 	 * if the attribute is multiple inherited, forbid the renaming,
+ 	 * even if we are already inside a recursive rename, because we
+ 	 * have no reasonable way to keep its integrity.
+ 	 */
+ 	if (list_length(find_column_origin(myrelid, oldattname)) > 1)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ 				 (errmsg("cannot rename multiple inherited column \"%s\"",
+ 						 oldattname))));
+ 
  	/* new name should not already exist */
  
  	/* this test is deliberately not attisdropped-aware */
***************
*** 5771,5776 **** ATPrepAlterColumnType(List **wqueue,
--- 5782,5788 ----
  					  bool recurse, bool recursing,
  					  AlterTableCmd *cmd)
  {
+ 	Oid			relOid = RelationGetRelid(rel);
  	char	   *colName = cmd->name;
  	TypeName   *typeName = (TypeName *) cmd->def;
  	HeapTuple	tuple;
***************
*** 5806,5811 **** ATPrepAlterColumnType(List **wqueue,
--- 5818,5830 ----
  				 errmsg("cannot alter inherited column \"%s\"",
  						colName)));
  
+ 	/* Don't alter multiple inherited columns */
+ 	if (list_length(find_column_origin(relOid, colName)) > 1)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ 				 (errmsg("cannot alter multiple inherited column \"%s\"",
+ 						 colName))));
+ 
  	/* Look up the target type */
  	targettype = typenameTypeId(NULL, typeName, &targettypmod);
  
*** a/src/include/catalog/pg_inherits_fn.h
--- b/src/include/catalog/pg_inherits_fn.h
***************
*** 19,24 ****
--- 19,25 ----
  
  extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
  extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode);
+ extern List *find_column_origin(Oid relOid, const char *colName);
  extern bool has_subclass(Oid relationId);
  extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
  
*** a/src/test/regress/expected/inherit.out
--- b/src/test/regress/expected/inherit.out
***************
*** 1053,1055 **** NOTICE:  merging column "a" with inherited definition
--- 1053,1133 ----
  ERROR:  column "a" has a storage parameter conflict
  DETAIL:  MAIN versus EXTENDED
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ -- Test for renaming and type changes (simple multiple inheritance)
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE s1 (b int, c int);
+ CREATE TABLE ts (d int) INHERITS (t1, s1);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE s1 ALTER b TYPE float;	-- to be failed
+ ERROR:  cannot alter multiple inherited column "b"
+ ALTER TABLE s1 ALTER c TYPE float;
+ ALTER TABLE ts ALTER c TYPE text;	-- to be failed
+ ERROR:  cannot alter inherited column "c"
+ ALTER TABLE ts ALTER d TYPE text;
+ ALTER TABLE t1 RENAME a TO aa;
+ ALTER TABLE t1 RENAME b TO bb;		-- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ ALTER TABLE ts RENAME aa TO aaa;	-- to be failed
+ ERROR:  cannot rename inherited column "aa"
+ ALTER TABLE ts RENAME d TO dd;
+ \d+ ts
+                        Table "public.ts"
+  Column |       Type       | Modifiers | Storage  | Description 
+ --------+------------------+-----------+----------+-------------
+  aa     | integer          |           | plain    | 
+  b      | integer          |           | plain    | 
+  c      | double precision |           | plain    | 
+  dd     | text             |           | extended | 
+ Inherits: t1,
+           s1
+ Has OIDs: no
+ 
+ DROP TABLE ts;
+ -- Test for renaming and type changes (diamond inheritance)
+ CREATE TABLE t2 (x int) INHERITS (t1);
+ CREATE TABLE t3 (y int) INHERITS (t1);
+ CREATE TABLE t4 (z int) INHERITS (t2, t3);
+ NOTICE:  merging multiple inherited definitions of column "aa"
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 ALTER aa TYPE float;
+ ALTER TABLE t1 RENAME aa TO aaa;
+ \d+ t4
+                        Table "public.t4"
+  Column |       Type       | Modifiers | Storage | Description 
+ --------+------------------+-----------+---------+-------------
+  aaa    | double precision |           | plain   | 
+  b      | integer          |           | plain   | 
+  x      | integer          |           | plain   | 
+  y      | integer          |           | plain   | 
+  z      | integer          |           | plain   | 
+ Inherits: t2,
+           t3
+ Has OIDs: no
+ 
+ CREATE TABLE ts (d int) INHERITS (t2, s1);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 ALTER aaa TYPE text;
+ ALTER TABLE t1 ALTER b TYPE text;	-- to be failed
+ ERROR:  cannot alter multiple inherited column "b"
+ ALTER TABLE t1 RENAME aaa TO aaaa;
+ ALTER TABLE t1 RENAME b TO bb;		-- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ \d+ ts
+                        Table "public.ts"
+  Column |       Type       | Modifiers | Storage  | Description 
+ --------+------------------+-----------+----------+-------------
+  aaaa   | text             |           | extended | 
+  b      | integer          |           | plain    | 
+  x      | integer          |           | plain    | 
+  c      | double precision |           | plain    | 
+  d      | integer          |           | plain    | 
+ Inherits: t2,
+           s1
+ Has OIDs: no
+ 
+ DROP TABLE t1, s1 CASCADE;
+ NOTICE:  drop cascades to 4 other objects
+ DETAIL:  drop cascades to table t2
+ drop cascades to table ts
+ drop cascades to table t3
+ drop cascades to table t4
*** a/src/test/regress/sql/inherit.sql
--- b/src/test/regress/sql/inherit.sql
***************
*** 334,336 **** CREATE TABLE inh_error1 () INHERITS (t1, t4);
--- 334,372 ----
  CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
  
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ 
+ -- Test for renaming and type changes (simple multiple inheritance)
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE s1 (b int, c int);
+ CREATE TABLE ts (d int) INHERITS (t1, s1);
+ 
+ ALTER TABLE s1 ALTER b TYPE float;	-- to be failed
+ ALTER TABLE s1 ALTER c TYPE float;
+ ALTER TABLE ts ALTER c TYPE text;	-- to be failed
+ ALTER TABLE ts ALTER d TYPE text;
+ 
+ ALTER TABLE t1 RENAME a TO aa;
+ ALTER TABLE t1 RENAME b TO bb;		-- to be failed
+ ALTER TABLE ts RENAME aa TO aaa;	-- to be failed
+ ALTER TABLE ts RENAME d TO dd;
+ \d+ ts
+ 
+ DROP TABLE ts;
+ 
+ -- Test for renaming and type changes (diamond inheritance)
+ CREATE TABLE t2 (x int) INHERITS (t1);
+ CREATE TABLE t3 (y int) INHERITS (t1);
+ CREATE TABLE t4 (z int) INHERITS (t2, t3);
+ 
+ ALTER TABLE t1 ALTER aa TYPE float;
+ ALTER TABLE t1 RENAME aa TO aaa;
+ \d+ t4
+ 
+ CREATE TABLE ts (d int) INHERITS (t2, s1);
+ ALTER TABLE t1 ALTER aaa TYPE text;
+ ALTER TABLE t1 ALTER b TYPE text;	-- to be failed
+ ALTER TABLE t1 RENAME aaa TO aaaa;
+ ALTER TABLE t1 RENAME b TO bb;		-- to be failed
+ \d+ ts
+ 
+ DROP TABLE t1, s1 CASCADE;

diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
index e256f6f..fbde33a 100644
--- a/src/backend/catalog/pg_inherits.c
+++ b/src/backend/catalog/pg_inherits.c
@@ -28,6 +28,7 @@
 #include "parser/parse_type.h"
 #include "storage/lmgr.h"
 #include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
 
@@ -190,6 +191,67 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
 	return rels_list;
 }
 
+/*
+ * find_column_origin
+ *
+ * Returns a list of relation OIDs the given column is inherited from.
+ * In most cases, a column has one origin, unless it (or its parent)
+ * has multiple ancestors.
+ * Note that find_column_origin() returns a unique OID for diamond-type 
+ * inheritance trees, because all relations shares the same origin.
+ */
+List *
+find_column_origin(Oid relOid, const char *colName)
+{
+	Relation	inhRel;
+	SysScanDesc	scan;
+	ScanKeyData	skey[1];
+	HeapTuple	tuple;
+	List	   *results = NIL;
+
+	/*
+	 * This relation does not contain the given column, so its
+	 * parent neither.
+	 */
+	if (get_attnum(relOid, colName) == InvalidAttrNumber)
+		return NIL;
+
+	inhRel = heap_open(InheritsRelationId, AccessShareLock);
+
+	ScanKeyInit(&skey[0],
+				Anum_pg_inherits_inhrelid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(relOid));
+
+	scan = systable_beginscan(inhRel, InheritsRelidSeqnoIndexId,
+							  true, SnapshotNow, 1, skey);
+
+	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+	{
+		Form_pg_inherits	inhForm = (Form_pg_inherits) GETSTRUCT(tuple);
+		List	   *temp;
+
+		temp = find_column_origin(inhForm->inhparent, colName);
+		if (temp == NIL)
+			continue;
+
+		/*
+		 * Add to the queue only those children not already seen. This avoids
+		 * making duplicate entries in case of multiple inheritance paths from
+		 * the same parent.  (It'll also keep us from getting into an infinite
+		 * loop, though theoretically there can't be any cycles in the
+		 * inheritance graph anyway.)
+		 */
+		results = list_concat_unique_oid(results, temp);
+	}
+	systable_endscan(scan);
+	heap_close(inhRel, AccessShareLock);
+
+	if (results == NIL)
+		results = list_make1_oid(relOid);
+
+	return results;
+}
 
 /*
  * has_subclass - does this relation have any children?
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 10f0a94..4cd988c 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2009,6 +2009,17 @@ renameatt(Oid myrelid,
 				 errmsg("cannot rename inherited column \"%s\"",
 						oldattname)));
 
+	/*
+	 * if the attribute is inherited multiple times, forbid the renaming,
+	 * even if we are already inside a recursive rename, because we
+	 * have no reasonable way to keep its integrity.
+	 */
+	if (list_length(find_column_origin(myrelid, oldattname)) > 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 (errmsg("cannot rename multiple inherited column \"%s\"",
+						 oldattname))));
+
 	/* new name should not already exist */
 
 	/* this test is deliberately not attisdropped-aware */
@@ -5768,6 +5779,7 @@ ATPrepAlterColumnType(List **wqueue,
 					  bool recurse, bool recursing,
 					  AlterTableCmd *cmd)
 {
+	Oid			relOid = RelationGetRelid(rel);
 	char	   *colName = cmd->name;
 	TypeName   *typeName = (TypeName *) cmd->def;
 	HeapTuple	tuple;
@@ -5803,6 +5815,13 @@ ATPrepAlterColumnType(List **wqueue,
 				 errmsg("cannot alter inherited column \"%s\"",
 						colName)));
 
+	/* Don't alter multiple inherited columns */
+	if (list_length(find_column_origin(relOid, colName)) > 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 (errmsg("cannot alter multiple inherited column \"%s\"",
+						 colName))));
+
 	/* Look up the target type */
 	targettype = typenameTypeId(NULL, typeName, &targettypmod);
 
diff --git a/src/include/catalog/pg_inherits_fn.h b/src/include/catalog/pg_inherits_fn.h
index 91baec3..a23f62b 100644
--- a/src/include/catalog/pg_inherits_fn.h
+++ b/src/include/catalog/pg_inherits_fn.h
@@ -19,6 +19,7 @@
 
 extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
 extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode);
+extern List *find_column_origin(Oid relOid, const char *colName);
 extern bool has_subclass(Oid relationId);
 extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
 
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 9c83a32..3a049cc 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1053,3 +1053,81 @@ NOTICE:  merging column "a" with inherited definition
 ERROR:  column "a" has a storage parameter conflict
 DETAIL:  MAIN versus EXTENDED
 DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+-- Test for renaming and type changes (simple multiple inheritance)
+CREATE TABLE t1 (a int, b int);
+CREATE TABLE s1 (b int, c int);
+CREATE TABLE ts (d int) INHERITS (t1, s1);
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE s1 ALTER b TYPE float;	-- to be failed
+ERROR:  cannot alter multiple inherited column "b"
+ALTER TABLE s1 ALTER c TYPE float;
+ALTER TABLE ts ALTER c TYPE text;	-- to be failed
+ERROR:  cannot alter inherited column "c"
+ALTER TABLE ts ALTER d TYPE text;
+ALTER TABLE t1 RENAME a TO aa;
+ALTER TABLE t1 RENAME b TO bb;		-- to be failed
+ERROR:  cannot rename multiple inherited column "b"
+ALTER TABLE ts RENAME aa TO aaa;	-- to be failed
+ERROR:  cannot rename inherited column "aa"
+ALTER TABLE ts RENAME d TO dd;
+\d+ ts
+                       Table "public.ts"
+ Column |       Type       | Modifiers | Storage  | Description 
+--------+------------------+-----------+----------+-------------
+ aa     | integer          |           | plain    | 
+ b      | integer          |           | plain    | 
+ c      | double precision |           | plain    | 
+ dd     | text             |           | extended | 
+Inherits: t1,
+          s1
+Has OIDs: no
+
+DROP TABLE ts;
+-- Test for renaming and type changes (diamond inheritance)
+CREATE TABLE t2 (x int) INHERITS (t1);
+CREATE TABLE t3 (y int) INHERITS (t1);
+CREATE TABLE t4 (z int) INHERITS (t2, t3);
+NOTICE:  merging multiple inherited definitions of column "aa"
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE t1 ALTER aa TYPE float;
+ALTER TABLE t1 RENAME aa TO aaa;
+\d+ t4
+                       Table "public.t4"
+ Column |       Type       | Modifiers | Storage | Description 
+--------+------------------+-----------+---------+-------------
+ aaa    | double precision |           | plain   | 
+ b      | integer          |           | plain   | 
+ x      | integer          |           | plain   | 
+ y      | integer          |           | plain   | 
+ z      | integer          |           | plain   | 
+Inherits: t2,
+          t3
+Has OIDs: no
+
+CREATE TABLE ts (d int) INHERITS (t2, s1);
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE t1 ALTER aaa TYPE text;
+ALTER TABLE t1 ALTER b TYPE text;	-- to be failed
+ERROR:  cannot alter multiple inherited column "b"
+ALTER TABLE t1 RENAME aaa TO aaaa;
+ALTER TABLE t1 RENAME b TO bb;		-- to be failed
+ERROR:  cannot rename multiple inherited column "b"
+\d+ ts
+                       Table "public.ts"
+ Column |       Type       | Modifiers | Storage  | Description 
+--------+------------------+-----------+----------+-------------
+ aaaa   | text             |           | extended | 
+ b      | integer          |           | plain    | 
+ x      | integer          |           | plain    | 
+ c      | double precision |           | plain    | 
+ d      | integer          |           | plain    | 
+Inherits: t2,
+          s1
+Has OIDs: no
+
+DROP TABLE t1, s1 CASCADE;
+NOTICE:  drop cascades to 4 other objects
+DETAIL:  drop cascades to table t2
+drop cascades to table ts
+drop cascades to table t3
+drop cascades to table t4
diff --git a/src/test/regress/sql/inherit.sql b/src/test/regress/sql/inherit.sql
index 192e860..82ee7d3 100644
--- a/src/test/regress/sql/inherit.sql
+++ b/src/test/regress/sql/inherit.sql
@@ -334,3 +334,39 @@ CREATE TABLE inh_error1 () INHERITS (t1, t4);
 CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
 
 DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+
+-- Test for renaming and type changes (simple multiple inheritance)
+CREATE TABLE t1 (a int, b int);
+CREATE TABLE s1 (b int, c int);
+CREATE TABLE ts (d int) INHERITS (t1, s1);
+
+ALTER TABLE s1 ALTER b TYPE float;	-- to be failed
+ALTER TABLE s1 ALTER c TYPE float;
+ALTER TABLE ts ALTER c TYPE text;	-- to be failed
+ALTER TABLE ts ALTER d TYPE text;
+
+ALTER TABLE t1 RENAME a TO aa;
+ALTER TABLE t1 RENAME b TO bb;		-- to be failed
+ALTER TABLE ts RENAME aa TO aaa;	-- to be failed
+ALTER TABLE ts RENAME d TO dd;
+\d+ ts
+
+DROP TABLE ts;
+
+-- Test for renaming and type changes (diamond inheritance)
+CREATE TABLE t2 (x int) INHERITS (t1);
+CREATE TABLE t3 (y int) INHERITS (t1);
+CREATE TABLE t4 (z int) INHERITS (t2, t3);
+
+ALTER TABLE t1 ALTER aa TYPE float;
+ALTER TABLE t1 RENAME aa TO aaa;
+\d+ t4
+
+CREATE TABLE ts (d int) INHERITS (t2, s1);
+ALTER TABLE t1 ALTER aaa TYPE text;
+ALTER TABLE t1 ALTER b TYPE text;	-- to be failed
+ALTER TABLE t1 RENAME aaa TO aaaa;
+ALTER TABLE t1 RENAME b TO bb;		-- to be failed
+\d+ ts
+
+DROP TABLE t1, s1 CASCADE;

 src/backend/catalog/pg_inherits.c     |   85 ++++++++++++++++++++++++
 src/backend/commands/alter.c          |    1 +
 src/backend/commands/tablecmds.c      |  114 +++++++++++++++++++++++++++------
 src/include/catalog/pg_inherits_fn.h  |    4 +
 src/include/commands/tablecmds.h      |    1 +
 src/test/regress/expected/inherit.out |   78 ++++++++++++++++++++++
 src/test/regress/sql/inherit.sql      |   36 ++++++++++
 7 files changed, 299 insertions(+), 20 deletions(-)

diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
index e256f6f..4fb8a25 100644
--- a/src/backend/catalog/pg_inherits.c
+++ b/src/backend/catalog/pg_inherits.c
@@ -190,6 +190,91 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
 	return rels_list;
 }
 
+/*
+ * find_all_inheritors_with_inhcount
+ *
+ * It is same as find_all_inheritors, except for it returns an excepted
+ * inhcount for each child relations.
+ * The expected inhcount means the number of times a relation is inherited
+ * from a certain origin. It shall be 1 in normal inheritance tree cases.
+ * However, if a relation has 'diamond-inheritance' structure, it may be
+ * more than 1.
+ *
+ *    T2
+ *   /  \
+ * T1    T4
+ *   \  /
+ *    T3-T5
+ *      /
+ *    S1
+ *
+ * In this case, T2 and T3 are inherited from T1, and T4 is inherited from
+ * T2 and T3. In T4, all the columns inherited from T1 are merged.
+ * The expected of T1, T2 and T3 are 1, but 2 for T4. The pg_attribute.inhcount
+ * of T4 will be 2 (if no corruption or bugs). It is not over the expected
+ * inhcount, so we can alter the column inherited from T1.
+ *
+ * If T5 is inherited from T3 and S1, the pg_attribute.inhcount of T5 will
+ * be 2. However, its expected inhcount when we try to alter T1 and its child
+ * relation is 1, because it does not have any diamond-inheritance from the
+ * series of T1. In this case, its inhcount will over the expected one, so
+ * we can prevent incorrect ALTER TABLE.
+ */
+void
+find_all_inheritors_with_inhcount(Oid parentrelId, LOCKMODE lockmode,
+								  List **child_oids, List **child_inhs)
+{
+	List	   *children, *rels_oids, *rels_inhs;
+	ListCell   *lc, *lo, *li;
+
+	/*
+	 * The root of the inheritance tree always has 1 as an expected
+	 * inhcount.
+	 */
+	rels_oids = list_make1_oid(parentrelId);
+	rels_inhs = list_make1_int(1);
+
+	children = find_inheritance_children(parentrelId, lockmode);
+	foreach (lc, children)
+	{
+		Oid		cur_relid = lfirst_oid(lc);
+		List   *cur_children;
+		bool	found = false;
+
+		forboth (lo, rels_oids, li, rels_inhs)
+		{
+			/*
+			 * If we found a duplicated relation within a certain inheritance
+			 * tree, it means a diamond-inheritance. So, we increment its
+			 * expected inhcount without appending an element to the list.
+			 */
+			if (lfirst_oid(lo) == cur_relid)
+			{
+				lfirst_int(li)++;
+				found = true;
+				break;
+			}
+		}
+
+		if (!found)
+		{
+			rels_oids = lappend_oid(rels_oids, cur_relid);
+			rels_inhs = lappend_int(rels_inhs, 1);
+		}
+
+		/*
+		 * Unlike find_all_inheritors(), we need to walk on child relations
+		 * that have diamond inheritance tree, because this function has to
+		 * return correct expected inhecount to the caller.
+		 */
+		cur_children = find_inheritance_children(cur_relid, lockmode);
+
+		children = list_concat(children, cur_children);
+	}
+
+	*child_oids = rels_oids;
+	*child_inhs = rels_inhs;
+}
 
 /*
  * has_subclass - does this relation have any children?
diff --git a/src/backend/commands/alter.c b/src/backend/commands/alter.c
index 8c81eaa..fa3279a 100644
--- a/src/backend/commands/alter.c
+++ b/src/backend/commands/alter.c
@@ -125,6 +125,7 @@ ExecRenameStmt(RenameStmt *stmt)
 						renameatt(relid,
 								  stmt->subname,		/* old att name */
 								  stmt->newname,		/* new att name */
+								  1,			/* expected inhcount */
 								  interpretInhOption(stmt->relation->inhOpt),	/* recursive? */
 								  false);		/* recursing already? */
 						break;
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 2db97dd..60d7687 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -1906,6 +1906,7 @@ void
 renameatt(Oid myrelid,
 		  const char *oldattname,
 		  const char *newattname,
+		  int expected_inhcount,
 		  bool recurse,
 		  bool recursing)
 {
@@ -1946,24 +1947,32 @@ renameatt(Oid myrelid,
 	 */
 	if (recurse)
 	{
-		ListCell   *child;
-		List	   *children;
-
-		children = find_all_inheritors(myrelid, AccessExclusiveLock);
+		List	   *child_oids, *child_inhs;
+		ListCell   *lo, *li;
 
 		/*
-		 * find_all_inheritors does the recursive search of the inheritance
-		 * hierarchy, so all we have to do is process all of the relids in the
-		 * list that it returns.
+		 * It is same as find_all_inheritors, except for it returns the
+		 * list of expected inhcount for each child relations.
+		 * It is a value to be set on pg_attribute.inhcount when the column
+		 * to be renamed is not merged with any other column which have
+		 * different origin.
+		 * If pg_attribute.inhcount is larger than the expected inhcount,
+		 * it means the column is merged from different serieses.
 		 */
-		foreach(child, children)
+		find_all_inheritors_with_inhcount(myrelid, AccessExclusiveLock,
+										  &child_oids, &child_inhs);
+
+		forboth (lo, child_oids, li, child_inhs)
 		{
-			Oid			childrelid = lfirst_oid(child);
+			Oid		child_relid = lfirst_oid(lo);
+			int		child_inhcount = lfirst_int(li);
 
-			if (childrelid == myrelid)
+			if (child_relid == myrelid)
 				continue;
+
 			/* note we need not recurse again */
-			renameatt(childrelid, oldattname, newattname, false, true);
+			renameatt(child_relid, oldattname, newattname,
+					  child_inhcount, false, true);
 		}
 	}
 	else
@@ -2007,6 +2016,17 @@ renameatt(Oid myrelid,
 				 errmsg("cannot rename inherited column \"%s\"",
 						oldattname)));
 
+	/*
+	 * if the attribute is multiple inherited, forbid the renaming,
+	 * even if we are already inside a recursive rename, because we
+	 * have no reasonable way to keep its integrity.
+	 */
+	if (attform->attinhcount > expected_inhcount)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 (errmsg("cannot rename multiple inherited column \"%s\"",
+						 oldattname))));
+
 	/* new name should not already exist */
 
 	/* this test is deliberately not attisdropped-aware */
@@ -5771,11 +5791,29 @@ ATPrepAlterColumnType(List **wqueue,
 						colName)));
 
 	/* Don't alter inherited columns */
-	if (attTup->attinhcount > 0 && !recursing)
-		ereport(ERROR,
-				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
-				 errmsg("cannot alter inherited column \"%s\"",
-						colName)));
+	if (!recursing)
+	{
+		if (attTup->attinhcount > 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+					 errmsg("cannot alter inherited column \"%s\"",
+							colName)));
+	}
+	else
+	{
+		/*
+		 * The TypeName->location is not used in this code path,
+		 * so we utilize it to store an enpected inhconunt for each
+		 * child relations.
+		 */
+		int		expected_inhcount = typeName->location;
+
+		if (attTup->attinhcount > expected_inhcount)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+					 errmsg("cannot alter multiple inherited column \"%s\"",
+							colName)));
+	}
 
 	/* Look up the target type */
 	targettype = typenameTypeId(NULL, typeName, &targettypmod);
@@ -5857,12 +5895,48 @@ ATPrepAlterColumnType(List **wqueue,
 	ReleaseSysCache(tuple);
 
 	/*
-	 * The recursion case is handled by ATSimpleRecursion.	However, if we are
-	 * told not to recurse, there had better not be any child tables; else the
-	 * alter would put them out of step.
+	 * The recursion case is not handled by ATSimpleRecursion, because we need
+	 * to compute an expected inhcount for each child relations. This value is
+	 * delivered to the recursive invocation to check unexpected type changes.
+	 * If we are told not to recurse, there had better not be any child tables;
+	 * else the alter would put them out of step.
 	 */
 	if (recurse)
-		ATSimpleRecursion(wqueue, rel, cmd, recurse);
+	{
+		Relation	child_rel;
+		List	   *child_oids;
+		List	   *child_inhs;
+		ListCell   *lo;
+		ListCell   *li;
+
+		find_all_inheritors_with_inhcount(RelationGetRelid(rel),
+										  AccessExclusiveLock,
+										  &child_oids, &child_inhs);
+		forboth(lo, child_oids, li, child_inhs)
+		{
+			AlterTableCmd  *child_cmd;
+			Relation		child_rel;
+			Oid				child_relid = lfirst_oid(lo);
+			int				child_inhcount = lfirst_int(li);
+
+			if (child_relid == RelationGetRelid(rel))
+				continue;
+
+			/*
+			 * The TypeName->location is not used in this code path,
+			 * so we utilize it to store an expected inhcount for each
+			 * child relation.
+			 */
+			child_cmd = copyObject(cmd);
+			((TypeName *)child_cmd->def)->location = child_inhcount;
+
+			/* find_all_inheritors_with_inhcount already got lock  */
+			child_rel = relation_open(child_relid, NoLock);
+			CheckTableNotInUse(child_rel, "ALTER TABLE");
+			ATPrepCmd(wqueue, child_rel, child_cmd, false, true);
+			relation_close(child_rel, NoLock);
+		}
+	}
 	else if (!recursing &&
 			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
 		ereport(ERROR,
diff --git a/src/include/catalog/pg_inherits_fn.h b/src/include/catalog/pg_inherits_fn.h
index 91baec3..e750fcd 100644
--- a/src/include/catalog/pg_inherits_fn.h
+++ b/src/include/catalog/pg_inherits_fn.h
@@ -19,6 +19,10 @@
 
 extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
 extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode);
+extern void find_all_inheritors_with_inhcount(Oid parentrelId,
+											  LOCKMODE lockmode,
+											  List **child_oids,
+											  List **child_inhs);
 extern bool has_subclass(Oid relationId);
 extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
 
diff --git a/src/include/commands/tablecmds.h b/src/include/commands/tablecmds.h
index 8bc716a..7f90306 100644
--- a/src/include/commands/tablecmds.h
+++ b/src/include/commands/tablecmds.h
@@ -42,6 +42,7 @@ extern void ExecuteTruncate(TruncateStmt *stmt);
 extern void renameatt(Oid myrelid,
 		  const char *oldattname,
 		  const char *newattname,
+		  int expected_inhcount,
 		  bool recurse,
 		  bool recursing);
 
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 9c83a32..8cb3db8 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1053,3 +1053,81 @@ NOTICE:  merging column "a" with inherited definition
 ERROR:  column "a" has a storage parameter conflict
 DETAIL:  MAIN versus EXTENDED
 DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+-- Test for renaming and type changes (simple multiple inheritance)
+CREATE TABLE t1 (a int, b int);
+CREATE TABLE s1 (b int, c int);
+CREATE TABLE ts (d int) INHERITS (t1, s1);
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE s1 ALTER b TYPE float;    -- to be failed
+ERROR:  cannot alter multiple inherited column "b"
+ALTER TABLE s1 ALTER c TYPE float;
+ALTER TABLE ts ALTER c TYPE text;     -- to be failed
+ERROR:  cannot alter inherited column "c"
+ALTER TABLE ts ALTER d TYPE text;
+ALTER TABLE t1 RENAME a TO aa;
+ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ERROR:  cannot rename multiple inherited column "b"
+ALTER TABLE ts RENAME aa TO aaa;      -- to be failed
+ERROR:  cannot rename inherited column "aa"
+ALTER TABLE ts RENAME d TO dd;
+\d+ ts
+                       Table "public.ts"
+ Column |       Type       | Modifiers | Storage  | Description 
+--------+------------------+-----------+----------+-------------
+ aa     | integer          |           | plain    | 
+ b      | integer          |           | plain    | 
+ c      | double precision |           | plain    | 
+ dd     | text             |           | extended | 
+Inherits: t1,
+          s1
+Has OIDs: no
+
+DROP TABLE ts;
+-- Test for renaming and type changes (diamond inheritance)
+CREATE TABLE t2 (x int) INHERITS (t1);
+CREATE TABLE t3 (y int) INHERITS (t1);
+CREATE TABLE t4 (z int) INHERITS (t2, t3);
+NOTICE:  merging multiple inherited definitions of column "aa"
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE t1 ALTER aa TYPE float;
+ALTER TABLE t1 RENAME aa TO aaa;
+\d+ t4
+                       Table "public.t4"
+ Column |       Type       | Modifiers | Storage | Description 
+--------+------------------+-----------+---------+-------------
+ aaa    | double precision |           | plain   | 
+ b      | integer          |           | plain   | 
+ x      | integer          |           | plain   | 
+ y      | integer          |           | plain   | 
+ z      | integer          |           | plain   | 
+Inherits: t2,
+          t3
+Has OIDs: no
+
+CREATE TABLE ts (d int) INHERITS (t2, s1);
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE t1 ALTER aaa TYPE text;
+ALTER TABLE t1 ALTER b TYPE text;     -- to be failed
+ERROR:  cannot alter multiple inherited column "b"
+ALTER TABLE t1 RENAME aaa TO aaaa;
+ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ERROR:  cannot rename multiple inherited column "b"
+\d+ ts
+                       Table "public.ts"
+ Column |       Type       | Modifiers | Storage  | Description 
+--------+------------------+-----------+----------+-------------
+ aaaa   | text             |           | extended | 
+ b      | integer          |           | plain    | 
+ x      | integer          |           | plain    | 
+ c      | double precision |           | plain    | 
+ d      | integer          |           | plain    | 
+Inherits: t2,
+          s1
+Has OIDs: no
+
+DROP TABLE t1, s1 CASCADE;
+NOTICE:  drop cascades to 4 other objects
+DETAIL:  drop cascades to table t2
+drop cascades to table ts
+drop cascades to table t3
+drop cascades to table t4
diff --git a/src/test/regress/sql/inherit.sql b/src/test/regress/sql/inherit.sql
index 192e860..76fe589 100644
--- a/src/test/regress/sql/inherit.sql
+++ b/src/test/regress/sql/inherit.sql
@@ -334,3 +334,39 @@ CREATE TABLE inh_error1 () INHERITS (t1, t4);
 CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
 
 DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+
+-- Test for renaming and type changes (simple multiple inheritance)
+CREATE TABLE t1 (a int, b int);
+CREATE TABLE s1 (b int, c int);
+CREATE TABLE ts (d int) INHERITS (t1, s1);
+
+ALTER TABLE s1 ALTER b TYPE float;    -- to be failed
+ALTER TABLE s1 ALTER c TYPE float;
+ALTER TABLE ts ALTER c TYPE text;     -- to be failed
+ALTER TABLE ts ALTER d TYPE text;
+
+ALTER TABLE t1 RENAME a TO aa;
+ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ALTER TABLE ts RENAME aa TO aaa;      -- to be failed
+ALTER TABLE ts RENAME d TO dd;
+\d+ ts
+
+DROP TABLE ts;
+
+-- Test for renaming and type changes (diamond inheritance)
+CREATE TABLE t2 (x int) INHERITS (t1);
+CREATE TABLE t3 (y int) INHERITS (t1);
+CREATE TABLE t4 (z int) INHERITS (t2, t3);
+
+ALTER TABLE t1 ALTER aa TYPE float;
+ALTER TABLE t1 RENAME aa TO aaa;
+\d+ t4
+
+CREATE TABLE ts (d int) INHERITS (t2, s1);
+ALTER TABLE t1 ALTER aaa TYPE text;
+ALTER TABLE t1 ALTER b TYPE text;     -- to be failed
+ALTER TABLE t1 RENAME aaa TO aaaa;
+ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+\d+ ts
+
+DROP TABLE t1, s1 CASCADE;

*** a/src/backend/catalog/pg_inherits.c
--- b/src/backend/catalog/pg_inherits.c
***************
*** 158,164 **** List *
  find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
  {
  	List	   *rels_list;
! 	ListCell   *l;
  
  	/*
  	 * We build a list starting with the given rel and adding all direct and
--- 158,212 ----
  find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
  {
  	List	   *rels_list;
! 
! 	find_all_inheritors_with_inhcount(parentrelId, lockmode,
! 									  &rels_list, NULL);
! 
! 	return rels_list;
! }
! 
! /*
!  * find_all_inheritors_with_inhcount
!  *
!  *		It returns a list of relations OIDs including the given rel plus
!  *		all relations that inherit from it, directly or indirectly.
!  *		In addition, it also returns the expected inhcount for them.
!  *
!  * The expected inhcount means the number of times a certain relation being
!  * inherited from any other relations which were inherited from the root
!  * of inheritance tree directly or indirectly.
!  *
!  * It is used to control some of ALTER TABLE operations on columns inherited
!  * from a relation. For example, an inherited column must has same name
!  * within the series of inheritance. So, we need to prevent renaming when
!  * the column to be renamed is delivered from multiple independent relations.
!  *
!  * The specified lock type is acquired on all child relations (but not on the
!  * given rel; caller should already have locked it).  If lockmode is NoLock
!  * then no locks are acquired, but caller must beware of race conditions
!  * against possible DROPs of child relations.
!  *
!  *    T2     For example, T2 and T3 are inherited from T1, T4 is inherited
!  *   /  \    from T2 and T3. And, T5 is inherited from T3 and S1.
!  * T1    T4  When we try to rename a column within T1, it needs to rename
!  *   \  /    inherited column in the child relations also.
!  *    T3-T5  If attinhcount of the column is larger than its expected inhcount,
!  *      /    it means the column is delivered from the different origin, so
!  *    S1     we have to prevent this operations to keep database integrity.
!  *
!  * In this example, the expected inhcount is 1 in T2, T3 and T5, and 2 in T4.
!  * The column inherited from T1 has attinhcount = 2 in T4, so it does not
!  * prevent renaming.
!  *
!  * If the column inherited from T1 has attinhcount = 2 in T5, it means the
!  * column was also inherited from S1, so we can prevent renaming it.
!  */
! void
! find_all_inheritors_with_inhcount(Oid parentrelId, LOCKMODE lockmode,
! 								  List **child_oids, List **child_inhs)
! {
! 	List	   *rels_oids, *rels_inhs;
! 	ListCell   *cell;
  
  	/*
  	 * We build a list starting with the given rel and adding all direct and
***************
*** 166,196 **** find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
  	 * already-found rels and the agenda of rels yet to be scanned for more
  	 * children.  This is a bit tricky but works because the foreach() macro
  	 * doesn't fetch the next list element until the bottom of the loop.
  	 */
! 	rels_list = list_make1_oid(parentrelId);
  
! 	foreach(l, rels_list)
  	{
! 		Oid			currentrel = lfirst_oid(l);
! 		List	   *currentchildren;
  
  		/* Get the direct children of this rel */
! 		currentchildren = find_inheritance_children(currentrel, lockmode);
  
! 		/*
! 		 * Add to the queue only those children not already seen. This avoids
! 		 * making duplicate entries in case of multiple inheritance paths from
! 		 * the same parent.  (It'll also keep us from getting into an infinite
! 		 * loop, though theoretically there can't be any cycles in the
! 		 * inheritance graph anyway.)
! 		 */
! 		rels_list = list_concat_unique_oid(rels_list, currentchildren);
  	}
  
! 	return rels_list;
  }
  
- 
  /*
   * has_subclass - does this relation have any children?
   *
--- 214,274 ----
  	 * already-found rels and the agenda of rels yet to be scanned for more
  	 * children.  This is a bit tricky but works because the foreach() macro
  	 * doesn't fetch the next list element until the bottom of the loop.
+ 	 *
+ 	 * The root of the inheritance tree always has 0 as an expected inhcount,
+ 	 * because its parent, even if exists, it is never contained within the
+ 	 * inheritance tree originally delivered from the root.
  	 */
! 	rels_oids = list_make1_oid(parentrelId);
! 	rels_inhs = list_make1_int(0);
  
! 	foreach (cell, rels_oids)
  	{
! 		Oid			cur_relid = lfirst_oid(cell);
! 		Oid			temp_relid;
! 		List	   *temp;
! 		ListCell   *lt, *lo, *li;
  
  		/* Get the direct children of this rel */
! 		temp = find_inheritance_children(cur_relid, lockmode);
  
! 		foreach (lt, temp)
! 		{
! 			Oid		temp_relid = lfirst_oid(lt);
! 			bool	found = false;
! 
! 			/*
! 			 * Add to the queue only those children not already seen.
! 			 * This avoids making duplicate entries in case of multiple
! 			 * inheritance paths from the same parent.  (It'll also keep
! 			 * us from getting into an infinite loop, though theoretically
! 			 * there can't be any cycles in the inheritance graph anyway.)
! 			 */
! 			forboth (lo, rels_oids, li, rels_inhs)
! 			{
! 				if (lfirst_oid(lo) == temp_relid)
! 				{
! 					/* increment its expected inhcount */
! 					lfirst_int(li)++;
! 					found = true;
! 					break;
! 				}
! 			}
! 
! 			if (!found)
! 			{
! 				rels_oids = lappend_oid(rels_oids, temp_relid);
! 				rels_inhs = lappend_int(rels_inhs, 1);
! 			}
! 		}
  	}
  
! 	if (child_oids)
! 		*child_oids = rels_oids;
! 	if (child_inhs)
! 		*child_inhs = rels_inhs;
  }
  
  /*
   * has_subclass - does this relation have any children?
   *
*** a/src/backend/commands/alter.c
--- b/src/backend/commands/alter.c
***************
*** 125,130 **** ExecRenameStmt(RenameStmt *stmt)
--- 125,131 ----
  						renameatt(relid,
  								  stmt->subname,		/* old att name */
  								  stmt->newname,		/* new att name */
+ 								  0,			/* expected inhcount */
  								  interpretInhOption(stmt->relation->inhOpt),	/* recursive? */
  								  false);		/* recursing already? */
  						break;
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 1906,1911 **** void
--- 1906,1912 ----
  renameatt(Oid myrelid,
  		  const char *oldattname,
  		  const char *newattname,
+ 		  int expected_inhcount,
  		  bool recurse,
  		  bool recursing)
  {
***************
*** 1946,1969 **** renameatt(Oid myrelid,
  	 */
  	if (recurse)
  	{
! 		ListCell   *child;
! 		List	   *children;
! 
! 		children = find_all_inheritors(myrelid, AccessExclusiveLock);
  
  		/*
! 		 * find_all_inheritors does the recursive search of the inheritance
! 		 * hierarchy, so all we have to do is process all of the relids in the
! 		 * list that it returns.
  		 */
! 		foreach(child, children)
  		{
! 			Oid			childrelid = lfirst_oid(child);
  
! 			if (childrelid == myrelid)
  				continue;
  			/* note we need not recurse again */
! 			renameatt(childrelid, oldattname, newattname, false, true);
  		}
  	}
  	else
--- 1947,1978 ----
  	 */
  	if (recurse)
  	{
! 		List	   *child_oids, *child_inhs;
! 		ListCell   *lo, *li;
  
  		/*
! 		 * It is same as find_all_inheritors, except for it returns the
! 		 * list of expected inhcount for each child relations.
! 		 * It is a value to be set on pg_attribute.inhcount when the column
! 		 * to be renamed is not merged with any other column which have
! 		 * different origin.
! 		 * If pg_attribute.inhcount is larger than the expected inhcount,
! 		 * it means the column is merged from different serieses.
  		 */
! 		find_all_inheritors_with_inhcount(myrelid, AccessExclusiveLock,
! 										  &child_oids, &child_inhs);
! 
! 		forboth (lo, child_oids, li, child_inhs)
  		{
! 			Oid		child_relid = lfirst_oid(lo);
! 			int		child_inhcount = lfirst_int(li);
  
! 			if (child_relid == myrelid)
  				continue;
+ 
  			/* note we need not recurse again */
! 			renameatt(child_relid, oldattname, newattname,
! 					  child_inhcount, false, true);
  		}
  	}
  	else
***************
*** 2007,2012 **** renameatt(Oid myrelid,
--- 2016,2032 ----
  				 errmsg("cannot rename inherited column \"%s\"",
  						oldattname)));
  
+ 	/*
+ 	 * if the attribute is multiple inherited, forbid the renaming,
+ 	 * even if we are already inside a recursive rename, because we
+ 	 * have no reasonable way to keep its integrity.
+ 	 */
+ 	if (attform->attinhcount > expected_inhcount)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ 				 (errmsg("cannot rename multiple inherited column \"%s\"",
+ 						 oldattname))));
+ 
  	/* new name should not already exist */
  
  	/* this test is deliberately not attisdropped-aware */
***************
*** 5772,5782 **** ATPrepAlterColumnType(List **wqueue,
  						colName)));
  
  	/* Don't alter inherited columns */
! 	if (attTup->attinhcount > 0 && !recursing)
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
! 				 errmsg("cannot alter inherited column \"%s\"",
! 						colName)));
  
  	/* Look up the target type */
  	targettype = typenameTypeId(NULL, typeName, &targettypmod);
--- 5792,5820 ----
  						colName)));
  
  	/* Don't alter inherited columns */
! 	if (!recursing)
! 	{
! 		if (attTup->attinhcount > 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
! 					 errmsg("cannot alter inherited column \"%s\"",
! 							colName)));
! 	}
! 	else
! 	{
! 		/*
! 		 * The TypeName->location is not used in this code path,
! 		 * so we utilize it to store an enpected inhconunt for each
! 		 * child relations.
! 		 */
! 		int		expected_inhcount = typeName->location;
! 
! 		if (attTup->attinhcount > expected_inhcount)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
! 					 errmsg("cannot alter multiple inherited column \"%s\"",
! 							colName)));
! 	}
  
  	/* Look up the target type */
  	targettype = typenameTypeId(NULL, typeName, &targettypmod);
***************
*** 5858,5869 **** ATPrepAlterColumnType(List **wqueue,
  	ReleaseSysCache(tuple);
  
  	/*
! 	 * The recursion case is handled by ATSimpleRecursion.	However, if we are
! 	 * told not to recurse, there had better not be any child tables; else the
! 	 * alter would put them out of step.
  	 */
  	if (recurse)
! 		ATSimpleRecursion(wqueue, rel, cmd, recurse);
  	else if (!recursing &&
  			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
  		ereport(ERROR,
--- 5896,5943 ----
  	ReleaseSysCache(tuple);
  
  	/*
! 	 * The recursion case is not handled by ATSimpleRecursion, because we need
! 	 * to compute an expected inhcount for each child relations. This value is
! 	 * delivered to the recursive invocation to check unexpected type changes.
! 	 * If we are told not to recurse, there had better not be any child tables;
! 	 * else the alter would put them out of step.
  	 */
  	if (recurse)
! 	{
! 		Relation	child_rel;
! 		List	   *child_oids;
! 		List	   *child_inhs;
! 		ListCell   *lo;
! 		ListCell   *li;
! 
! 		find_all_inheritors_with_inhcount(RelationGetRelid(rel),
! 										  AccessExclusiveLock,
! 										  &child_oids, &child_inhs);
! 		forboth(lo, child_oids, li, child_inhs)
! 		{
! 			AlterTableCmd  *child_cmd;
! 			Relation		child_rel;
! 			Oid				child_relid = lfirst_oid(lo);
! 			int				child_inhcount = lfirst_int(li);
! 
! 			if (child_relid == RelationGetRelid(rel))
! 				continue;
! 
! 			/*
! 			 * The TypeName->location is not used in this code path,
! 			 * so we utilize it to store an expected inhcount for each
! 			 * child relation.
! 			 */
! 			child_cmd = copyObject(cmd);
! 			((TypeName *)child_cmd->def)->location = child_inhcount;
! 
! 			/* find_all_inheritors_with_inhcount already got lock  */
! 			child_rel = relation_open(child_relid, NoLock);
! 			CheckTableNotInUse(child_rel, "ALTER TABLE");
! 			ATPrepCmd(wqueue, child_rel, child_cmd, false, true);
! 			relation_close(child_rel, NoLock);
! 		}
! 	}
  	else if (!recursing &&
  			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
  		ereport(ERROR,
*** a/src/include/catalog/pg_inherits_fn.h
--- b/src/include/catalog/pg_inherits_fn.h
***************
*** 19,24 ****
--- 19,28 ----
  
  extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
  extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode);
+ extern void find_all_inheritors_with_inhcount(Oid parentrelId,
+ 											  LOCKMODE lockmode,
+ 											  List **child_oids,
+ 											  List **child_inhs);
  extern bool has_subclass(Oid relationId);
  extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
  
*** a/src/include/commands/tablecmds.h
--- b/src/include/commands/tablecmds.h
***************
*** 42,47 **** extern void ExecuteTruncate(TruncateStmt *stmt);
--- 42,48 ----
  extern void renameatt(Oid myrelid,
  		  const char *oldattname,
  		  const char *newattname,
+ 		  int expected_inhcount,
  		  bool recurse,
  		  bool recursing);
  
*** a/src/test/regress/expected/inherit.out
--- b/src/test/regress/expected/inherit.out
***************
*** 1053,1055 **** NOTICE:  merging column "a" with inherited definition
--- 1053,1158 ----
  ERROR:  column "a" has a storage parameter conflict
  DETAIL:  MAIN versus EXTENDED
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ -- Test for renaming and type changes (simple multiple inheritance)
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE s1 (b int, c int);
+ CREATE TABLE ts (d int) INHERITS (t1, s1);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE s1 ALTER b TYPE float;    -- to be failed
+ ERROR:  cannot alter multiple inherited column "b"
+ ALTER TABLE s1 ALTER c TYPE float;
+ ALTER TABLE ts ALTER c TYPE text;     -- to be failed
+ ERROR:  cannot alter inherited column "c"
+ ALTER TABLE ts ALTER d TYPE text;
+ ALTER TABLE t1 RENAME a TO aa;
+ ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ ALTER TABLE ts RENAME aa TO aaa;      -- to be failed
+ ERROR:  cannot rename inherited column "aa"
+ ALTER TABLE ts RENAME d TO dd;
+ \d+ ts
+                        Table "public.ts"
+  Column |       Type       | Modifiers | Storage  | Description 
+ --------+------------------+-----------+----------+-------------
+  aa     | integer          |           | plain    | 
+  b      | integer          |           | plain    | 
+  c      | double precision |           | plain    | 
+  dd     | text             |           | extended | 
+ Inherits: t1,
+           s1
+ Has OIDs: no
+ 
+ DROP TABLE ts;
+ -- Test for renaming and type changes (diamond inheritance)
+ CREATE TABLE t2 (x int) INHERITS (t1);
+ CREATE TABLE t3 (y int) INHERITS (t1);
+ CREATE TABLE t4 (z int) INHERITS (t2, t3);
+ NOTICE:  merging multiple inherited definitions of column "aa"
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 ALTER aa TYPE float;
+ ALTER TABLE t1 RENAME aa TO aaa;
+ \d+ t4
+                        Table "public.t4"
+  Column |       Type       | Modifiers | Storage | Description 
+ --------+------------------+-----------+---------+-------------
+  aaa    | double precision |           | plain   | 
+  b      | integer          |           | plain   | 
+  x      | integer          |           | plain   | 
+  y      | integer          |           | plain   | 
+  z      | integer          |           | plain   | 
+ Inherits: t2,
+           t3
+ Has OIDs: no
+ 
+ CREATE TABLE ts (d int) INHERITS (t2, s1);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 ALTER aaa TYPE text;
+ ALTER TABLE t1 ALTER b TYPE text;             -- to be failed
+ ERROR:  cannot alter multiple inherited column "b"
+ ALTER TABLE t1 RENAME aaa TO aaaa;
+ ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ \d+ ts
+                        Table "public.ts"
+  Column |       Type       | Modifiers | Storage  | Description 
+ --------+------------------+-----------+----------+-------------
+  aaaa   | text             |           | extended | 
+  b      | integer          |           | plain    | 
+  x      | integer          |           | plain    | 
+  c      | double precision |           | plain    | 
+  d      | integer          |           | plain    | 
+ Inherits: t2,
+           s1
+ Has OIDs: no
+ 
+ WITH RECURSIVE r AS (
+   SELECT 't1'::regclass AS inhrelid
+ UNION ALL
+   SELECT c.inhrelid FROM pg_inherits c, r WHERE r.inhrelid = c.inhparent
+ )
+ SELECT attrelid::regclass, attname, attinhcount, r.expected
+   FROM (SELECT inhrelid, count(*) AS expected FROM pg_inherits
+         WHERE inhparent IN (SELECT inhrelid FROM r) GROUP BY inhrelid) r
+   JOIN pg_attribute a ON r.inhrelid = a.attrelid WHERE attislocal = false;
+  attrelid | attname | attinhcount | expected 
+ ----------+---------+-------------+----------
+  t2       | b       |           1 |        1
+  t3       | b       |           1 |        1
+  t4       | b       |           2 |        2
+  t4       | x       |           1 |        2
+  t4       | y       |           1 |        2
+  t2       | aaaa    |           1 |        1
+  t3       | aaaa    |           1 |        1
+  t4       | aaaa    |           2 |        2
+  ts       | b       |           2 |        1
+  ts       | x       |           1 |        1
+  ts       | c       |           1 |        1
+  ts       | aaaa    |           1 |        1
+ (12 rows)
+ 
+ DROP TABLE t1, s1 CASCADE;
+ NOTICE:  drop cascades to 4 other objects
+ DETAIL:  drop cascades to table t2
+ drop cascades to table ts
+ drop cascades to table t3
+ drop cascades to table t4
*** a/src/test/regress/sql/inherit.sql
--- b/src/test/regress/sql/inherit.sql
***************
*** 334,336 **** CREATE TABLE inh_error1 () INHERITS (t1, t4);
--- 334,382 ----
  CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
  
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ 
+ -- Test for renaming and type changes (simple multiple inheritance)
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE s1 (b int, c int);
+ CREATE TABLE ts (d int) INHERITS (t1, s1);
+ 
+ ALTER TABLE s1 ALTER b TYPE float;    -- to be failed
+ ALTER TABLE s1 ALTER c TYPE float;
+ ALTER TABLE ts ALTER c TYPE text;     -- to be failed
+ ALTER TABLE ts ALTER d TYPE text;
+ 
+ ALTER TABLE t1 RENAME a TO aa;
+ ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ ALTER TABLE ts RENAME aa TO aaa;      -- to be failed
+ ALTER TABLE ts RENAME d TO dd;
+ \d+ ts
+ 
+ DROP TABLE ts;
+ 
+ -- Test for renaming and type changes (diamond inheritance)
+ CREATE TABLE t2 (x int) INHERITS (t1);
+ CREATE TABLE t3 (y int) INHERITS (t1);
+ CREATE TABLE t4 (z int) INHERITS (t2, t3);
+ 
+ ALTER TABLE t1 ALTER aa TYPE float;
+ ALTER TABLE t1 RENAME aa TO aaa;
+ \d+ t4
+ 
+ CREATE TABLE ts (d int) INHERITS (t2, s1);
+ ALTER TABLE t1 ALTER aaa TYPE text;
+ ALTER TABLE t1 ALTER b TYPE text;             -- to be failed
+ ALTER TABLE t1 RENAME aaa TO aaaa;
+ ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ \d+ ts
+ 
+ WITH RECURSIVE r AS (
+   SELECT 't1'::regclass AS inhrelid
+ UNION ALL
+   SELECT c.inhrelid FROM pg_inherits c, r WHERE r.inhrelid = c.inhparent
+ )
+ SELECT attrelid::regclass, attname, attinhcount, r.expected
+   FROM (SELECT inhrelid, count(*) AS expected FROM pg_inherits
+         WHERE inhparent IN (SELECT inhrelid FROM r) GROUP BY inhrelid) r
+   JOIN pg_attribute a ON r.inhrelid = a.attrelid WHERE attislocal = false;
+ 
+ DROP TABLE t1, s1 CASCADE;

*** a/src/backend/catalog/pg_inherits.c
--- b/src/backend/catalog/pg_inherits.c
***************
*** 148,163 **** find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
   * find_all_inheritors -
   *		Returns a list of relation OIDs including the given rel plus
   *		all relations that inherit from it, directly or indirectly.
   *
   * The specified lock type is acquired on all child relations (but not on the
   * given rel; caller should already have locked it).  If lockmode is NoLock
   * then no locks are acquired, but caller must beware of race conditions
   * against possible DROPs of child relations.
   */
! List *
! find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
  {
! 	List	   *rels_list;
  	ListCell   *l;
  
  	/*
--- 148,194 ----
   * find_all_inheritors -
   *		Returns a list of relation OIDs including the given rel plus
   *		all relations that inherit from it, directly or indirectly.
+  *		In addition, it also returns the expected inhcount for them.
   *
   * The specified lock type is acquired on all child relations (but not on the
   * given rel; caller should already have locked it).  If lockmode is NoLock
   * then no locks are acquired, but caller must beware of race conditions
   * against possible DROPs of child relations.
+  *
+  * The expected inhcount means the number of times a certain relation being
+  * inherited from any other relations which were inherited from the root
+  * of inheritance tree directly or indirectly.
+  *
+  * It is used to control some of ALTER TABLE operations on columns inherited
+  * from a relation. For example, an inherited column must has same name
+  * within the series of inheritance. So, we need to prevent renaming when
+  * the column to be renamed is delivered from multiple independent relations.
+  *
+  * The specified lock type is acquired on all child relations (but not on the
+  * given rel; caller should already have locked it).  If lockmode is NoLock
+  * then no locks are acquired, but caller must beware of race conditions
+  * against possible DROPs of child relations.
+  *
+  *    T2     For example, T2 and T3 are inherited from T1, T4 is inherited
+  *   /  \    from T2 and T3. And, T5 is inherited from T3 and S1.
+  * T1    T4  When we try to rename a column within T1, it needs to rename
+  *   \  /    inherited column in the child relations also.
+  *    T3-T5  If attinhcount of the column is larger than its expected inhcount,
+  *      /    it means the column is delivered from the different origin, so
+  *    S1     we have to prevent this operations to keep database integrity.
+  *
+  * In this example, the expected inhcount is 1 in T2, T3 and T5, and 2 in T4.
+  * The column inherited from T1 has attinhcount = 2 in T4, so it does not
+  * prevent renaming.
+  *
+  * If the column inherited from T1 has attinhcount = 2 in T5, it means the
+  * column was also inherited from S1, so we can prevent renaming it.
   */
! void
! find_all_inheritors(Oid parentrelId, LOCKMODE lockmode,
! 					List **child_oids, List **child_inhs)
  {
! 	List	   *rel_oids, *rel_inhs;
  	ListCell   *l;
  
  	/*
***************
*** 167,193 **** find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
  	 * children.  This is a bit tricky but works because the foreach() macro
  	 * doesn't fetch the next list element until the bottom of the loop.
  	 */
! 	rels_list = list_make1_oid(parentrelId);
  
! 	foreach(l, rels_list)
  	{
! 		Oid			currentrel = lfirst_oid(l);
! 		List	   *currentchildren;
  
  		/* Get the direct children of this rel */
! 		currentchildren = find_inheritance_children(currentrel, lockmode);
  
! 		/*
! 		 * Add to the queue only those children not already seen. This avoids
! 		 * making duplicate entries in case of multiple inheritance paths from
! 		 * the same parent.  (It'll also keep us from getting into an infinite
! 		 * loop, though theoretically there can't be any cycles in the
! 		 * inheritance graph anyway.)
! 		 */
! 		rels_list = list_concat_unique_oid(rels_list, currentchildren);
  	}
  
! 	return rels_list;
  }
  
  
--- 198,257 ----
  	 * children.  This is a bit tricky but works because the foreach() macro
  	 * doesn't fetch the next list element until the bottom of the loop.
  	 */
! 	rel_oids = list_make1_oid(parentrelId);
! 	rel_inhs = list_make1_int(0);
  
! 	foreach(l, rel_oids)
  	{
! 		Oid			cur_relid = lfirst_oid(l);
! 		Oid			temp_relid;
! 		List	   *temp;
! 		ListCell   *lt, *lo, *li;
  
  		/* Get the direct children of this rel */
! 		temp = find_inheritance_children(cur_relid, lockmode);
  
! 		foreach(lt, temp)
! 		{
! 			Oid		temp_relid = lfirst_oid(lt);
! 			bool	found = false;
! 
! 			/*
! 			 * Add to the queue only those children not already seen.
! 			 * This avoids making duplicate entries in case of multiple
! 			 * inheritance paths from the same parent.  (It'll also keep
! 			 * us from getting into an infinite loop, though theoretically
! 			 * there can't be any cycles in the inheritance graph anyway.)
! 			 */
! 			forboth(lo, rel_oids, li, rel_inhs)
! 			{
! 				/*
! 				 * Increment its expected inhcount, if the child relation
! 				 * is already chained to the rel_oids due to the diamond
! 				 * inheritance tree. In this case, we don't need to chain
! 				 * a new entry into the list.
! 				 */
! 
! 				if (lfirst_oid(lo) == temp_relid)
! 				{
! 					lfirst_int(li)++;
! 					found = true;
! 					break;
! 				}
! 			}
! 
! 			if (!found)
! 			{
! 				rel_oids = lappend_oid(rel_oids, temp_relid);
! 				rel_inhs = lappend_int(rel_inhs, 1);
! 			}
! 		}
  	}
  
! 	if (child_oids)
! 		*child_oids = rel_oids;
! 	if (child_inhs)
! 		*child_inhs = rel_inhs;
  }
  
  
*** a/src/backend/commands/alter.c
--- b/src/backend/commands/alter.c
***************
*** 125,130 **** ExecRenameStmt(RenameStmt *stmt)
--- 125,131 ----
  						renameatt(relid,
  								  stmt->subname,		/* old att name */
  								  stmt->newname,		/* new att name */
+ 								  0,			/* expected inhcount */
  								  interpretInhOption(stmt->relation->inhOpt),	/* recursive? */
  								  false);		/* recursing already? */
  						break;
*** a/src/backend/commands/analyze.c
--- b/src/backend/commands/analyze.c
***************
*** 1390,1396 **** acquire_inherited_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
  	 * Find all members of inheritance set.  We only need AccessShareLock on
  	 * the children.
  	 */
! 	tableOIDs = find_all_inheritors(RelationGetRelid(onerel), AccessShareLock);
  
  	/*
  	 * Check that there's at least one descendant, else fail.  This could
--- 1390,1397 ----
  	 * Find all members of inheritance set.  We only need AccessShareLock on
  	 * the children.
  	 */
! 	find_all_inheritors(RelationGetRelid(onerel), AccessShareLock,
! 						&tableOIDs, NULL);
  
  	/*
  	 * Check that there's at least one descendant, else fail.  This could
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 824,830 **** ExecuteTruncate(TruncateStmt *stmt)
  			ListCell   *child;
  			List	   *children;
  
! 			children = find_all_inheritors(myrelid, AccessExclusiveLock);
  
  			foreach(child, children)
  			{
--- 824,831 ----
  			ListCell   *child;
  			List	   *children;
  
! 			find_all_inheritors(myrelid, AccessExclusiveLock,
! 								&children, NULL);
  
  			foreach(child, children)
  			{
***************
*** 1942,1947 **** void
--- 1943,1949 ----
  renameatt(Oid myrelid,
  		  const char *oldattname,
  		  const char *newattname,
+ 		  int expected_inhcount,
  		  bool recurse,
  		  bool recursing)
  {
***************
*** 1987,2010 **** renameatt(Oid myrelid,
  	 */
  	if (recurse)
  	{
! 		ListCell   *child;
! 		List	   *children;
! 
! 		children = find_all_inheritors(myrelid, AccessExclusiveLock);
  
  		/*
  		 * find_all_inheritors does the recursive search of the inheritance
  		 * hierarchy, so all we have to do is process all of the relids in the
  		 * list that it returns.
  		 */
! 		foreach(child, children)
  		{
! 			Oid			childrelid = lfirst_oid(child);
  
! 			if (childrelid == myrelid)
  				continue;
  			/* note we need not recurse again */
! 			renameatt(childrelid, oldattname, newattname, false, true);
  		}
  	}
  	else
--- 1989,2019 ----
  	 */
  	if (recurse)
  	{
! 		List	   *child_oids, *child_inhs;
! 		ListCell   *lo, *li;
  
  		/*
  		 * find_all_inheritors does the recursive search of the inheritance
  		 * hierarchy, so all we have to do is process all of the relids in the
  		 * list that it returns.
+ 		 * Also, we need the list of expected inhcount, since it has to be
+ 		 * forbidden to rename a column that is inherited from different
+ 		 * origin. (Note that we allow diamond-inheritance tree)
  		 */
! 		find_all_inheritors(myrelid, AccessExclusiveLock,
! 							&child_oids, &child_inhs);
! 
! 		forboth(lo, child_oids, li, child_inhs)
  		{
! 			Oid		child_relid = lfirst_oid(lo);
! 			int		child_inhcount = lfirst_int(li);
  
! 			if (child_relid == myrelid)
  				continue;
+ 
  			/* note we need not recurse again */
! 			renameatt(child_relid, oldattname, newattname,
! 					  child_inhcount, false, true);
  		}
  	}
  	else
***************
*** 2048,2053 **** renameatt(Oid myrelid,
--- 2057,2073 ----
  				 errmsg("cannot rename inherited column \"%s\"",
  						oldattname)));
  
+ 	/*
+ 	 * if the attribute is multiple inherited, forbid the renaming,
+ 	 * even if we are already inside a recursive rename, because we
+ 	 * have no reasonable way to keep its integrity.
+ 	 */
+ 	if (attform->attinhcount > expected_inhcount)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ 				 (errmsg("cannot rename multiple inherited column \"%s\"",
+ 						 oldattname))));
+ 
  	/* new name should not already exist */
  
  	/* this test is deliberately not attisdropped-aware */
***************
*** 3410,3416 **** ATSimpleRecursion(List **wqueue, Relation rel,
  		ListCell   *child;
  		List	   *children;
  
! 		children = find_all_inheritors(relid, AccessExclusiveLock);
  
  		/*
  		 * find_all_inheritors does the recursive search of the inheritance
--- 3430,3436 ----
  		ListCell   *child;
  		List	   *children;
  
! 		find_all_inheritors(relid, AccessExclusiveLock, &children, NULL);
  
  		/*
  		 * find_all_inheritors does the recursive search of the inheritance
***************
*** 7232,7239 **** ATExecAddInherit(Relation child_rel, RangeVar *parent)
  	 *
  	 * We use weakest lock we can on child's children, namely AccessShareLock.
  	 */
! 	children = find_all_inheritors(RelationGetRelid(child_rel),
! 								   AccessShareLock);
  
  	if (list_member_oid(children, RelationGetRelid(parent_rel)))
  		ereport(ERROR,
--- 7252,7259 ----
  	 *
  	 * We use weakest lock we can on child's children, namely AccessShareLock.
  	 */
! 	find_all_inheritors(RelationGetRelid(child_rel), AccessShareLock,
! 						&children, NULL);
  
  	if (list_member_oid(children, RelationGetRelid(parent_rel)))
  		ereport(ERROR,
*** a/src/backend/optimizer/prep/prepunion.c
--- b/src/backend/optimizer/prep/prepunion.c
***************
*** 1180,1186 **** expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
  		lockmode = AccessShareLock;
  
  	/* Scan for all members of inheritance set, acquire needed locks */
! 	inhOIDs = find_all_inheritors(parentOID, lockmode);
  
  	/*
  	 * Check that there's at least one descendant, else treat as no-child
--- 1180,1186 ----
  		lockmode = AccessShareLock;
  
  	/* Scan for all members of inheritance set, acquire needed locks */
! 	find_all_inheritors(parentOID, lockmode, &inhOIDs, NULL);
  
  	/*
  	 * Check that there's at least one descendant, else treat as no-child
*** a/src/include/catalog/pg_inherits_fn.h
--- b/src/include/catalog/pg_inherits_fn.h
***************
*** 18,24 ****
  #include "storage/lock.h"
  
  extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
! extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode);
  extern bool has_subclass(Oid relationId);
  extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
  
--- 18,25 ----
  #include "storage/lock.h"
  
  extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
! extern void find_all_inheritors(Oid parentrelId, LOCKMODE lockmode,
! 								List **child_oids, List **child_inhs);
  extern bool has_subclass(Oid relationId);
  extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
  
*** a/src/include/commands/tablecmds.h
--- b/src/include/commands/tablecmds.h
***************
*** 42,47 **** extern void ExecuteTruncate(TruncateStmt *stmt);
--- 42,48 ----
  extern void renameatt(Oid myrelid,
  		  const char *oldattname,
  		  const char *newattname,
+ 		  int expected_inhcount,
  		  bool recurse,
  		  bool recursing);
  
*** a/src/test/regress/expected/inherit.out
--- b/src/test/regress/expected/inherit.out
***************
*** 1053,1055 **** NOTICE:  merging column "a" with inherited definition
--- 1053,1148 ----
  ERROR:  column "a" has a storage parameter conflict
  DETAIL:  MAIN versus EXTENDED
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ -- Test for renaming in simple multiple inheritance
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE s1 (b int, c int);
+ CREATE TABLE ts (d int) INHERITS (t1, s1);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 RENAME a TO aa;
+ ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ ALTER TABLE ts RENAME aa TO aaa;      -- to be failed
+ ERROR:  cannot rename inherited column "aa"
+ ALTER TABLE ts RENAME d TO dd;
+ \d+ ts
+                   Table "public.ts"
+  Column |  Type   | Modifiers | Storage | Description 
+ --------+---------+-----------+---------+-------------
+  aa     | integer |           | plain   | 
+  b      | integer |           | plain   | 
+  c      | integer |           | plain   | 
+  dd     | integer |           | plain   | 
+ Inherits: t1,
+           s1
+ Has OIDs: no
+ 
+ DROP TABLE ts;
+ -- Test for renaming in diamond inheritance
+ CREATE TABLE t2 (x int) INHERITS (t1);
+ CREATE TABLE t3 (y int) INHERITS (t1);
+ CREATE TABLE t4 (z int) INHERITS (t2, t3);
+ NOTICE:  merging multiple inherited definitions of column "aa"
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 RENAME aa TO aaa;
+ \d+ t4
+                   Table "public.t4"
+  Column |  Type   | Modifiers | Storage | Description 
+ --------+---------+-----------+---------+-------------
+  aaa    | integer |           | plain   | 
+  b      | integer |           | plain   | 
+  x      | integer |           | plain   | 
+  y      | integer |           | plain   | 
+  z      | integer |           | plain   | 
+ Inherits: t2,
+           t3
+ Has OIDs: no
+ 
+ CREATE TABLE ts (d int) INHERITS (t2, s1);
+ NOTICE:  merging multiple inherited definitions of column "b"
+ ALTER TABLE t1 RENAME aaa TO aaaa;
+ ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ ERROR:  cannot rename multiple inherited column "b"
+ \d+ ts
+                   Table "public.ts"
+  Column |  Type   | Modifiers | Storage | Description 
+ --------+---------+-----------+---------+-------------
+  aaaa   | integer |           | plain   | 
+  b      | integer |           | plain   | 
+  x      | integer |           | plain   | 
+  c      | integer |           | plain   | 
+  d      | integer |           | plain   | 
+ Inherits: t2,
+           s1
+ Has OIDs: no
+ 
+ WITH RECURSIVE r AS (
+   SELECT 't1'::regclass AS inhrelid
+ UNION ALL
+   SELECT c.inhrelid FROM pg_inherits c, r WHERE r.inhrelid = c.inhparent
+ )
+ SELECT attrelid::regclass, attname, attinhcount, r.expected
+   FROM (SELECT inhrelid, count(*) AS expected FROM pg_inherits
+         WHERE inhparent IN (SELECT inhrelid FROM r) GROUP BY inhrelid) r
+   JOIN pg_attribute a ON r.inhrelid = a.attrelid WHERE attislocal = false;
+  attrelid | attname | attinhcount | expected 
+ ----------+---------+-------------+----------
+  t2       | b       |           1 |        1
+  t3       | b       |           1 |        1
+  t4       | b       |           2 |        2
+  t4       | x       |           1 |        2
+  t4       | y       |           1 |        2
+  ts       | b       |           2 |        1
+  ts       | x       |           1 |        1
+  ts       | c       |           1 |        1
+  t2       | aaaa    |           1 |        1
+  t3       | aaaa    |           1 |        1
+  t4       | aaaa    |           2 |        2
+  ts       | aaaa    |           1 |        1
+ (12 rows)
+ 
+ DROP TABLE t1, s1 CASCADE;
+ NOTICE:  drop cascades to 4 other objects
+ DETAIL:  drop cascades to table t2
+ drop cascades to table ts
+ drop cascades to table t3
+ drop cascades to table t4
*** a/src/test/regress/sql/inherit.sql
--- b/src/test/regress/sql/inherit.sql
***************
*** 334,336 **** CREATE TABLE inh_error1 () INHERITS (t1, t4);
--- 334,374 ----
  CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
  
  DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+ 
+ -- Test for renaming in simple multiple inheritance
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE s1 (b int, c int);
+ CREATE TABLE ts (d int) INHERITS (t1, s1);
+ 
+ ALTER TABLE t1 RENAME a TO aa;
+ ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ ALTER TABLE ts RENAME aa TO aaa;      -- to be failed
+ ALTER TABLE ts RENAME d TO dd;
+ \d+ ts
+ 
+ DROP TABLE ts;
+ 
+ -- Test for renaming in diamond inheritance
+ CREATE TABLE t2 (x int) INHERITS (t1);
+ CREATE TABLE t3 (y int) INHERITS (t1);
+ CREATE TABLE t4 (z int) INHERITS (t2, t3);
+ 
+ ALTER TABLE t1 RENAME aa TO aaa;
+ \d+ t4
+ 
+ CREATE TABLE ts (d int) INHERITS (t2, s1);
+ ALTER TABLE t1 RENAME aaa TO aaaa;
+ ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ \d+ ts
+ 
+ WITH RECURSIVE r AS (
+   SELECT 't1'::regclass AS inhrelid
+ UNION ALL
+   SELECT c.inhrelid FROM pg_inherits c, r WHERE r.inhrelid = c.inhparent
+ )
+ SELECT attrelid::regclass, attname, attinhcount, r.expected
+   FROM (SELECT inhrelid, count(*) AS expected FROM pg_inherits
+         WHERE inhparent IN (SELECT inhrelid FROM r) GROUP BY inhrelid) r
+   JOIN pg_attribute a ON r.inhrelid = a.attrelid WHERE attislocal = false;
+ 
+ DROP TABLE t1, s1 CASCADE;

diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c
index e256f6f..b53f44d 100644
--- a/src/backend/catalog/pg_inherits.c
+++ b/src/backend/catalog/pg_inherits.c
@@ -148,6 +148,9 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
  * find_all_inheritors -
  *		Returns a list of relation OIDs including the given rel plus
  *		all relations that inherit from it, directly or indirectly.
+ *		Optionally, it also returns the number of parents found for
+ *		each such relation within the inheritance tree rooted at the
+ *		given rel.
  *
  * The specified lock type is acquired on all child relations (but not on the
  * given rel; caller should already have locked it).  If lockmode is NoLock
@@ -155,9 +158,9 @@ find_inheritance_children(Oid parentrelId, LOCKMODE lockmode)
  * against possible DROPs of child relations.
  */
 List *
-find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
+find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **parents)
 {
-	List	   *rels_list;
+	List	   *rels_list, *rel_parents;
 	ListCell   *l;
 
 	/*
@@ -168,11 +171,13 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
 	 * doesn't fetch the next list element until the bottom of the loop.
 	 */
 	rels_list = list_make1_oid(parentrelId);
+	rel_parents = list_make1_int(0);
 
 	foreach(l, rels_list)
 	{
 		Oid			currentrel = lfirst_oid(l);
 		List	   *currentchildren;
+		ListCell   *lc;
 
 		/* Get the direct children of this rel */
 		currentchildren = find_inheritance_children(currentrel, lockmode);
@@ -184,9 +189,35 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode)
 		 * loop, though theoretically there can't be any cycles in the
 		 * inheritance graph anyway.)
 		 */
-		rels_list = list_concat_unique_oid(rels_list, currentchildren);
+		foreach(lc, currentchildren)
+		{
+			Oid		child_oid = lfirst_oid(lc);
+			bool	found = false;
+			ListCell   *lo;
+			ListCell   *li;
+
+			forboth(lo, rels_list, li, rel_parents)
+			{
+				if (lfirst_oid(lo) == child_oid)
+				{
+					lfirst_int(li)++;
+					found = true;
+					break;
+				}
+			}
+
+			if (!found)
+			{
+				rels_list = lappend_oid(rels_list, child_oid);
+				rel_parents = lappend_int(rel_parents, 1);
+			}
+		}
 	}
 
+	if (parents)
+		*parents = rel_parents;
+	else
+		list_free(rel_parents);
 	return rels_list;
 }
 
diff --git a/src/backend/commands/alter.c b/src/backend/commands/alter.c
index 8c81eaa..efbd088 100644
--- a/src/backend/commands/alter.c
+++ b/src/backend/commands/alter.c
@@ -126,7 +126,7 @@ ExecRenameStmt(RenameStmt *stmt)
 								  stmt->subname,		/* old att name */
 								  stmt->newname,		/* new att name */
 								  interpretInhOption(stmt->relation->inhOpt),	/* recursive? */
-								  false);		/* recursing already? */
+								  0);			/* expected inhcount */
 						break;
 					case OBJECT_TRIGGER:
 						renametrig(relid,
diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index 9062c15..c93b57f 100644
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -1390,7 +1390,8 @@ acquire_inherited_sample_rows(Relation onerel, HeapTuple *rows, int targrows,
 	 * Find all members of inheritance set.  We only need AccessShareLock on
 	 * the children.
 	 */
-	tableOIDs = find_all_inheritors(RelationGetRelid(onerel), AccessShareLock);
+	tableOIDs =
+		find_all_inheritors(RelationGetRelid(onerel), AccessShareLock, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else fail.  This could
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 50e4244..52f32fc 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -824,7 +824,7 @@ ExecuteTruncate(TruncateStmt *stmt)
 			ListCell   *child;
 			List	   *children;
 
-			children = find_all_inheritors(myrelid, AccessExclusiveLock);
+			children = find_all_inheritors(myrelid, AccessExclusiveLock, NULL);
 
 			foreach(child, children)
 			{
@@ -1943,7 +1943,7 @@ renameatt(Oid myrelid,
 		  const char *oldattname,
 		  const char *newattname,
 		  bool recurse,
-		  bool recursing)
+		  int expected_parents)
 {
 	Relation	targetrelation;
 	Relation	attrelation;
@@ -1987,24 +1987,31 @@ renameatt(Oid myrelid,
 	 */
 	if (recurse)
 	{
-		ListCell   *child;
-		List	   *children;
+		List	   *child_oids, *child_parents;
+		ListCell   *lo, *li;
 
-		children = find_all_inheritors(myrelid, AccessExclusiveLock);
+		/*
+		 * we need the number of parents for each child so that the recursive
+		 * calls to renameatt() can determine whether there are any parents
+		 * outside the inheritance hierarchy being processed.
+		 */
+		child_oids =
+			find_all_inheritors(myrelid, AccessExclusiveLock, &child_parents);
 
 		/*
 		 * find_all_inheritors does the recursive search of the inheritance
 		 * hierarchy, so all we have to do is process all of the relids in the
 		 * list that it returns.
 		 */
-		foreach(child, children)
+		forboth(lo, child_oids, li, child_parents)
 		{
-			Oid			childrelid = lfirst_oid(child);
+			Oid			childrelid = lfirst_oid(lo);
+			int			numparents = lfirst_int(li);
 
 			if (childrelid == myrelid)
 				continue;
 			/* note we need not recurse again */
-			renameatt(childrelid, oldattname, newattname, false, true);
+			renameatt(childrelid, oldattname, newattname, false, numparents);
 		}
 	}
 	else
@@ -2012,8 +2019,10 @@ renameatt(Oid myrelid,
 		/*
 		 * If we are told not to recurse, there had better not be any child
 		 * tables; else the rename would put them out of step.
+		 *
+		 * expected_parents will only be 0 if we are not already recursing.
 		 */
-		if (!recursing &&
+		if (expected_parents == 0 &&
 			find_inheritance_children(myrelid, NoLock) != NIL)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
@@ -2039,10 +2048,15 @@ renameatt(Oid myrelid,
 						oldattname)));
 
 	/*
-	 * if the attribute is inherited, forbid the renaming, unless we are
-	 * already inside a recursive rename.
+	 * if the attribute is inherited, forbid the renaming.  if this is a
+	 * top-level call to renameatt(), then expected_parents will be 0, so the
+	 * effect of this code will be to prohibit the renaming if the attribute
+	 * is inherited at all.  if this is a recursive call to renameatt(),
+	 * expected_parents will be the number of parents the current relation has
+	 * within the inheritance hierarchy being processed, so we'll prohibit
+	 * the renaming only if there are additional parents from elsewhere.
 	 */
-	if (attform->attinhcount > 0 && !recursing)
+	if (attform->attinhcount > expected_parents)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 				 errmsg("cannot rename inherited column \"%s\"",
@@ -3410,7 +3424,7 @@ ATSimpleRecursion(List **wqueue, Relation rel,
 		ListCell   *child;
 		List	   *children;
 
-		children = find_all_inheritors(relid, AccessExclusiveLock);
+		children = find_all_inheritors(relid, AccessExclusiveLock, NULL);
 
 		/*
 		 * find_all_inheritors does the recursive search of the inheritance
@@ -7233,7 +7247,7 @@ ATExecAddInherit(Relation child_rel, RangeVar *parent)
 	 * We use weakest lock we can on child's children, namely AccessShareLock.
 	 */
 	children = find_all_inheritors(RelationGetRelid(child_rel),
-								   AccessShareLock);
+								   AccessShareLock, NULL);
 
 	if (list_member_oid(children, RelationGetRelid(parent_rel)))
 		ereport(ERROR,
diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index c7e9c85..50a6ab7 100644
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -1180,7 +1180,7 @@ expand_inherited_rtentry(PlannerInfo *root, RangeTblEntry *rte, Index rti)
 		lockmode = AccessShareLock;
 
 	/* Scan for all members of inheritance set, acquire needed locks */
-	inhOIDs = find_all_inheritors(parentOID, lockmode);
+	inhOIDs = find_all_inheritors(parentOID, lockmode, NULL);
 
 	/*
 	 * Check that there's at least one descendant, else treat as no-child
diff --git a/src/include/catalog/pg_inherits_fn.h b/src/include/catalog/pg_inherits_fn.h
index 91baec3..70a624b 100644
--- a/src/include/catalog/pg_inherits_fn.h
+++ b/src/include/catalog/pg_inherits_fn.h
@@ -18,7 +18,8 @@
 #include "storage/lock.h"
 
 extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode);
-extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode);
+extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode,
+					List **parents);
 extern bool has_subclass(Oid relationId);
 extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId);
 
diff --git a/src/include/commands/tablecmds.h b/src/include/commands/tablecmds.h
index 8bc716a..f9269cc 100644
--- a/src/include/commands/tablecmds.h
+++ b/src/include/commands/tablecmds.h
@@ -43,7 +43,7 @@ extern void renameatt(Oid myrelid,
 		  const char *oldattname,
 		  const char *newattname,
 		  bool recurse,
-		  bool recursing);
+		  int expected_parents);
 
 extern void RenameRelation(Oid myrelid,
 			   const char *newrelname,
diff --git a/src/test/regress/expected/inherit.out b/src/test/regress/expected/inherit.out
index 9c83a32..dc54e56 100644
--- a/src/test/regress/expected/inherit.out
+++ b/src/test/regress/expected/inherit.out
@@ -1053,3 +1053,97 @@ NOTICE:  merging column "a" with inherited definition
 ERROR:  column "a" has a storage parameter conflict
 DETAIL:  MAIN versus EXTENDED
 DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+-- Test for renaming in simple multiple inheritance
+CREATE TABLE t1 (a int, b int);
+CREATE TABLE s1 (b int, c int);
+CREATE TABLE ts (d int) INHERITS (t1, s1);
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE t1 RENAME a TO aa;
+ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ERROR:  cannot rename inherited column "b"
+ALTER TABLE ts RENAME aa TO aaa;      -- to be failed
+ERROR:  cannot rename inherited column "aa"
+ALTER TABLE ts RENAME d TO dd;
+\d+ ts
+                  Table "public.ts"
+ Column |  Type   | Modifiers | Storage | Description 
+--------+---------+-----------+---------+-------------
+ aa     | integer |           | plain   | 
+ b      | integer |           | plain   | 
+ c      | integer |           | plain   | 
+ dd     | integer |           | plain   | 
+Inherits: t1,
+          s1
+Has OIDs: no
+
+DROP TABLE ts;
+-- Test for renaming in diamond inheritance
+CREATE TABLE t2 (x int) INHERITS (t1);
+CREATE TABLE t3 (y int) INHERITS (t1);
+CREATE TABLE t4 (z int) INHERITS (t2, t3);
+NOTICE:  merging multiple inherited definitions of column "aa"
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE t1 RENAME aa TO aaa;
+\d+ t4
+                  Table "public.t4"
+ Column |  Type   | Modifiers | Storage | Description 
+--------+---------+-----------+---------+-------------
+ aaa    | integer |           | plain   | 
+ b      | integer |           | plain   | 
+ x      | integer |           | plain   | 
+ y      | integer |           | plain   | 
+ z      | integer |           | plain   | 
+Inherits: t2,
+          t3
+Has OIDs: no
+
+CREATE TABLE ts (d int) INHERITS (t2, s1);
+NOTICE:  merging multiple inherited definitions of column "b"
+ALTER TABLE t1 RENAME aaa TO aaaa;
+ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ERROR:  cannot rename inherited column "b"
+\d+ ts
+                  Table "public.ts"
+ Column |  Type   | Modifiers | Storage | Description 
+--------+---------+-----------+---------+-------------
+ aaaa   | integer |           | plain   | 
+ b      | integer |           | plain   | 
+ x      | integer |           | plain   | 
+ c      | integer |           | plain   | 
+ d      | integer |           | plain   | 
+Inherits: t2,
+          s1
+Has OIDs: no
+
+WITH RECURSIVE r AS (
+  SELECT 't1'::regclass AS inhrelid
+UNION ALL
+  SELECT c.inhrelid FROM pg_inherits c, r WHERE r.inhrelid = c.inhparent
+)
+SELECT a.attrelid::regclass, a.attname, a.attinhcount, e.expected
+  FROM (SELECT inhrelid, count(*) AS expected FROM pg_inherits
+        WHERE inhparent IN (SELECT inhrelid FROM r) GROUP BY inhrelid) e
+  JOIN pg_attribute a ON e.inhrelid = a.attrelid WHERE NOT attislocal
+  ORDER BY a.attrelid, a.attnum;
+ attrelid | attname | attinhcount | expected 
+----------+---------+-------------+----------
+ t2       | aaaa    |           1 |        1
+ t2       | b       |           1 |        1
+ t3       | aaaa    |           1 |        1
+ t3       | b       |           1 |        1
+ t4       | aaaa    |           2 |        2
+ t4       | b       |           2 |        2
+ t4       | x       |           1 |        2
+ t4       | y       |           1 |        2
+ ts       | aaaa    |           1 |        1
+ ts       | b       |           2 |        1
+ ts       | x       |           1 |        1
+ ts       | c       |           1 |        1
+(12 rows)
+
+DROP TABLE t1, s1 CASCADE;
+NOTICE:  drop cascades to 4 other objects
+DETAIL:  drop cascades to table t2
+drop cascades to table ts
+drop cascades to table t3
+drop cascades to table t4
diff --git a/src/test/regress/sql/inherit.sql b/src/test/regress/sql/inherit.sql
index 192e860..bbd5752 100644
--- a/src/test/regress/sql/inherit.sql
+++ b/src/test/regress/sql/inherit.sql
@@ -334,3 +334,42 @@ CREATE TABLE inh_error1 () INHERITS (t1, t4);
 CREATE TABLE inh_error2 (LIKE t4 INCLUDING STORAGE) INHERITS (t1);
 
 DROP TABLE t1, t2, t3, t4, t12_storage, t12_comments, t1_inh, t13_inh, t13_like, t_all;
+
+-- Test for renaming in simple multiple inheritance
+CREATE TABLE t1 (a int, b int);
+CREATE TABLE s1 (b int, c int);
+CREATE TABLE ts (d int) INHERITS (t1, s1);
+
+ALTER TABLE t1 RENAME a TO aa;
+ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+ALTER TABLE ts RENAME aa TO aaa;      -- to be failed
+ALTER TABLE ts RENAME d TO dd;
+\d+ ts
+
+DROP TABLE ts;
+
+-- Test for renaming in diamond inheritance
+CREATE TABLE t2 (x int) INHERITS (t1);
+CREATE TABLE t3 (y int) INHERITS (t1);
+CREATE TABLE t4 (z int) INHERITS (t2, t3);
+
+ALTER TABLE t1 RENAME aa TO aaa;
+\d+ t4
+
+CREATE TABLE ts (d int) INHERITS (t2, s1);
+ALTER TABLE t1 RENAME aaa TO aaaa;
+ALTER TABLE t1 RENAME b TO bb;                -- to be failed
+\d+ ts
+
+WITH RECURSIVE r AS (
+  SELECT 't1'::regclass AS inhrelid
+UNION ALL
+  SELECT c.inhrelid FROM pg_inherits c, r WHERE r.inhrelid = c.inhparent
+)
+SELECT a.attrelid::regclass, a.attname, a.attinhcount, e.expected
+  FROM (SELECT inhrelid, count(*) AS expected FROM pg_inherits
+        WHERE inhparent IN (SELECT inhrelid FROM r) GROUP BY inhrelid) e
+  JOIN pg_attribute a ON e.inhrelid = a.attrelid WHERE NOT attislocal
+  ORDER BY a.attrelid, a.attnum;
+
+DROP TABLE t1, s1 CASCADE;

*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 255,261 **** static void createForeignKeyTriggers(Relation rel, Constraint *fkconstraint,
  						 Oid constraintOid, Oid indexOid);
  static void ATController(Relation rel, List *cmds, bool recurse);
  static void ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
! 		  bool recurse, bool recursing);
  static void ATRewriteCatalogs(List **wqueue);
  static void ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
  		  AlterTableCmd *cmd);
--- 255,261 ----
  						 Oid constraintOid, Oid indexOid);
  static void ATController(Relation rel, List *cmds, bool recurse);
  static void ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
! 		  bool recurse, int expected_parents);
  static void ATRewriteCatalogs(List **wqueue);
  static void ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
  		  AlterTableCmd *cmd);
***************
*** 309,315 **** static void ATExecDropConstraint(Relation rel, const char *constrName,
  								 bool missing_ok);
  static void ATPrepAlterColumnType(List **wqueue,
  					  AlteredTableInfo *tab, Relation rel,
! 					  bool recurse, bool recursing,
  					  AlterTableCmd *cmd);
  static void ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
  					  const char *colName, TypeName *typeName);
--- 309,315 ----
  								 bool missing_ok);
  static void ATPrepAlterColumnType(List **wqueue,
  					  AlteredTableInfo *tab, Relation rel,
! 					  bool recurse, int expected_parents,
  					  AlterTableCmd *cmd);
  static void ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
  					  const char *colName, TypeName *typeName);
***************
*** 2388,2394 **** ATController(Relation rel, List *cmds, bool recurse)
  	{
  		AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);
  
! 		ATPrepCmd(&wqueue, rel, cmd, recurse, false);
  	}
  
  	/* Close the relation, but keep lock until commit */
--- 2388,2394 ----
  	{
  		AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);
  
! 		ATPrepCmd(&wqueue, rel, cmd, recurse, 0);
  	}
  
  	/* Close the relation, but keep lock until commit */
***************
*** 2412,2418 **** ATController(Relation rel, List *cmds, bool recurse)
   */
  static void
  ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
! 		  bool recurse, bool recursing)
  {
  	AlteredTableInfo *tab;
  	int			pass;
--- 2412,2418 ----
   */
  static void
  ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
! 		  bool recurse, int expected_parents)
  {
  	AlteredTableInfo *tab;
  	int			pass;
***************
*** 2523,2529 **** ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
  		case AT_AlterColumnType:		/* ALTER COLUMN TYPE */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			ATPrepAlterColumnType(wqueue, tab, rel, recurse, recursing, cmd);
  			pass = AT_PASS_ALTER_TYPE;
  			break;
  		case AT_ChangeOwner:	/* ALTER OWNER */
--- 2523,2530 ----
  		case AT_AlterColumnType:		/* ALTER COLUMN TYPE */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			ATPrepAlterColumnType(wqueue, tab, rel,
! 								  recurse, expected_parents, cmd);
  			pass = AT_PASS_ALTER_TYPE;
  			break;
  		case AT_ChangeOwner:	/* ALTER OWNER */
***************
*** 2541,2547 **** ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
  		case AT_AddOids:		/* SET WITH OIDS */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			if (!rel->rd_rel->relhasoids || recursing)
  				ATPrepAddOids(wqueue, rel, recurse, cmd);
  			pass = AT_PASS_ADD_COL;
  			break;
--- 2542,2548 ----
  		case AT_AddOids:		/* SET WITH OIDS */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			if (!rel->rd_rel->relhasoids || expected_parents > 0)
  				ATPrepAddOids(wqueue, rel, recurse, cmd);
  			pass = AT_PASS_ADD_COL;
  			break;
***************
*** 2555,2561 **** ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
  				dropCmd->subtype = AT_DropColumn;
  				dropCmd->name = pstrdup("oid");
  				dropCmd->behavior = cmd->behavior;
! 				ATPrepCmd(wqueue, rel, dropCmd, recurse, false);
  			}
  			pass = AT_PASS_DROP;
  			break;
--- 2556,2562 ----
  				dropCmd->subtype = AT_DropColumn;
  				dropCmd->name = pstrdup("oid");
  				dropCmd->behavior = cmd->behavior;
! 				ATPrepCmd(wqueue, rel, dropCmd, recurse, expected_parents);
  			}
  			pass = AT_PASS_DROP;
  			break;
***************
*** 3421,3439 **** ATSimpleRecursion(List **wqueue, Relation rel,
  	if (recurse && rel->rd_rel->relkind == RELKIND_RELATION)
  	{
  		Oid			relid = RelationGetRelid(rel);
! 		ListCell   *child;
  		List	   *children;
  
! 		children = find_all_inheritors(relid, AccessExclusiveLock, NULL);
  
  		/*
  		 * find_all_inheritors does the recursive search of the inheritance
  		 * hierarchy, so all we have to do is process all of the relids in the
  		 * list that it returns.
  		 */
! 		foreach(child, children)
  		{
! 			Oid			childrelid = lfirst_oid(child);
  			Relation	childrel;
  
  			if (childrelid == relid)
--- 3422,3443 ----
  	if (recurse && rel->rd_rel->relkind == RELKIND_RELATION)
  	{
  		Oid			relid = RelationGetRelid(rel);
! 		ListCell   *lc, *lp;
  		List	   *children;
+ 		List	   *numparents;
  
! 		children = find_all_inheritors(relid, AccessExclusiveLock, &numparents);
  
  		/*
  		 * find_all_inheritors does the recursive search of the inheritance
  		 * hierarchy, so all we have to do is process all of the relids in the
  		 * list that it returns.
  		 */
! 		
! 		forboth(lc, children, lp, numparents)
  		{
! 			Oid			childrelid = lfirst_oid(lc);
! 			int			expected_parents = lfirst_int(lp);
  			Relation	childrel;
  
  			if (childrelid == relid)
***************
*** 3441,3447 **** ATSimpleRecursion(List **wqueue, Relation rel,
  			/* find_all_inheritors already got lock */
  			childrel = relation_open(childrelid, NoLock);
  			CheckTableNotInUse(childrel, "ALTER TABLE");
! 			ATPrepCmd(wqueue, childrel, cmd, false, true);
  			relation_close(childrel, NoLock);
  		}
  	}
--- 3445,3451 ----
  			/* find_all_inheritors already got lock */
  			childrel = relation_open(childrelid, NoLock);
  			CheckTableNotInUse(childrel, "ALTER TABLE");
! 			ATPrepCmd(wqueue, childrel, cmd, false, expected_parents);
  			relation_close(childrel, NoLock);
  		}
  	}
***************
*** 3473,3479 **** ATOneLevelRecursion(List **wqueue, Relation rel,
  		/* find_inheritance_children already got lock */
  		childrel = relation_open(childrelid, NoLock);
  		CheckTableNotInUse(childrel, "ALTER TABLE");
! 		ATPrepCmd(wqueue, childrel, cmd, true, true);
  		relation_close(childrel, NoLock);
  	}
  }
--- 3477,3488 ----
  		/* find_inheritance_children already got lock */
  		childrel = relation_open(childrelid, NoLock);
  		CheckTableNotInUse(childrel, "ALTER TABLE");
! 		/*
! 		 * XXX - Is it possible to assume `expected_numparents' is
! 		 * always 1 in this code path. Or, is there any reason why
! 		 * we should use find_all_inheritors() for ATAddColumn?
! 		 */
! 		ATPrepCmd(wqueue, childrel, cmd, true, 1);
  		relation_close(childrel, NoLock);
  	}
  }
***************
*** 5805,5811 **** ATExecDropConstraint(Relation rel, const char *constrName,
  static void
  ATPrepAlterColumnType(List **wqueue,
  					  AlteredTableInfo *tab, Relation rel,
! 					  bool recurse, bool recursing,
  					  AlterTableCmd *cmd)
  {
  	char	   *colName = cmd->name;
--- 5814,5820 ----
  static void
  ATPrepAlterColumnType(List **wqueue,
  					  AlteredTableInfo *tab, Relation rel,
! 					  bool recurse, int expected_parents,
  					  AlterTableCmd *cmd)
  {
  	char	   *colName = cmd->name;
***************
*** 5837,5843 **** ATPrepAlterColumnType(List **wqueue,
  						colName)));
  
  	/* Don't alter inherited columns */
! 	if (attTup->attinhcount > 0 && !recursing)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
  				 errmsg("cannot alter inherited column \"%s\"",
--- 5846,5852 ----
  						colName)));
  
  	/* Don't alter inherited columns */
! 	if (attTup->attinhcount > expected_parents)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
  				 errmsg("cannot alter inherited column \"%s\"",
***************
*** 5929,5935 **** ATPrepAlterColumnType(List **wqueue,
  	 */
  	if (recurse)
  		ATSimpleRecursion(wqueue, rel, cmd, recurse);
! 	else if (!recursing &&
  			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
--- 5938,5944 ----
  	 */
  	if (recurse)
  		ATSimpleRecursion(wqueue, rel, cmd, recurse);
! 	else if (expected_parents == 0 &&
  			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),

*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 255,261 **** static void createForeignKeyTriggers(Relation rel, Constraint *fkconstraint,
  						 Oid constraintOid, Oid indexOid);
  static void ATController(Relation rel, List *cmds, bool recurse);
  static void ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
! 		  bool recurse, bool recursing);
  static void ATRewriteCatalogs(List **wqueue);
  static void ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
  		  AlterTableCmd *cmd);
--- 255,261 ----
  						 Oid constraintOid, Oid indexOid);
  static void ATController(Relation rel, List *cmds, bool recurse);
  static void ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
! 		  bool recurse, int expected_parents);
  static void ATRewriteCatalogs(List **wqueue);
  static void ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
  		  AlterTableCmd *cmd);
***************
*** 266,280 **** static void ATSimplePermissions(Relation rel, bool allowView);
  static void ATSimplePermissionsRelationOrIndex(Relation rel);
  static void ATSimpleRecursion(List **wqueue, Relation rel,
  				  AlterTableCmd *cmd, bool recurse);
- static void ATOneLevelRecursion(List **wqueue, Relation rel,
- 					AlterTableCmd *cmd);
  static void ATPrepAddColumn(List **wqueue, Relation rel, bool recurse,
! 				AlterTableCmd *cmd);
  static void ATExecAddColumn(AlteredTableInfo *tab, Relation rel,
  				ColumnDef *colDef, bool isOid);
  static void add_column_datatype_dependency(Oid relid, int32 attnum, Oid typid);
  static void ATPrepAddOids(List **wqueue, Relation rel, bool recurse,
! 			  AlterTableCmd *cmd);
  static void ATExecDropNotNull(Relation rel, const char *colName);
  static void ATExecSetNotNull(AlteredTableInfo *tab, Relation rel,
  				 const char *colName);
--- 266,278 ----
  static void ATSimplePermissionsRelationOrIndex(Relation rel);
  static void ATSimpleRecursion(List **wqueue, Relation rel,
  				  AlterTableCmd *cmd, bool recurse);
  static void ATPrepAddColumn(List **wqueue, Relation rel, bool recurse,
! 				int expected_parents, AlterTableCmd *cmd);
  static void ATExecAddColumn(AlteredTableInfo *tab, Relation rel,
  				ColumnDef *colDef, bool isOid);
  static void add_column_datatype_dependency(Oid relid, int32 attnum, Oid typid);
  static void ATPrepAddOids(List **wqueue, Relation rel, bool recurse,
! 				int expected_parents, AlterTableCmd *cmd);
  static void ATExecDropNotNull(Relation rel, const char *colName);
  static void ATExecSetNotNull(AlteredTableInfo *tab, Relation rel,
  				 const char *colName);
***************
*** 309,315 **** static void ATExecDropConstraint(Relation rel, const char *constrName,
  								 bool missing_ok);
  static void ATPrepAlterColumnType(List **wqueue,
  					  AlteredTableInfo *tab, Relation rel,
! 					  bool recurse, bool recursing,
  					  AlterTableCmd *cmd);
  static void ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
  					  const char *colName, TypeName *typeName);
--- 307,313 ----
  								 bool missing_ok);
  static void ATPrepAlterColumnType(List **wqueue,
  					  AlteredTableInfo *tab, Relation rel,
! 					  bool recurse, int expected_parents,
  					  AlterTableCmd *cmd);
  static void ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
  					  const char *colName, TypeName *typeName);
***************
*** 2388,2394 **** ATController(Relation rel, List *cmds, bool recurse)
  	{
  		AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);
  
! 		ATPrepCmd(&wqueue, rel, cmd, recurse, false);
  	}
  
  	/* Close the relation, but keep lock until commit */
--- 2386,2392 ----
  	{
  		AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lcmd);
  
! 		ATPrepCmd(&wqueue, rel, cmd, recurse, 0);
  	}
  
  	/* Close the relation, but keep lock until commit */
***************
*** 2412,2418 **** ATController(Relation rel, List *cmds, bool recurse)
   */
  static void
  ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
! 		  bool recurse, bool recursing)
  {
  	AlteredTableInfo *tab;
  	int			pass;
--- 2410,2416 ----
   */
  static void
  ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
! 		  bool recurse, int expected_parents)
  {
  	AlteredTableInfo *tab;
  	int			pass;
***************
*** 2437,2450 **** ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
  		case AT_AddColumn:		/* ADD COLUMN */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			ATPrepAddColumn(wqueue, rel, recurse, cmd);
  			pass = AT_PASS_ADD_COL;
  			break;
  		case AT_AddColumnToView:		/* add column via CREATE OR REPLACE
  										 * VIEW */
  			ATSimplePermissions(rel, true);
  			/* Performs own recursion */
! 			ATPrepAddColumn(wqueue, rel, recurse, cmd);
  			pass = AT_PASS_ADD_COL;
  			break;
  		case AT_ColumnDefault:	/* ALTER COLUMN DEFAULT */
--- 2435,2448 ----
  		case AT_AddColumn:		/* ADD COLUMN */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			ATPrepAddColumn(wqueue, rel, recurse, expected_parents, cmd);
  			pass = AT_PASS_ADD_COL;
  			break;
  		case AT_AddColumnToView:		/* add column via CREATE OR REPLACE
  										 * VIEW */
  			ATSimplePermissions(rel, true);
  			/* Performs own recursion */
! 			ATPrepAddColumn(wqueue, rel, recurse, expected_parents, cmd);
  			pass = AT_PASS_ADD_COL;
  			break;
  		case AT_ColumnDefault:	/* ALTER COLUMN DEFAULT */
***************
*** 2523,2529 **** ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
  		case AT_AlterColumnType:		/* ALTER COLUMN TYPE */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			ATPrepAlterColumnType(wqueue, tab, rel, recurse, recursing, cmd);
  			pass = AT_PASS_ALTER_TYPE;
  			break;
  		case AT_ChangeOwner:	/* ALTER OWNER */
--- 2521,2528 ----
  		case AT_AlterColumnType:		/* ALTER COLUMN TYPE */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			ATPrepAlterColumnType(wqueue, tab, rel,
! 								  recurse, expected_parents, cmd);
  			pass = AT_PASS_ALTER_TYPE;
  			break;
  		case AT_ChangeOwner:	/* ALTER OWNER */
***************
*** 2541,2548 **** ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
  		case AT_AddOids:		/* SET WITH OIDS */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			if (!rel->rd_rel->relhasoids || recursing)
! 				ATPrepAddOids(wqueue, rel, recurse, cmd);
  			pass = AT_PASS_ADD_COL;
  			break;
  		case AT_DropOids:		/* SET WITHOUT OIDS */
--- 2540,2547 ----
  		case AT_AddOids:		/* SET WITH OIDS */
  			ATSimplePermissions(rel, false);
  			/* Performs own recursion */
! 			if (!rel->rd_rel->relhasoids || expected_parents > 0)
! 				ATPrepAddOids(wqueue, rel, recurse, expected_parents, cmd);
  			pass = AT_PASS_ADD_COL;
  			break;
  		case AT_DropOids:		/* SET WITHOUT OIDS */
***************
*** 2555,2561 **** ATPrepCmd(List **wqueue, Relation rel, AlterTableCmd *cmd,
  				dropCmd->subtype = AT_DropColumn;
  				dropCmd->name = pstrdup("oid");
  				dropCmd->behavior = cmd->behavior;
! 				ATPrepCmd(wqueue, rel, dropCmd, recurse, false);
  			}
  			pass = AT_PASS_DROP;
  			break;
--- 2554,2560 ----
  				dropCmd->subtype = AT_DropColumn;
  				dropCmd->name = pstrdup("oid");
  				dropCmd->behavior = cmd->behavior;
! 				ATPrepCmd(wqueue, rel, dropCmd, recurse, expected_parents);
  			}
  			pass = AT_PASS_DROP;
  			break;
***************
*** 3421,3439 **** ATSimpleRecursion(List **wqueue, Relation rel,
  	if (recurse && rel->rd_rel->relkind == RELKIND_RELATION)
  	{
  		Oid			relid = RelationGetRelid(rel);
! 		ListCell   *child;
  		List	   *children;
  
! 		children = find_all_inheritors(relid, AccessExclusiveLock, NULL);
  
  		/*
  		 * find_all_inheritors does the recursive search of the inheritance
  		 * hierarchy, so all we have to do is process all of the relids in the
  		 * list that it returns.
  		 */
! 		foreach(child, children)
  		{
! 			Oid			childrelid = lfirst_oid(child);
  			Relation	childrel;
  
  			if (childrelid == relid)
--- 3420,3440 ----
  	if (recurse && rel->rd_rel->relkind == RELKIND_RELATION)
  	{
  		Oid			relid = RelationGetRelid(rel);
! 		ListCell   *lc, *lp;
  		List	   *children;
+ 		List	   *numparents;
  
! 		children = find_all_inheritors(relid, AccessExclusiveLock, &numparents);
  
  		/*
  		 * find_all_inheritors does the recursive search of the inheritance
  		 * hierarchy, so all we have to do is process all of the relids in the
  		 * list that it returns.
  		 */
! 		forboth(lc, children, lp, numparents)
  		{
! 			Oid			childrelid = lfirst_oid(lc);
! 			int			expected_parents = lfirst_int(lp);
  			Relation	childrel;
  
  			if (childrelid == relid)
***************
*** 3441,3485 **** ATSimpleRecursion(List **wqueue, Relation rel,
  			/* find_all_inheritors already got lock */
  			childrel = relation_open(childrelid, NoLock);
  			CheckTableNotInUse(childrel, "ALTER TABLE");
! 			ATPrepCmd(wqueue, childrel, cmd, false, true);
  			relation_close(childrel, NoLock);
  		}
  	}
  }
  
  /*
-  * ATOneLevelRecursion
-  *
-  * Here, we visit only direct inheritance children.  It is expected that
-  * the command's prep routine will recurse again to find indirect children.
-  * When using this technique, a multiply-inheriting child will be visited
-  * multiple times.
-  */
- static void
- ATOneLevelRecursion(List **wqueue, Relation rel,
- 					AlterTableCmd *cmd)
- {
- 	Oid			relid = RelationGetRelid(rel);
- 	ListCell   *child;
- 	List	   *children;
- 
- 	children = find_inheritance_children(relid, AccessExclusiveLock);
- 
- 	foreach(child, children)
- 	{
- 		Oid			childrelid = lfirst_oid(child);
- 		Relation	childrel;
- 
- 		/* find_inheritance_children already got lock */
- 		childrel = relation_open(childrelid, NoLock);
- 		CheckTableNotInUse(childrel, "ALTER TABLE");
- 		ATPrepCmd(wqueue, childrel, cmd, true, true);
- 		relation_close(childrel, NoLock);
- 	}
- }
- 
- 
- /*
   * find_composite_type_dependencies
   *
   * Check to see if a composite type is being used as a column in some
--- 3442,3454 ----
  			/* find_all_inheritors already got lock */
  			childrel = relation_open(childrelid, NoLock);
  			CheckTableNotInUse(childrel, "ALTER TABLE");
! 			ATPrepCmd(wqueue, childrel, cmd, false, expected_parents);
  			relation_close(childrel, NoLock);
  		}
  	}
  }
  
  /*
   * find_composite_type_dependencies
   *
   * Check to see if a composite type is being used as a column in some
***************
*** 3591,3627 **** find_composite_type_dependencies(Oid typeOid,
   */
  static void
  ATPrepAddColumn(List **wqueue, Relation rel, bool recurse,
! 				AlterTableCmd *cmd)
  {
  	/*
  	 * Recurse to add the column to child classes, if requested.
  	 *
! 	 * We must recurse one level at a time, so that multiply-inheriting
! 	 * children are visited the right number of times and end up with the
! 	 * right attinhcount.
  	 */
  	if (recurse)
! 	{
! 		AlterTableCmd *childCmd = copyObject(cmd);
! 		ColumnDef  *colDefChild = (ColumnDef *) childCmd->def;
! 
! 		/* Child should see column as singly inherited */
! 		colDefChild->inhcount = 1;
! 		colDefChild->is_local = false;
! 
! 		ATOneLevelRecursion(wqueue, rel, childCmd);
! 	}
! 	else
! 	{
! 		/*
! 		 * If we are told not to recurse, there had better not be any child
! 		 * tables; else the addition would put them out of step.
! 		 */
! 		if (find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
! 					 errmsg("column must be added to child tables too")));
! 	}
  }
  
  static void
--- 3560,3587 ----
   */
  static void
  ATPrepAddColumn(List **wqueue, Relation rel, bool recurse,
! 				int expected_parents, AlterTableCmd *cmd)
  {
+ 	ColumnDef  *colDef = (ColumnDef *)cmd->def;
+ 
+ 	colDef->inhcount = expected_parents;
+ 
+ 	colDef->is_local = (expected_parents == 0 ? true : false);
+ 
  	/*
  	 * Recurse to add the column to child classes, if requested.
  	 *
! 	 * ATExecAddColumn creates a new column with attinhcount which shall be
! 	 * initialized by colDef->inhcount, or increments attinhcount of the
! 	 * existing column to be merged by colDef->inhcount.
  	 */
  	if (recurse)
! 		ATSimpleRecursion(wqueue, rel, cmd, recurse);
! 	else if (expected_parents == 0 &&
! 			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
! 				 errmsg("column must be added to child tables too")));
  }
  
  static void
***************
*** 3681,3687 **** ATExecAddColumn(AlteredTableInfo *tab, Relation rel,
  						RelationGetRelationName(rel), colDef->colname)));
  
  			/* Bump the existing child att's inhcount */
! 			childatt->attinhcount++;
  			simple_heap_update(attrdesc, &tuple->t_self, tuple);
  			CatalogUpdateIndexes(attrdesc, tuple);
  
--- 3641,3647 ----
  						RelationGetRelationName(rel), colDef->colname)));
  
  			/* Bump the existing child att's inhcount */
! 			childatt->attinhcount += colDef->inhcount;
  			simple_heap_update(attrdesc, &tuple->t_self, tuple);
  			CatalogUpdateIndexes(attrdesc, tuple);
  
***************
*** 3915,3921 **** add_column_datatype_dependency(Oid relid, int32 attnum, Oid typid)
   * to cons up a ColumnDef node because the ADD COLUMN code needs one.
   */
  static void
! ATPrepAddOids(List **wqueue, Relation rel, bool recurse, AlterTableCmd *cmd)
  {
  	/* If we're recursing to a child table, the ColumnDef is already set up */
  	if (cmd->def == NULL)
--- 3875,3882 ----
   * to cons up a ColumnDef node because the ADD COLUMN code needs one.
   */
  static void
! ATPrepAddOids(List **wqueue, Relation rel, bool recurse,
! 			  int expected_parents, AlterTableCmd *cmd)
  {
  	/* If we're recursing to a child table, the ColumnDef is already set up */
  	if (cmd->def == NULL)
***************
*** 3930,3936 **** ATPrepAddOids(List **wqueue, Relation rel, bool recurse, AlterTableCmd *cmd)
  		cdef->storage = 0;
  		cmd->def = (Node *) cdef;
  	}
! 	ATPrepAddColumn(wqueue, rel, recurse, cmd);
  }
  
  /*
--- 3891,3897 ----
  		cdef->storage = 0;
  		cmd->def = (Node *) cdef;
  	}
! 	ATPrepAddColumn(wqueue, rel, recurse, expected_parents, cmd);
  }
  
  /*
***************
*** 5805,5811 **** ATExecDropConstraint(Relation rel, const char *constrName,
  static void
  ATPrepAlterColumnType(List **wqueue,
  					  AlteredTableInfo *tab, Relation rel,
! 					  bool recurse, bool recursing,
  					  AlterTableCmd *cmd)
  {
  	char	   *colName = cmd->name;
--- 5766,5772 ----
  static void
  ATPrepAlterColumnType(List **wqueue,
  					  AlteredTableInfo *tab, Relation rel,
! 					  bool recurse, int expected_parents,
  					  AlterTableCmd *cmd)
  {
  	char	   *colName = cmd->name;
***************
*** 5837,5843 **** ATPrepAlterColumnType(List **wqueue,
  						colName)));
  
  	/* Don't alter inherited columns */
! 	if (attTup->attinhcount > 0 && !recursing)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
  				 errmsg("cannot alter inherited column \"%s\"",
--- 5798,5804 ----
  						colName)));
  
  	/* Don't alter inherited columns */
! 	if (attTup->attinhcount > expected_parents)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
  				 errmsg("cannot alter inherited column \"%s\"",
***************
*** 5929,5935 **** ATPrepAlterColumnType(List **wqueue,
  	 */
  	if (recurse)
  		ATSimpleRecursion(wqueue, rel, cmd, recurse);
! 	else if (!recursing &&
  			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
--- 5890,5896 ----
  	 */
  	if (recurse)
  		ATSimpleRecursion(wqueue, rel, cmd, recurse);
! 	else if (expected_parents == 0 &&
  			 find_inheritance_children(RelationGetRelid(rel), NoLock) != NIL)
  		ereport(ERROR,
  				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),