1 files changed, 39 insertions, 5 deletions

diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 16d40c72406..14384d58dbe 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -56,6 +56,7 @@
 #include "rewrite/rewriteManip.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
+#include "utils/guc.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/syscache.h"
@@ -150,6 +151,7 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString)
 	Oid			namespaceid;
 	Oid			existing_relid;
 	ParseCallbackState pcbstate;
+	bool		like_found = false;
 
 	/*
 	 * We must not scribble on the passed-in CreateStmt, so copy it.  (This is
@@ -242,7 +244,10 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString)
 
 	/*
 	 * Run through each primary element in the table creation clause. Separate
-	 * column defs from constraints, and do preliminary analysis.
+	 * column defs from constraints, and do preliminary analysis.  We have to
+	 * process column-defining clauses first because it can control the
+	 * presence of columns which are referenced by columns referenced by
+	 * constraints.
 	 */
 	foreach(elements, stmt->tableElts)
 	{
@@ -254,14 +259,19 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString)
 				transformColumnDefinition(&cxt, (ColumnDef *) element);
 				break;
 
-			case T_Constraint:
-				transformTableConstraint(&cxt, (Constraint *) element);
-				break;
-
 			case T_TableLikeClause:
+				if (!like_found)
+				{
+					cxt.hasoids = false;
+					like_found = true;
+				}
 				transformTableLikeClause(&cxt, (TableLikeClause *) element);
 				break;
 
+			case T_Constraint:
+				/* process later */
+				break;
+
 			default:
 				elog(ERROR, "unrecognized node type: %d",
 					 (int) nodeTag(element));
@@ -269,6 +279,27 @@ transformCreateStmt(CreateStmt *stmt, const char *queryString)
 		}
 	}
 
+	if (like_found)
+	{
+		/*
+		 * To match INHERITS, the existance of any LIKE table with OIDs
+		 * causes the new table to have oids.  For the same reason,
+		 * WITH/WITHOUT OIDs is also ignored with LIKE.  We prepend
+		 * because the first oid option list entry is honored.  Our
+		 * prepended WITHOUT OIDS clause will be overridden if an
+		 * inherited table has oids.
+		 */
+		stmt->options = lcons(makeDefElem("oids",
+							  (Node *)makeInteger(cxt.hasoids)), stmt->options);
+	}
+
+	foreach(elements, stmt->tableElts)
+	{
+		Node	   *element = lfirst(elements);
+
+		if (nodeTag(element) == T_Constraint)
+			transformTableConstraint(&cxt, (Constraint *) element);
+	}
 	/*
 	 * transformIndexConstraints wants cxt.alist to contain only index
 	 * statements, so transfer anything we already have into save_alist.
@@ -860,6 +891,9 @@ transformTableLikeClause(CreateStmtContext *cxt, TableLikeClause *table_like_cla
 		}
 	}
 
+	/* We use oids if at least one LIKE'ed table has oids. */
+	cxt->hasoids = cxt->hasoids || relation->rd_rel->relhasoids;
+
 	/*
 	 * Copy CHECK constraints if requested, being careful to adjust attribute
 	 * numbers so they match the child.