Adding support for Default partition in partitioning

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index e01ef86..2e675ba 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -90,6 +90,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_def;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	bool		def_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -166,6 +170,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -239,6 +245,8 @@ RelationBuildPartitionDesc(Relation rel)
 			i = 0;
 			found_null = false;
 			null_index = -1;
+			found_def = false;
+			def_index = -1;
 			foreach(cell, boundspecs)
 			{
 				ListCell   *c;
@@ -249,6 +257,15 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
+
+					if (IsA(value, DefElem))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
+
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
@@ -459,6 +476,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_def = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +514,11 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def)
+					{
+						if (mapping[def_index] == -1)
+							mapping[def_index] = next_index++;
+					}
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +527,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->def_index = mapping[def_index];
+					else
+						boundinfo->def_index = -1;
 					break;
 				}
 
@@ -1558,6 +1586,19 @@ generate_partition_qual(Relation rel)
 	bound = stringToNode(TextDatumGetCString(boundDatum));
 	ReleaseSysCache(tuple);
 
+	/* Return if it is a default list partition */
+	PartitionBoundSpec *spec = (PartitionBoundSpec *)bound;
+	ListCell *cell;
+	foreach(cell, spec->listdatums)
+	{
+		Node *value = lfirst(cell);
+		if (IsA(value, DefElem))
+		{
+			/* Keep the parent locked until commit */
+			heap_close(parent, NoLock);
+			return result;
+		}
+	}
 	my_qual = get_qual_from_partbound(rel, parent, bound);
 
 	/* Add the parent's quals to the list (if any) */
@@ -1771,6 +1812,17 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			result = -1;
 			*failed_at = parent;
 			*failed_slot = slot;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_def)
+				result = parent->indexes[partdesc->boundinfo->def_index];
+			else
+			{
+				result = -1;
+				*failed_at = RelationGetRelid(parent->reldesc);
+			}
 			break;
 		}
 		else if (parent->indexes[cur_index] >= 0)
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 6316688..ebb7db7 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -2594,6 +2594,7 @@ partbound_datum:
 			Sconst			{ $$ = makeStringConst($1, @1); }
 			| NumericOnly	{ $$ = makeAConst($1, @1); }
 			| NULL_P		{ $$ = makeNullAConst(@1); }
+			| DEFAULT  { $$ = (Node *)makeDefElem("DEFAULT", NULL, @1); }
 		;
 
 partbound_datum_list:
@@ -2601,7 +2602,6 @@ partbound_datum_list:
 			| partbound_datum_list ',' partbound_datum
 												{ $$ = lappend($1, $3); }
 		;
-
 range_datum_list:
 			PartitionRangeDatum					{ $$ = list_make1($1); }
 			| range_datum_list ',' PartitionRangeDatum
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 673276a..ba05ac8 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -3088,47 +3088,50 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!IsA(value, DefElem))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
+
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
 
-				if (equal(value, value2))
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 5c82325..ffdf633 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -8487,8 +8487,13 @@ get_rule_expr(Node *node, deparse_context *context,
 						sep = "";
 						foreach(cell, spec->listdatums)
 						{
+							Node *value = lfirst(cell);
 							Const	   *val = lfirst(cell);
-
+							if (IsA(value, DefElem))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								continue;
+							}
 							appendStringInfoString(buf, sep);
 							get_const_expr(val, context, -1);
 							sep = ", ";

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index e01ef86..7bc8a8b 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -90,6 +90,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_def;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	int			def_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -118,7 +122,8 @@ static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
 						   void *arg);
 
-static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec);
+static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec,
+								bool is_def, List *boundspecs);
 static List *get_qual_for_range(PartitionKey key, PartitionBoundSpec *spec);
 static Oid get_partition_operator(PartitionKey key, int col,
 					   StrategyNumber strategy, bool *need_relabel);
@@ -166,6 +171,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -249,9 +256,16 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
+					if (IsA(value, DefElem))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
 					if (!val->constisnull)
 					{
 						list_value = (PartitionListValue *)
@@ -459,6 +473,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_def = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +511,11 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def)
+					{
+						if (mapping[def_index] == -1)
+							mapping[def_index] = next_index++;
+					}
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +524,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->def_index = mapping[def_index];
+					else
+						boundinfo->def_index = -1;
 					break;
 				}
 
@@ -690,6 +715,12 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						   boundinfo->strategy == PARTITION_STRATEGY_LIST &&
 						   (boundinfo->ndatums > 0 || boundinfo->has_null));
 
+					if (boundinfo->has_def)
+						ereport(ERROR,
+							(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+								errmsg("parent table \"%s\" has a default partition",
+									RelationGetRelationName(parent))));
+
 					foreach(cell, spec->listdatums)
 					{
 						Const	   *val = lfirst(cell);
@@ -894,6 +925,12 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
+	List	   *inhoids,
+			   *partoids;
+	List	   *boundspecs = NIL;
+	bool		is_def = false;
+	ListCell 	*cell;
+	ListCell 	*cell2;
 
 	Assert(key != NULL);
 
@@ -901,9 +938,78 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			Assert(spec->strategy == PARTITION_STRATEGY_LIST);
-			my_qual = get_qual_for_list(key, spec);
-			break;
+			foreach(cell, spec->listdatums)
+			{
+				Node *value = lfirst(cell);
+				if (IsA(value, DefElem))
+					is_def = true;
+			}
+			if (is_def)
+			{
+				/* Collect bound spec nodes in a list. This is done if the partition is
+				 * a default partition. In case of default partition, constraint is formed
+				 * by performing <> operation over the partition constraints of the
+				 * existing partitions.
+				 */
+				inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+				partoids = NIL;
+				foreach(cell2, inhoids)
+				{
+					Oid			inhrelid = lfirst_oid(cell2);
+					HeapTuple	tuple;
+					Datum		datum;
+					bool		isnull;
+					Node	   *boundspec;
+					bool		def_elem = false;
+					PartitionBoundSpec *bspec;
+					ListCell *cell1;
+					ListCell *cell3;
+
+					tuple = SearchSysCache1(RELOID, inhrelid);
+					if (!HeapTupleIsValid(tuple))
+						elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+					/*
+					 * It is possible that the pg_class tuple of a partition has not been
+					 * updated yet to set its relpartbound field.  The only case where
+					 * this happens is when we open the parent relation to check using its
+					 * partition descriptor that a new partition's bound does not overlap
+					 * some existing partition.
+					 */
+					if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
 
+					datum = SysCacheGetAttr(RELOID, tuple,
+											Anum_pg_class_relpartbound,
+											&isnull);
+					Assert(!isnull);
+					boundspec = (Node *) stringToNode(TextDatumGetCString(datum));
+					bspec = (PartitionBoundSpec *)boundspec;
+					foreach(cell1, bspec->listdatums)
+					{
+						Node *value = lfirst(cell1);
+						if (IsA(value, DefElem))
+							def_elem = true;
+					}
+					if (def_elem)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
+					foreach(cell3, bspec->listdatums)
+					{
+						Node *value = lfirst(cell3);
+						boundspecs = lappend(boundspecs, value);
+					}
+					partoids = lappend_oid(partoids, inhrelid);
+					ReleaseSysCache(tuple);
+				}
+			}
+			my_qual = get_qual_for_list(key, spec, is_def, boundspecs);
+			break;
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
 			my_qual = get_qual_for_range(key, spec);
@@ -1147,7 +1253,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
  * Returns a list of expressions to use as a list partition's constraint.
  */
 static List *
-get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
+get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec, bool is_def,
+					List *boundspecs)
 {
 	List	   *result;
 	ArrayExpr  *arr;
@@ -1225,7 +1332,10 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		: key->parttypid[0];
 	arr->array_collid = key->parttypcoll[0];
 	arr->element_typeid = key->parttypid[0];
-	arr->elements = spec->listdatums;
+	if (is_def)
+		arr->elements = boundspecs;
+	else
+		arr->elements = spec->listdatums;
 	arr->multidims = false;
 	arr->location = -1;
 
@@ -1239,15 +1349,28 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 										  key->partcollation[0],
 										  COERCE_EXPLICIT_CAST);
 
+	/* Build leftop <> ALL(rightop). This is for default partition */
+	if (is_def)
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = 518;
+		opexpr->opfuncid = get_opcode(opexpr->opno);
+		opexpr->useOr = false;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	/* Build leftop = ANY (rightop) */
-	opexpr = makeNode(ScalarArrayOpExpr);
-	opexpr->opno = operoid;
-	opexpr->opfuncid = get_opcode(operoid);
-	opexpr->useOr = true;
-	opexpr->inputcollid = key->partcollation[0];
-	opexpr->args = list_make2(keyCol, arr);
-	opexpr->location = -1;
-
+	else
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = true;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	if (nulltest1)
 		result = list_make2(nulltest1, opexpr);
 	else if (nulltest2)
@@ -1771,6 +1894,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			result = -1;
 			*failed_at = parent;
 			*failed_slot = slot;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_def && key->strategy
+				== PARTITION_STRATEGY_LIST)
+				result = parent->indexes[partdesc->boundinfo->def_index];
 			break;
 		}
 		else if (parent->indexes[cur_index] >= 0)
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 82844a0..5b21dc9 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -2595,6 +2595,7 @@ partbound_datum:
 			Sconst			{ $$ = makeStringConst($1, @1); }
 			| NumericOnly	{ $$ = makeAConst($1, @1); }
 			| NULL_P		{ $$ = makeNullAConst(@1); }
+			| DEFAULT  { $$ = (Node *)makeDefElem("DEFAULT", NULL, @1); }
 		;
 
 partbound_datum_list:
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 673276a..ba05ac8 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -3088,47 +3088,50 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!IsA(value, DefElem))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
+
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
 
-				if (equal(value, value2))
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 5c82325..ffdf633 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -8487,8 +8487,13 @@ get_rule_expr(Node *node, deparse_context *context,
 						sep = "";
 						foreach(cell, spec->listdatums)
 						{
+							Node *value = lfirst(cell);
 							Const	   *val = lfirst(cell);
-
+							if (IsA(value, DefElem))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								continue;
+							}
 							appendStringInfoString(buf, sep);
 							get_const_expr(val, context, -1);
 							sep = ", ";

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index ab891f6..f5a9f44 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -34,6 +34,7 @@
 #include "nodes/nodeFuncs.h"
 #include "nodes/parsenodes.h"
 #include "optimizer/clauses.h"
+#include "optimizer/prep.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
 #include "rewrite/rewriteManip.h"
@@ -90,6 +91,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_def;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	int			def_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -118,7 +123,8 @@ static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
 						   void *arg);
 
-static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec);
+static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec,
+								bool is_def, List *boundspecs);
 static List *get_qual_for_range(PartitionKey key, PartitionBoundSpec *spec);
 static Oid get_partition_operator(PartitionKey key, int col,
 					   StrategyNumber strategy, bool *need_relabel);
@@ -166,6 +172,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -249,9 +257,16 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
+					if (IsA(value, DefElem))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
 					if (!val->constisnull)
 					{
 						list_value = (PartitionListValue *)
@@ -459,6 +474,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_def = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +512,11 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def)
+					{
+						if (mapping[def_index] == -1)
+							mapping[def_index] = next_index++;
+					}
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +525,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->def_index = mapping[def_index];
+					else
+						boundinfo->def_index = -1;
 					break;
 				}
 
@@ -671,6 +697,7 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	PartitionDesc partdesc = RelationGetPartitionDesc(parent);
+	PartitionBoundInfo boundinfo;
 	ParseState *pstate = make_parsestate(NULL);
 	int			with = -1;
 	bool		overlap = false;
@@ -679,6 +706,8 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			{
+				boundinfo = partdesc->boundinfo;
+
 				Assert(spec->strategy == PARTITION_STRATEGY_LIST);
 
 				if (partdesc->nparts > 0)
@@ -688,7 +717,8 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 
 					Assert(boundinfo &&
 						   boundinfo->strategy == PARTITION_STRATEGY_LIST &&
-						   (boundinfo->ndatums > 0 || boundinfo->has_null));
+						   (boundinfo->ndatums > 0 || boundinfo->has_null
+							|| boundinfo->has_def));
 
 					foreach(cell, spec->listdatums)
 					{
@@ -836,6 +866,76 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						relname, get_rel_name(partdesc->oids[with])),
 				 parser_errposition(pstate, spec->location)));
 	}
+
+	/*
+	 * When adding a list partition after default partition, scan the
+	 * default partiton for rows satisfying the new partition
+	 * constraint. If found dont allow addition of a new partition.
+	 * Otherwise continue with the creation of new  partition.
+	 */
+	if (spec->strategy == PARTITION_STRATEGY_LIST && partdesc->nparts > 0
+		&& boundinfo->has_def)
+	{
+		List	       *partConstraint = NIL;
+		ExprContext    *econtext;
+		EState	       *estate;
+		Relation	    defrel;
+		HeapScanDesc    scan;
+		HeapTuple	    tuple;
+		ExprState	   *partqualstate = NULL;
+		Snapshot	    snapshot;
+		Oid			    defid;
+		MemoryContext   oldCxt;
+		TupleTableSlot *tupslot;
+		TupleDesc	    tupdesc;
+
+		partConstraint = generate_qual_for_defaultpart(parent, bound, &defid);
+		partConstraint = (List *) eval_const_expressions(NULL,
+													(Node *) partConstraint);
+		partConstraint = (List *) canonicalize_qual((Expr *) partConstraint);
+		partConstraint = list_make1(make_ands_explicit(partConstraint));
+
+		/*
+		 * Generate the constraint and default execution states
+		 */
+		estate = CreateExecutorState();
+
+		defrel = heap_open(defid, AccessShareLock);
+		tupdesc = CreateTupleDescCopy(RelationGetDescr(defrel));
+
+		/* Build expression execution states for partition check quals */
+		partqualstate = ExecPrepareExpr((Expr *) partConstraint,
+						estate);
+
+		econtext = GetPerTupleExprContext(estate);
+		snapshot = RegisterSnapshot(GetLatestSnapshot());
+		scan = heap_beginscan(defrel, snapshot, 0, NULL);
+		tupslot = MakeSingleTupleTableSlot(tupdesc);
+
+		/*
+		 * Switch to per-tuple memory context and reset it for each tuple
+		 * produced, so we don't leak memory.
+		 */
+		oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
+
+		while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
+		{
+			ExecStoreTuple(tuple, tupslot, InvalidBuffer, false);
+			econtext->ecxt_scantuple = tupslot;
+			if (partqualstate && !ExecCheck(partqualstate, econtext))
+				ereport(ERROR,
+						(errcode(ERRCODE_CHECK_VIOLATION),
+				errmsg("new default partition constraint is violated by some row")));
+			ResetExprContext(econtext);
+			CHECK_FOR_INTERRUPTS();
+		}
+		MemoryContextSwitchTo(oldCxt);
+		heap_endscan(scan);
+		UnregisterSnapshot(snapshot);
+		heap_close(defrel, AccessShareLock);
+		ExecDropSingleTupleTableSlot(tupslot);
+	}
+
 }
 
 /*
@@ -884,6 +984,90 @@ get_partition_parent(Oid relid)
 }
 
 /*
+ * Return a list of executable expressions as new partition constraint
+ * for default partition while adding a new partition after default
+ */
+List *
+generate_qual_for_defaultpart(Relation parent, Node *bound, Oid * defid)
+{
+	PartitionKey key = RelationGetPartitionKey(parent);
+	PartitionBoundSpec *spec;
+	List	   *partConstraint = NIL;
+	List	   *inhoids;
+	ListCell   *cell2;
+	ListCell   *cell4;
+	List       *boundspecs = NIL;
+	bool		is_def = true;
+
+	spec = (PartitionBoundSpec *) bound;
+
+	inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+
+	foreach(cell2, inhoids)
+	{
+		PartitionBoundSpec *bspec;
+		Oid			inhrelid = lfirst_oid(cell2);
+		HeapTuple	tuple;
+		Datum		datum;
+		bool		isnull;
+		Node	   *boundspec;
+		bool		def_elem = false;
+		ListCell   *cell1;
+		ListCell   *cell3;
+
+		tuple = SearchSysCache1(RELOID, inhrelid);
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+		/*
+		 * It is possible that the pg_class tuple of a partition has not been
+		 * updated yet to set its relpartbound field.  The only case where
+		 * this happens is when we open the parent relation to check using its
+		 * partition descriptor that a new partition's bound does not overlap
+		 * some existing partition.
+		 */
+		if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+
+		datum = SysCacheGetAttr(RELOID, tuple,
+								Anum_pg_class_relpartbound,
+								&isnull);
+		Assert(!isnull);
+		boundspec = (Node *) stringToNode(TextDatumGetCString(datum));
+		bspec = (PartitionBoundSpec *)boundspec;
+		foreach(cell1, bspec->listdatums)
+		{
+			Node *value = lfirst(cell1);
+			if (IsA(value, DefElem))
+			{
+				def_elem = true;
+				*defid = inhrelid;
+			}
+		}
+		if (def_elem)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+		foreach(cell3, bspec->listdatums)
+		{
+			Node *value = lfirst(cell3);
+			boundspecs = lappend(boundspecs, value);
+		}
+		ReleaseSysCache(tuple);
+	}
+	foreach(cell4, spec->listdatums)
+	{
+		Node *value = lfirst(cell4);
+		boundspecs = lappend(boundspecs, value);
+	}
+	partConstraint = get_qual_for_list(key, spec, is_def, boundspecs);
+	return partConstraint;
+}
+/*
  * get_qual_from_partbound
  *		Given a parser node for partition bound, return the list of executable
  *		expressions as partition constraint
@@ -894,6 +1078,12 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
+	List	   *inhoids,
+			   *partoids;
+	List	   *boundspecs = NIL;
+	bool		is_def = false;
+	ListCell   *cell;
+	ListCell   *cell2;
 
 	Assert(key != NULL);
 
@@ -901,9 +1091,78 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			Assert(spec->strategy == PARTITION_STRATEGY_LIST);
-			my_qual = get_qual_for_list(key, spec);
-			break;
+			foreach(cell, spec->listdatums)
+			{
+				Node *value = lfirst(cell);
+				if (IsA(value, DefElem))
+					is_def = true;
+			}
+			if (is_def)
+			{
+				/* Collect bound spec nodes in a list. This is done if the partition is
+				 * a default partition. In case of default partition, constraint is formed
+				 * by performing <> operation over the partition constraints of the
+				 * existing partitions.
+				 */
+				inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+				partoids = NIL;
+				foreach(cell2, inhoids)
+				{
+					Oid			inhrelid = lfirst_oid(cell2);
+					HeapTuple	tuple;
+					Datum		datum;
+					bool		isnull;
+					Node	   *boundspec;
+					bool		def_elem = false;
+					PartitionBoundSpec *bspec;
+					ListCell *cell1;
+					ListCell *cell3;
+
+					tuple = SearchSysCache1(RELOID, inhrelid);
+					if (!HeapTupleIsValid(tuple))
+						elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+					/*
+					 * It is possible that the pg_class tuple of a partition has not been
+					 * updated yet to set its relpartbound field.  The only case where
+					 * this happens is when we open the parent relation to check using its
+					 * partition descriptor that a new partition's bound does not overlap
+					 * some existing partition.
+					 */
+					if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
 
+					datum = SysCacheGetAttr(RELOID, tuple,
+											Anum_pg_class_relpartbound,
+											&isnull);
+					Assert(!isnull);
+					boundspec = (Node *) stringToNode(TextDatumGetCString(datum));
+					bspec = (PartitionBoundSpec *)boundspec;
+					foreach(cell1, bspec->listdatums)
+					{
+						Node *value = lfirst(cell1);
+						if (IsA(value, DefElem))
+							def_elem = true;
+					}
+					if (def_elem)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
+					foreach(cell3, bspec->listdatums)
+					{
+						Node *value = lfirst(cell3);
+						boundspecs = lappend(boundspecs, value);
+					}
+					partoids = lappend_oid(partoids, inhrelid);
+					ReleaseSysCache(tuple);
+				}
+			}
+			my_qual = get_qual_for_list(key, spec, is_def, boundspecs);
+			break;
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
 			my_qual = get_qual_for_range(key, spec);
@@ -1151,7 +1410,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
  * Returns a list of expressions to use as a list partition's constraint.
  */
 static List *
-get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
+get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec, bool is_def,
+					List *boundspecs)
 {
 	List	   *result;
 	ArrayExpr  *arr;
@@ -1229,7 +1489,10 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		: key->parttypid[0];
 	arr->array_collid = key->parttypcoll[0];
 	arr->element_typeid = key->parttypid[0];
-	arr->elements = spec->listdatums;
+	if (is_def)
+		arr->elements = boundspecs;
+	else
+		arr->elements = spec->listdatums;
 	arr->multidims = false;
 	arr->location = -1;
 
@@ -1243,15 +1506,28 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 										  key->partcollation[0],
 										  COERCE_EXPLICIT_CAST);
 
+	/* Build leftop <> ALL(rightop). This is for default partition */
+	if (is_def)
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = 518;
+		opexpr->opfuncid = get_opcode(opexpr->opno);
+		opexpr->useOr = false;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	/* Build leftop = ANY (rightop) */
-	opexpr = makeNode(ScalarArrayOpExpr);
-	opexpr->opno = operoid;
-	opexpr->opfuncid = get_opcode(operoid);
-	opexpr->useOr = true;
-	opexpr->inputcollid = key->partcollation[0];
-	opexpr->args = list_make2(keyCol, arr);
-	opexpr->location = -1;
-
+	else
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = true;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	if (nulltest1)
 		result = list_make2(nulltest1, opexpr);
 	else if (nulltest2)
@@ -1778,6 +2054,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			result = -1;
 			*failed_at = parent;
 			*failed_slot = slot;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_def && key->strategy
+				== PARTITION_STRATEGY_LIST)
+				result = parent->indexes[partdesc->boundinfo->def_index];
 			break;
 		}
 		else if (parent->indexes[cur_index] >= 0)
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index d418d56..69268b1 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -750,6 +750,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
 		ParseState *pstate;
 		Oid			parentId = linitial_oid(inheritOids);
 		Relation	parent;
+		PartitionDesc partdesc;
 
 		/* Already have strong enough lock on the parent */
 		parent = heap_open(parentId, NoLock);
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 9d53a29..7114d7f 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -2596,6 +2596,7 @@ partbound_datum:
 			Sconst			{ $$ = makeStringConst($1, @1); }
 			| NumericOnly	{ $$ = makeAConst($1, @1); }
 			| NULL_P		{ $$ = makeNullAConst(@1); }
+			| DEFAULT  { $$ = (Node *)makeDefElem("DEFAULT", NULL, @1); }
 		;
 
 partbound_datum_list:
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 1ae43dc..17605c3 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -3088,47 +3088,50 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!IsA(value, DefElem))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
+
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
 
-				if (equal(value, value2))
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 0c1a201..5732bbc 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -8559,8 +8559,14 @@ get_rule_expr(Node *node, deparse_context *context,
 						sep = "";
 						foreach(cell, spec->listdatums)
 						{
+							Node *value = lfirst(cell);
 							Const	   *val = lfirst(cell);
 
+							if (IsA(value, DefElem))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								continue;
+							}
 							appendStringInfoString(buf, sep);
 							get_const_expr(val, context, -1);
 							sep = ", ";
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 421644c..9c92a8a 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -77,6 +77,7 @@ extern bool partition_bounds_equal(PartitionKey key,
 extern void check_new_partition_bound(char *relname, Relation parent, Node *bound);
 extern Oid	get_partition_parent(Oid relid);
 extern List *get_qual_from_partbound(Relation rel, Relation parent, Node *bound);
+extern List *generate_qual_for_defaultpart(Relation parent, Node *bound ,Oid *defid);
 extern List *map_partition_varattnos(List *expr, int target_varno,
 						Relation partrel, Relation parent);
 extern List *RelationGetPartitionQual(Relation rel);

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index ab891f6..3aaf59f 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -34,6 +34,7 @@
 #include "nodes/nodeFuncs.h"
 #include "nodes/parsenodes.h"
 #include "optimizer/clauses.h"
+#include "optimizer/prep.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
 #include "rewrite/rewriteManip.h"
@@ -90,6 +91,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_def;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	int			def_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -118,7 +123,8 @@ static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
 						   void *arg);
 
-static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec);
+static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec,
+								bool is_def, List *boundspecs);
 static List *get_qual_for_range(PartitionKey key, PartitionBoundSpec *spec);
 static Oid get_partition_operator(PartitionKey key, int col,
 					   StrategyNumber strategy, bool *need_relabel);
@@ -166,6 +172,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -249,9 +257,16 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
+					if (IsA(value, DefElem))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
 					if (!val->constisnull)
 					{
 						list_value = (PartitionListValue *)
@@ -459,6 +474,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_def = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +512,11 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def)
+					{
+						if (mapping[def_index] == -1)
+							mapping[def_index] = next_index++;
+					}
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +525,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->def_index = mapping[def_index];
+					else
+						boundinfo->def_index = -1;
 					break;
 				}
 
@@ -671,6 +697,7 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	PartitionDesc partdesc = RelationGetPartitionDesc(parent);
+	PartitionBoundInfo boundinfo;
 	ParseState *pstate = make_parsestate(NULL);
 	int			with = -1;
 	bool		overlap = false;
@@ -679,6 +706,8 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			{
+				boundinfo = partdesc->boundinfo;
+
 				Assert(spec->strategy == PARTITION_STRATEGY_LIST);
 
 				if (partdesc->nparts > 0)
@@ -688,7 +717,8 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 
 					Assert(boundinfo &&
 						   boundinfo->strategy == PARTITION_STRATEGY_LIST &&
-						   (boundinfo->ndatums > 0 || boundinfo->has_null));
+						   (boundinfo->ndatums > 0 || boundinfo->has_null
+							|| boundinfo->has_def));
 
 					foreach(cell, spec->listdatums)
 					{
@@ -836,6 +866,76 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						relname, get_rel_name(partdesc->oids[with])),
 				 parser_errposition(pstate, spec->location)));
 	}
+
+	/*
+	 * When adding a list partition after default partition, scan the
+	 * default partiton for rows satisfying the new partition
+	 * constraint. If found dont allow addition of a new partition.
+	 * Otherwise continue with the creation of new  partition.
+	 */
+	if (spec->strategy == PARTITION_STRATEGY_LIST && partdesc->nparts > 0
+		&& boundinfo->has_def)
+	{
+		List	       *partConstraint = NIL;
+		ExprContext    *econtext;
+		EState	       *estate;
+		Relation	    defrel;
+		HeapScanDesc    scan;
+		HeapTuple	    tuple;
+		ExprState	   *partqualstate = NULL;
+		Snapshot	    snapshot;
+		Oid			    defid;
+		MemoryContext   oldCxt;
+		TupleTableSlot *tupslot;
+		TupleDesc	    tupdesc;
+
+		partConstraint = generate_qual_for_defaultpart(parent, bound, &defid);
+		partConstraint = (List *) eval_const_expressions(NULL,
+													(Node *) partConstraint);
+		partConstraint = (List *) canonicalize_qual((Expr *) partConstraint);
+		partConstraint = list_make1(make_ands_explicit(partConstraint));
+
+		/*
+		 * Generate the constraint and default execution states
+		 */
+		estate = CreateExecutorState();
+
+		defrel = heap_open(defid, AccessShareLock);
+		tupdesc = CreateTupleDescCopy(RelationGetDescr(defrel));
+
+		/* Build expression execution states for partition check quals */
+		partqualstate = ExecPrepareCheck(partConstraint,
+						estate);
+
+		econtext = GetPerTupleExprContext(estate);
+		snapshot = RegisterSnapshot(GetLatestSnapshot());
+		scan = heap_beginscan(defrel, snapshot, 0, NULL);
+		tupslot = MakeSingleTupleTableSlot(tupdesc);
+
+		/*
+		 * Switch to per-tuple memory context and reset it for each tuple
+		 * produced, so we don't leak memory.
+		 */
+		oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
+
+		while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
+		{
+			ExecStoreTuple(tuple, tupslot, InvalidBuffer, false);
+			econtext->ecxt_scantuple = tupslot;
+			if (partqualstate && !ExecCheck(partqualstate, econtext))
+				ereport(ERROR,
+						(errcode(ERRCODE_CHECK_VIOLATION),
+				errmsg("new default partition constraint is violated by some row")));
+			ResetExprContext(econtext);
+			CHECK_FOR_INTERRUPTS();
+		}
+		MemoryContextSwitchTo(oldCxt);
+		heap_endscan(scan);
+		UnregisterSnapshot(snapshot);
+		heap_close(defrel, AccessShareLock);
+		ExecDropSingleTupleTableSlot(tupslot);
+	}
+
 }
 
 /*
@@ -884,6 +984,90 @@ get_partition_parent(Oid relid)
 }
 
 /*
+ * Return a list of executable expressions as new partition constraint
+ * for default partition while adding a new partition after default
+ */
+List *
+generate_qual_for_defaultpart(Relation parent, Node *bound, Oid * defid)
+{
+	PartitionKey key = RelationGetPartitionKey(parent);
+	PartitionBoundSpec *spec;
+	List	   *partConstraint = NIL;
+	List	   *inhoids;
+	ListCell   *cell2;
+	ListCell   *cell4;
+	List       *boundspecs = NIL;
+	bool		is_def = true;
+
+	spec = (PartitionBoundSpec *) bound;
+
+	inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+
+	foreach(cell2, inhoids)
+	{
+		PartitionBoundSpec *bspec;
+		Oid			inhrelid = lfirst_oid(cell2);
+		HeapTuple	tuple;
+		Datum		datum;
+		bool		isnull;
+		Node	   *boundspec;
+		bool		def_elem = false;
+		ListCell   *cell1;
+		ListCell   *cell3;
+
+		tuple = SearchSysCache1(RELOID, inhrelid);
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+		/*
+		 * It is possible that the pg_class tuple of a partition has not been
+		 * updated yet to set its relpartbound field.  The only case where
+		 * this happens is when we open the parent relation to check using its
+		 * partition descriptor that a new partition's bound does not overlap
+		 * some existing partition.
+		 */
+		if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+
+		datum = SysCacheGetAttr(RELOID, tuple,
+								Anum_pg_class_relpartbound,
+								&isnull);
+		Assert(!isnull);
+		boundspec = (Node *) stringToNode(TextDatumGetCString(datum));
+		bspec = (PartitionBoundSpec *)boundspec;
+		foreach(cell1, bspec->listdatums)
+		{
+			Node *value = lfirst(cell1);
+			if (IsA(value, DefElem))
+			{
+				def_elem = true;
+				*defid = inhrelid;
+			}
+		}
+		if (def_elem)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+		foreach(cell3, bspec->listdatums)
+		{
+			Node *value = lfirst(cell3);
+			boundspecs = lappend(boundspecs, value);
+		}
+		ReleaseSysCache(tuple);
+	}
+	foreach(cell4, spec->listdatums)
+	{
+		Node *value = lfirst(cell4);
+		boundspecs = lappend(boundspecs, value);
+	}
+	partConstraint = get_qual_for_list(key, spec, is_def, boundspecs);
+	return partConstraint;
+}
+/*
  * get_qual_from_partbound
  *		Given a parser node for partition bound, return the list of executable
  *		expressions as partition constraint
@@ -894,6 +1078,12 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
+	List	   *inhoids,
+			   *partoids;
+	List	   *boundspecs = NIL;
+	bool		is_def = false;
+	ListCell   *cell;
+	ListCell   *cell2;
 
 	Assert(key != NULL);
 
@@ -901,9 +1091,78 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			Assert(spec->strategy == PARTITION_STRATEGY_LIST);
-			my_qual = get_qual_for_list(key, spec);
-			break;
+			foreach(cell, spec->listdatums)
+			{
+				Node *value = lfirst(cell);
+				if (IsA(value, DefElem))
+					is_def = true;
+			}
+			if (is_def)
+			{
+				/* Collect bound spec nodes in a list. This is done if the partition is
+				 * a default partition. In case of default partition, constraint is formed
+				 * by performing <> operation over the partition constraints of the
+				 * existing partitions.
+				 */
+				inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+				partoids = NIL;
+				foreach(cell2, inhoids)
+				{
+					Oid			inhrelid = lfirst_oid(cell2);
+					HeapTuple	tuple;
+					Datum		datum;
+					bool		isnull;
+					Node	   *boundspec;
+					bool		def_elem = false;
+					PartitionBoundSpec *bspec;
+					ListCell *cell1;
+					ListCell *cell3;
+
+					tuple = SearchSysCache1(RELOID, inhrelid);
+					if (!HeapTupleIsValid(tuple))
+						elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+					/*
+					 * It is possible that the pg_class tuple of a partition has not been
+					 * updated yet to set its relpartbound field.  The only case where
+					 * this happens is when we open the parent relation to check using its
+					 * partition descriptor that a new partition's bound does not overlap
+					 * some existing partition.
+					 */
+					if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
 
+					datum = SysCacheGetAttr(RELOID, tuple,
+											Anum_pg_class_relpartbound,
+											&isnull);
+					Assert(!isnull);
+					boundspec = (Node *) stringToNode(TextDatumGetCString(datum));
+					bspec = (PartitionBoundSpec *)boundspec;
+					foreach(cell1, bspec->listdatums)
+					{
+						Node *value = lfirst(cell1);
+						if (IsA(value, DefElem))
+							def_elem = true;
+					}
+					if (def_elem)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
+					foreach(cell3, bspec->listdatums)
+					{
+						Node *value = lfirst(cell3);
+						boundspecs = lappend(boundspecs, value);
+					}
+					partoids = lappend_oid(partoids, inhrelid);
+					ReleaseSysCache(tuple);
+				}
+			}
+			my_qual = get_qual_for_list(key, spec, is_def, boundspecs);
+			break;
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
 			my_qual = get_qual_for_range(key, spec);
@@ -1151,7 +1410,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
  * Returns a list of expressions to use as a list partition's constraint.
  */
 static List *
-get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
+get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec, bool is_def,
+					List *boundspecs)
 {
 	List	   *result;
 	ArrayExpr  *arr;
@@ -1229,7 +1489,10 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		: key->parttypid[0];
 	arr->array_collid = key->parttypcoll[0];
 	arr->element_typeid = key->parttypid[0];
-	arr->elements = spec->listdatums;
+	if (is_def)
+		arr->elements = boundspecs;
+	else
+		arr->elements = spec->listdatums;
 	arr->multidims = false;
 	arr->location = -1;
 
@@ -1243,15 +1506,28 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 										  key->partcollation[0],
 										  COERCE_EXPLICIT_CAST);
 
+	/* Build leftop <> ALL(rightop). This is for default partition */
+	if (is_def)
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = 518;
+		opexpr->opfuncid = get_opcode(opexpr->opno);
+		opexpr->useOr = false;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	/* Build leftop = ANY (rightop) */
-	opexpr = makeNode(ScalarArrayOpExpr);
-	opexpr->opno = operoid;
-	opexpr->opfuncid = get_opcode(operoid);
-	opexpr->useOr = true;
-	opexpr->inputcollid = key->partcollation[0];
-	opexpr->args = list_make2(keyCol, arr);
-	opexpr->location = -1;
-
+	else
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = true;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	if (nulltest1)
 		result = list_make2(nulltest1, opexpr);
 	else if (nulltest2)
@@ -1778,6 +2054,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			result = -1;
 			*failed_at = parent;
 			*failed_slot = slot;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_def && key->strategy
+				== PARTITION_STRATEGY_LIST)
+				result = parent->indexes[partdesc->boundinfo->def_index];
 			break;
 		}
 		else if (parent->indexes[cur_index] >= 0)
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index d418d56..69268b1 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -750,6 +750,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
 		ParseState *pstate;
 		Oid			parentId = linitial_oid(inheritOids);
 		Relation	parent;
+		PartitionDesc partdesc;
 
 		/* Already have strong enough lock on the parent */
 		parent = heap_open(parentId, NoLock);
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 9d53a29..7114d7f 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -2596,6 +2596,7 @@ partbound_datum:
 			Sconst			{ $$ = makeStringConst($1, @1); }
 			| NumericOnly	{ $$ = makeAConst($1, @1); }
 			| NULL_P		{ $$ = makeNullAConst(@1); }
+			| DEFAULT  { $$ = (Node *)makeDefElem("DEFAULT", NULL, @1); }
 		;
 
 partbound_datum_list:
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 1ae43dc..17605c3 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -3088,47 +3088,50 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!IsA(value, DefElem))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
+
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
 
-				if (equal(value, value2))
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 0c1a201..5732bbc 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -8559,8 +8559,14 @@ get_rule_expr(Node *node, deparse_context *context,
 						sep = "";
 						foreach(cell, spec->listdatums)
 						{
+							Node *value = lfirst(cell);
 							Const	   *val = lfirst(cell);
 
+							if (IsA(value, DefElem))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								continue;
+							}
 							appendStringInfoString(buf, sep);
 							get_const_expr(val, context, -1);
 							sep = ", ";
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 421644c..9c92a8a 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -77,6 +77,7 @@ extern bool partition_bounds_equal(PartitionKey key,
 extern void check_new_partition_bound(char *relname, Relation parent, Node *bound);
 extern Oid	get_partition_parent(Oid relid);
 extern List *get_qual_from_partbound(Relation rel, Relation parent, Node *bound);
+extern List *generate_qual_for_defaultpart(Relation parent, Node *bound ,Oid *defid);
 extern List *map_partition_varattnos(List *expr, int target_varno,
 						Relation partrel, Relation parent);
 extern List *RelationGetPartitionQual(Relation rel);

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index ab891f6..b7c3e85 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -34,6 +34,7 @@
 #include "nodes/nodeFuncs.h"
 #include "nodes/parsenodes.h"
 #include "optimizer/clauses.h"
+#include "optimizer/prep.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
 #include "rewrite/rewriteManip.h"
@@ -90,6 +91,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_def;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	int			def_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -118,7 +123,8 @@ static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
 						   void *arg);
 
-static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec);
+static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec,
+								bool is_def, List *boundspecs);
 static List *get_qual_for_range(PartitionKey key, PartitionBoundSpec *spec);
 static Oid get_partition_operator(PartitionKey key, int col,
 					   StrategyNumber strategy, bool *need_relabel);
@@ -166,6 +172,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -249,9 +257,16 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
+					if (IsA(value, DefElem))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
 					if (!val->constisnull)
 					{
 						list_value = (PartitionListValue *)
@@ -459,6 +474,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_def = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +512,11 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def)
+					{
+						if (mapping[def_index] == -1)
+							mapping[def_index] = next_index++;
+					}
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +525,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->def_index = mapping[def_index];
+					else
+						boundinfo->def_index = -1;
 					break;
 				}
 
@@ -671,6 +697,7 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	PartitionDesc partdesc = RelationGetPartitionDesc(parent);
+	PartitionBoundInfo boundinfo;
 	ParseState *pstate = make_parsestate(NULL);
 	int			with = -1;
 	bool		overlap = false;
@@ -679,6 +706,8 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			{
+				boundinfo = partdesc->boundinfo;
+
 				Assert(spec->strategy == PARTITION_STRATEGY_LIST);
 
 				if (partdesc->nparts > 0)
@@ -688,13 +717,15 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 
 					Assert(boundinfo &&
 						   boundinfo->strategy == PARTITION_STRATEGY_LIST &&
-						   (boundinfo->ndatums > 0 || boundinfo->has_null));
+						   (boundinfo->ndatums > 0 || boundinfo->has_null
+							|| boundinfo->has_def));
 
 					foreach(cell, spec->listdatums)
 					{
-						Const	   *val = lfirst(cell);
+						Node	   *value = lfirst(cell);
+						Const	   *val = (Const *) value;
 
-						if (!val->constisnull)
+						if (!val->constisnull && !(IsA(value, DefElem)))
 						{
 							int			offset;
 							bool		equal;
@@ -709,7 +740,13 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 								break;
 							}
 						}
-						else if (boundinfo->has_null)
+						else if (IsA(value, DefElem) && boundinfo->has_def)
+						{
+							overlap = true;
+							with = boundinfo->def_index;
+							break;
+						}
+						else if (val->constisnull && boundinfo->has_null)
 						{
 							overlap = true;
 							with = boundinfo->null_index;
@@ -717,7 +754,6 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						}
 					}
 				}
-
 				break;
 			}
 
@@ -836,6 +872,76 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						relname, get_rel_name(partdesc->oids[with])),
 				 parser_errposition(pstate, spec->location)));
 	}
+
+	/*
+	 * When adding a list partition after default partition, scan the
+	 * default partiton for rows satisfying the new partition
+	 * constraint. If found dont allow addition of a new partition.
+	 * Otherwise continue with the creation of new  partition.
+	 */
+	if (spec->strategy == PARTITION_STRATEGY_LIST && partdesc->nparts > 0
+		&& boundinfo->has_def)
+	{
+		List	       *partConstraint = NIL;
+		ExprContext    *econtext;
+		EState	       *estate;
+		Relation	    defrel;
+		HeapScanDesc    scan;
+		HeapTuple	    tuple;
+		ExprState	   *partqualstate = NULL;
+		Snapshot	    snapshot;
+		Oid			    defid;
+		MemoryContext   oldCxt;
+		TupleTableSlot *tupslot;
+		TupleDesc	    tupdesc;
+
+		partConstraint = generate_qual_for_defaultpart(parent, bound, &defid);
+		partConstraint = (List *) eval_const_expressions(NULL,
+													(Node *) partConstraint);
+		partConstraint = (List *) canonicalize_qual((Expr *) partConstraint);
+		partConstraint = list_make1(make_ands_explicit(partConstraint));
+
+		/*
+		 * Generate the constraint and default execution states
+		 */
+		estate = CreateExecutorState();
+
+		defrel = heap_open(defid, AccessShareLock);
+		tupdesc = CreateTupleDescCopy(RelationGetDescr(defrel));
+
+		/* Build expression execution states for partition check quals */
+		partqualstate = ExecPrepareCheck(partConstraint,
+						estate);
+
+		econtext = GetPerTupleExprContext(estate);
+		snapshot = RegisterSnapshot(GetLatestSnapshot());
+		scan = heap_beginscan(defrel, snapshot, 0, NULL);
+		tupslot = MakeSingleTupleTableSlot(tupdesc);
+
+		/*
+		 * Switch to per-tuple memory context and reset it for each tuple
+		 * produced, so we don't leak memory.
+		 */
+		oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
+
+		while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
+		{
+			ExecStoreTuple(tuple, tupslot, InvalidBuffer, false);
+			econtext->ecxt_scantuple = tupslot;
+			if (partqualstate && !ExecCheck(partqualstate, econtext))
+				ereport(ERROR,
+						(errcode(ERRCODE_CHECK_VIOLATION),
+				errmsg("new default partition constraint is violated by some row")));
+			ResetExprContext(econtext);
+			CHECK_FOR_INTERRUPTS();
+		}
+		MemoryContextSwitchTo(oldCxt);
+		heap_endscan(scan);
+		UnregisterSnapshot(snapshot);
+		heap_close(defrel, AccessShareLock);
+		ExecDropSingleTupleTableSlot(tupslot);
+	}
+
 }
 
 /*
@@ -884,6 +990,90 @@ get_partition_parent(Oid relid)
 }
 
 /*
+ * Return a list of executable expressions as new partition constraint
+ * for default partition while adding a new partition after default
+ */
+List *
+generate_qual_for_defaultpart(Relation parent, Node *bound, Oid * defid)
+{
+	PartitionKey key = RelationGetPartitionKey(parent);
+	PartitionBoundSpec *spec;
+	List	   *partConstraint = NIL;
+	List	   *inhoids;
+	ListCell   *cell2;
+	ListCell   *cell4;
+	List       *boundspecs = NIL;
+	bool		is_def = true;
+
+	spec = (PartitionBoundSpec *) bound;
+
+	inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+
+	foreach(cell2, inhoids)
+	{
+		PartitionBoundSpec *bspec;
+		Oid			inhrelid = lfirst_oid(cell2);
+		HeapTuple	tuple;
+		Datum		datum;
+		bool		isnull;
+		Node	   *boundspec;
+		bool		def_elem = false;
+		ListCell   *cell1;
+		ListCell   *cell3;
+
+		tuple = SearchSysCache1(RELOID, inhrelid);
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+		/*
+		 * It is possible that the pg_class tuple of a partition has not been
+		 * updated yet to set its relpartbound field.  The only case where
+		 * this happens is when we open the parent relation to check using its
+		 * partition descriptor that a new partition's bound does not overlap
+		 * some existing partition.
+		 */
+		if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+
+		datum = SysCacheGetAttr(RELOID, tuple,
+								Anum_pg_class_relpartbound,
+								&isnull);
+		Assert(!isnull);
+		boundspec = (Node *) stringToNode(TextDatumGetCString(datum));
+		bspec = (PartitionBoundSpec *)boundspec;
+		foreach(cell1, bspec->listdatums)
+		{
+			Node *value = lfirst(cell1);
+			if (IsA(value, DefElem))
+			{
+				def_elem = true;
+				*defid = inhrelid;
+			}
+		}
+		if (def_elem)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+		foreach(cell3, bspec->listdatums)
+		{
+			Node *value = lfirst(cell3);
+			boundspecs = lappend(boundspecs, value);
+		}
+		ReleaseSysCache(tuple);
+	}
+	foreach(cell4, spec->listdatums)
+	{
+		Node *value = lfirst(cell4);
+		boundspecs = lappend(boundspecs, value);
+	}
+	partConstraint = get_qual_for_list(key, spec, is_def, boundspecs);
+	return partConstraint;
+}
+/*
  * get_qual_from_partbound
  *		Given a parser node for partition bound, return the list of executable
  *		expressions as partition constraint
@@ -894,6 +1084,12 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
+	List	   *inhoids,
+			   *partoids;
+	List	   *boundspecs = NIL;
+	bool		is_def = false;
+	ListCell   *cell;
+	ListCell   *cell2;
 
 	Assert(key != NULL);
 
@@ -901,9 +1097,78 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			Assert(spec->strategy == PARTITION_STRATEGY_LIST);
-			my_qual = get_qual_for_list(key, spec);
-			break;
+			foreach(cell, spec->listdatums)
+			{
+				Node *value = lfirst(cell);
+				if (IsA(value, DefElem))
+					is_def = true;
+			}
+			if (is_def)
+			{
+				/* Collect bound spec nodes in a list. This is done if the partition is
+				 * a default partition. In case of default partition, constraint is formed
+				 * by performing <> operation over the partition constraints of the
+				 * existing partitions.
+				 */
+				inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+				partoids = NIL;
+				foreach(cell2, inhoids)
+				{
+					Oid			inhrelid = lfirst_oid(cell2);
+					HeapTuple	tuple;
+					Datum		datum;
+					bool		isnull;
+					Node	   *boundspec;
+					bool		def_elem = false;
+					PartitionBoundSpec *bspec;
+					ListCell *cell1;
+					ListCell *cell3;
+
+					tuple = SearchSysCache1(RELOID, inhrelid);
+					if (!HeapTupleIsValid(tuple))
+						elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+					/*
+					 * It is possible that the pg_class tuple of a partition has not been
+					 * updated yet to set its relpartbound field.  The only case where
+					 * this happens is when we open the parent relation to check using its
+					 * partition descriptor that a new partition's bound does not overlap
+					 * some existing partition.
+					 */
+					if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
 
+					datum = SysCacheGetAttr(RELOID, tuple,
+											Anum_pg_class_relpartbound,
+											&isnull);
+					Assert(!isnull);
+					boundspec = (Node *) stringToNode(TextDatumGetCString(datum));
+					bspec = (PartitionBoundSpec *)boundspec;
+					foreach(cell1, bspec->listdatums)
+					{
+						Node *value = lfirst(cell1);
+						if (IsA(value, DefElem))
+							def_elem = true;
+					}
+					if (def_elem)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
+					foreach(cell3, bspec->listdatums)
+					{
+						Node *value = lfirst(cell3);
+						boundspecs = lappend(boundspecs, value);
+					}
+					partoids = lappend_oid(partoids, inhrelid);
+					ReleaseSysCache(tuple);
+				}
+			}
+			my_qual = get_qual_for_list(key, spec, is_def, boundspecs);
+			break;
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
 			my_qual = get_qual_for_range(key, spec);
@@ -1151,7 +1416,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
  * Returns a list of expressions to use as a list partition's constraint.
  */
 static List *
-get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
+get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec, bool is_def,
+					List *boundspecs)
 {
 	List	   *result;
 	ArrayExpr  *arr;
@@ -1229,7 +1495,10 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		: key->parttypid[0];
 	arr->array_collid = key->parttypcoll[0];
 	arr->element_typeid = key->parttypid[0];
-	arr->elements = spec->listdatums;
+	if (is_def)
+		arr->elements = boundspecs;
+	else
+		arr->elements = spec->listdatums;
 	arr->multidims = false;
 	arr->location = -1;
 
@@ -1243,15 +1512,33 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 										  key->partcollation[0],
 										  COERCE_EXPLICIT_CAST);
 
+	/* Build leftop <> ALL(rightop). This is for default partition */
+	if (is_def)
+	{
+		/* Find the negator for the partition operator above */
+		if(get_negator(operoid) == InvalidOid)
+			elog(ERROR, "no negator found for partition operator %u",
+				 operoid);
+		operoid = get_negator(operoid);
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = false;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	/* Build leftop = ANY (rightop) */
-	opexpr = makeNode(ScalarArrayOpExpr);
-	opexpr->opno = operoid;
-	opexpr->opfuncid = get_opcode(operoid);
-	opexpr->useOr = true;
-	opexpr->inputcollid = key->partcollation[0];
-	opexpr->args = list_make2(keyCol, arr);
-	opexpr->location = -1;
-
+	else
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = true;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	if (nulltest1)
 		result = list_make2(nulltest1, opexpr);
 	else if (nulltest2)
@@ -1778,6 +2065,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			result = -1;
 			*failed_at = parent;
 			*failed_slot = slot;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_def && key->strategy
+				== PARTITION_STRATEGY_LIST)
+				result = parent->indexes[partdesc->boundinfo->def_index];
 			break;
 		}
 		else if (parent->indexes[cur_index] >= 0)
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index d418d56..69268b1 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -750,6 +750,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
 		ParseState *pstate;
 		Oid			parentId = linitial_oid(inheritOids);
 		Relation	parent;
+		PartitionDesc partdesc;
 
 		/* Already have strong enough lock on the parent */
 		parent = heap_open(parentId, NoLock);
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 9d53a29..7114d7f 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -2596,6 +2596,7 @@ partbound_datum:
 			Sconst			{ $$ = makeStringConst($1, @1); }
 			| NumericOnly	{ $$ = makeAConst($1, @1); }
 			| NULL_P		{ $$ = makeNullAConst(@1); }
+			| DEFAULT  { $$ = (Node *)makeDefElem("DEFAULT", NULL, @1); }
 		;
 
 partbound_datum_list:
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 1ae43dc..17605c3 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -3088,47 +3088,50 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!IsA(value, DefElem))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
+
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
 
-				if (equal(value, value2))
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 0c1a201..5732bbc 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -8559,8 +8559,14 @@ get_rule_expr(Node *node, deparse_context *context,
 						sep = "";
 						foreach(cell, spec->listdatums)
 						{
+							Node *value = lfirst(cell);
 							Const	   *val = lfirst(cell);
 
+							if (IsA(value, DefElem))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								continue;
+							}
 							appendStringInfoString(buf, sep);
 							get_const_expr(val, context, -1);
 							sep = ", ";
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 421644c..9c92a8a 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -77,6 +77,7 @@ extern bool partition_bounds_equal(PartitionKey key,
 extern void check_new_partition_bound(char *relname, Relation parent, Node *bound);
 extern Oid	get_partition_parent(Oid relid);
 extern List *get_qual_from_partbound(Relation rel, Relation parent, Node *bound);
+extern List *generate_qual_for_defaultpart(Relation parent, Node *bound ,Oid *defid);
 extern List *map_partition_varattnos(List *expr, int target_varno,
 						Relation partrel, Relation parent);
 extern List *RelationGetPartitionQual(Relation rel);

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index e0d2665..47b6c3d 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -34,6 +34,7 @@
 #include "nodes/nodeFuncs.h"
 #include "nodes/parsenodes.h"
 #include "optimizer/clauses.h"
+#include "optimizer/prep.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
 #include "rewrite/rewriteManip.h"
@@ -90,6 +91,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_default;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	int			default_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -118,7 +123,8 @@ static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
 						   void *arg);
 
-static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec);
+static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec,
+								bool is_def, List *boundspecs);
 static List *get_qual_for_range(PartitionKey key, PartitionBoundSpec *spec);
 static Oid get_partition_operator(PartitionKey key, int col,
 					   StrategyNumber strategy, bool *need_relabel);
@@ -166,6 +172,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -249,9 +257,16 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
+					if (isDefaultPartitionBound(value))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
 					if (!val->constisnull)
 					{
 						list_value = (PartitionListValue *)
@@ -459,6 +474,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_default = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +512,8 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def && mapping[def_index] == -1)
+						mapping[def_index] = next_index++;
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +522,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->default_index = mapping[def_index];
+					else
+						boundinfo->default_index = -1;
 					break;
 				}
 
@@ -671,6 +694,7 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	PartitionDesc partdesc = RelationGetPartitionDesc(parent);
+	PartitionBoundInfo boundinfo;
 	ParseState *pstate = make_parsestate(NULL);
 	int			with = -1;
 	bool		overlap = false;
@@ -679,6 +703,8 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			{
+				boundinfo = partdesc->boundinfo;
+
 				Assert(spec->strategy == PARTITION_STRATEGY_LIST);
 
 				if (partdesc->nparts > 0)
@@ -688,13 +714,15 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 
 					Assert(boundinfo &&
 						   boundinfo->strategy == PARTITION_STRATEGY_LIST &&
-						   (boundinfo->ndatums > 0 || boundinfo->has_null));
+						   (boundinfo->ndatums > 0 || boundinfo->has_null
+							|| boundinfo->has_default));
 
 					foreach(cell, spec->listdatums)
 					{
-						Const	   *val = lfirst(cell);
+						Node	   *value = lfirst(cell);
+						Const	   *val = (Const *) value;
 
-						if (!val->constisnull)
+						if (!val->constisnull && !(isDefaultPartitionBound(value)))
 						{
 							int			offset;
 							bool		equal;
@@ -709,7 +737,14 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 								break;
 							}
 						}
-						else if (boundinfo->has_null)
+						else if (isDefaultPartitionBound(value) &&
+								 boundinfo->has_default)
+						{
+							overlap = true;
+							with = boundinfo->default_index;
+							break;
+						}
+						else if (val->constisnull && boundinfo->has_null)
 						{
 							overlap = true;
 							with = boundinfo->null_index;
@@ -836,6 +871,76 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						relname, get_rel_name(partdesc->oids[with])),
 				 parser_errposition(pstate, spec->location)));
 	}
+
+	/*
+	 * When adding a list partition after default partition, scan the
+	 * default partition for rows satisfying the new partition
+	 * constraint. If found don't allow addition of a new partition.
+	 * Otherwise continue with the creation of new  partition.
+	 */
+	if (spec->strategy == PARTITION_STRATEGY_LIST && partdesc->nparts > 0
+		&& boundinfo->has_default)
+	{
+		List	       *partConstraint = NIL;
+		ExprContext    *econtext;
+		EState	       *estate;
+		Relation	    defrel;
+		HeapScanDesc    scan;
+		HeapTuple	    tuple;
+		ExprState	   *partqualstate = NULL;
+		Snapshot	    snapshot;
+		Oid			    defid;
+		MemoryContext   oldCxt;
+		TupleTableSlot *tupslot;
+		TupleDesc	    tupdesc;
+
+		partConstraint = generate_qual_for_defaultpart(parent, bound, &defid);
+		partConstraint = (List *) eval_const_expressions(NULL,
+													(Node *) partConstraint);
+		partConstraint = (List *) canonicalize_qual((Expr *) partConstraint);
+		partConstraint = list_make1(make_ands_explicit(partConstraint));
+
+		/*
+		 * Generate the constraint and default execution states
+		 */
+		estate = CreateExecutorState();
+
+		defrel = heap_open(defid, AccessExclusiveLock);
+		tupdesc = CreateTupleDescCopy(RelationGetDescr(defrel));
+
+		/* Build expression execution states for partition check quals */
+		partqualstate = ExecPrepareCheck(partConstraint,
+						estate);
+
+		econtext = GetPerTupleExprContext(estate);
+		snapshot = RegisterSnapshot(GetLatestSnapshot());
+		scan = heap_beginscan(defrel, snapshot, 0, NULL);
+		tupslot = MakeSingleTupleTableSlot(tupdesc);
+
+		/*
+		 * Switch to per-tuple memory context and reset it for each tuple
+		 * produced, so we don't leak memory.
+		 */
+		oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
+
+		while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
+		{
+			ExecStoreTuple(tuple, tupslot, InvalidBuffer, false);
+			econtext->ecxt_scantuple = tupslot;
+			if (partqualstate && !ExecCheck(partqualstate, econtext))
+				ereport(ERROR,
+						(errcode(ERRCODE_CHECK_VIOLATION),
+				errmsg("new default partition constraint is violated by some row")));
+			ResetExprContext(econtext);
+			CHECK_FOR_INTERRUPTS();
+		}
+		MemoryContextSwitchTo(oldCxt);
+		heap_endscan(scan);
+		UnregisterSnapshot(snapshot);
+		heap_close(defrel, AccessExclusiveLock);
+		ExecDropSingleTupleTableSlot(tupslot);
+	}
+
 }
 
 /*
@@ -884,6 +989,102 @@ get_partition_parent(Oid relid)
 }
 
 /*
+ * Returns true if the partition bound is default
+ */
+bool
+isDefaultPartitionBound(Node *value)
+{
+	if (IsA(value, DefElem))
+	{
+		DefElem *defvalue = (DefElem *) value;
+		if(!strcmp(defvalue->defname, "DEFAULT"))
+			return true;
+		return false;
+	}
+	return false;
+}
+
+/*
+ * Return a list of executable expressions as new partition constraint
+ * for default partition while adding a new partition after default
+ */
+List *
+generate_qual_for_defaultpart(Relation parent, Node *bound, Oid * defid)
+{
+	PartitionKey key = RelationGetPartitionKey(parent);
+	PartitionBoundSpec *spec;
+	List	   *partConstraint = NIL;
+	List	   *inhoids;
+	ListCell   *cell2;
+	ListCell   *cell4;
+	List       *boundspecs = NIL;
+
+	spec = (PartitionBoundSpec *) bound;
+
+	inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+
+	foreach(cell2, inhoids)
+	{
+		PartitionBoundSpec *bspec;
+		Oid			inhrelid = lfirst_oid(cell2);
+		HeapTuple	tuple;
+		Datum		datum;
+		bool		isnull;
+		bool		def_elem = false;
+		ListCell   *cell1;
+		ListCell   *cell3;
+
+		tuple = SearchSysCache1(RELOID, inhrelid);
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+		/*
+		 * It is possible that the pg_class tuple of a partition has not been
+		 * updated yet to set its relpartbound field.  The only case where
+		 * this happens is when we open the parent relation to check using its
+		 * partition descriptor that a new partition's bound does not overlap
+		 * some existing partition.
+		 */
+		if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+
+		datum = SysCacheGetAttr(RELOID, tuple,
+								Anum_pg_class_relpartbound,
+								&isnull);
+		Assert(!isnull);
+		bspec = (PartitionBoundSpec *) stringToNode(TextDatumGetCString(datum));
+		foreach(cell1, bspec->listdatums)
+		{
+			Node *value = lfirst(cell1);
+			if (isDefaultPartitionBound(value))
+			{
+				def_elem = true;
+				*defid = inhrelid;
+			}
+		}
+		if (!def_elem)
+		{
+			foreach(cell3, bspec->listdatums)
+			{
+				Node *value = lfirst(cell3);
+				boundspecs = lappend(boundspecs, value);
+			}
+		}
+		ReleaseSysCache(tuple);
+	}
+	foreach(cell4, spec->listdatums)
+	{
+		Node *value = lfirst(cell4);
+		boundspecs = lappend(boundspecs, value);
+	}
+	partConstraint = get_qual_for_list(key, spec, true, boundspecs);
+	return partConstraint;
+}
+
+/*
  * get_qual_from_partbound
  *		Given a parser node for partition bound, return the list of executable
  *		expressions as partition constraint
@@ -894,6 +1095,11 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
+	List	   *inhoids;
+	List	   *boundspecs = NIL;
+	bool		is_def = false;
+	ListCell   *cell;
+	ListCell   *cell2;
 
 	Assert(key != NULL);
 
@@ -901,9 +1107,72 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			Assert(spec->strategy == PARTITION_STRATEGY_LIST);
-			my_qual = get_qual_for_list(key, spec);
-			break;
+			foreach(cell, spec->listdatums)
+			{
+				Node *value = lfirst(cell);
+				if (isDefaultPartitionBound(value))
+					is_def = true;
+			}
+			if (is_def)
+			{
+				/* Collect bound spec nodes in a list. This is done if the partition is
+				 * a default partition. In case of default partition, constraint is formed
+				 * by performing <> operation over the partition constraints of the
+				 * existing partitions.
+				 */
+				inhoids = find_inheritance_children(RelationGetRelid(parent), NoLock);
+				foreach(cell2, inhoids)
+				{
+					Oid			inhrelid = lfirst_oid(cell2);
+					HeapTuple	tuple;
+					Datum		datum;
+					bool		isnull;
+					bool		def_elem = false;
+					PartitionBoundSpec *bspec;
+					ListCell *cell1;
+					ListCell *cell3;
+
+					tuple = SearchSysCache1(RELOID, inhrelid);
+					if (!HeapTupleIsValid(tuple))
+						elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+					/*
+					 * It is possible that the pg_class tuple of a partition has not been
+					 * updated yet to set its relpartbound field.  The only case where
+					 * this happens is when we open the parent relation to check using its
+					 * partition descriptor that a new partition's bound does not overlap
+					 * some existing partition.
+					 */
+					if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+					{
+						ReleaseSysCache(tuple);
+						continue;
+					}
 
+					datum = SysCacheGetAttr(RELOID, tuple,
+											Anum_pg_class_relpartbound,
+											&isnull);
+					Assert(!isnull);
+					bspec = (PartitionBoundSpec *) stringToNode(TextDatumGetCString(datum));
+					foreach(cell1, bspec->listdatums)
+					{
+						Node *value = lfirst(cell1);
+						if (isDefaultPartitionBound(value))
+							def_elem = true;
+					}
+					if (!def_elem)
+					{
+						foreach(cell3, bspec->listdatums)
+						{
+							Node *value = lfirst(cell3);
+							boundspecs = lappend(boundspecs, value);
+						}
+					}
+					ReleaseSysCache(tuple);
+				}
+			}
+			my_qual = get_qual_for_list(key, spec, is_def, boundspecs);
+			break;
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
 			my_qual = get_qual_for_range(key, spec);
@@ -1151,7 +1420,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
  * Returns a list of expressions to use as a list partition's constraint.
  */
 static List *
-get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
+get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec, bool is_def,
+					List *boundspecs)
 {
 	List	   *result;
 	ArrayExpr  *arr;
@@ -1229,7 +1499,10 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		: key->parttypid[0];
 	arr->array_collid = key->parttypcoll[0];
 	arr->element_typeid = key->parttypid[0];
-	arr->elements = spec->listdatums;
+	if (is_def)
+		arr->elements = boundspecs;
+	else
+		arr->elements = spec->listdatums;
 	arr->multidims = false;
 	arr->location = -1;
 
@@ -1243,15 +1516,33 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 										  key->partcollation[0],
 										  COERCE_EXPLICIT_CAST);
 
+	/* Build leftop <> ALL(rightop). This is for default partition */
+	if (is_def)
+	{
+		/* Find the negator for the partition operator above */
+		if(get_negator(operoid) == InvalidOid)
+			elog(ERROR, "no negator found for partition operator %u",
+				 operoid);
+		operoid = get_negator(operoid);
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = false;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	/* Build leftop = ANY (rightop) */
-	opexpr = makeNode(ScalarArrayOpExpr);
-	opexpr->opno = operoid;
-	opexpr->opfuncid = get_opcode(operoid);
-	opexpr->useOr = true;
-	opexpr->inputcollid = key->partcollation[0];
-	opexpr->args = list_make2(keyCol, arr);
-	opexpr->location = -1;
-
+	else
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = true;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	if (nulltest1)
 		result = list_make2(nulltest1, opexpr);
 	else if (nulltest2)
@@ -1778,6 +2069,13 @@ get_partition_for_tuple(PartitionDispatch *pd,
 			result = -1;
 			*failed_at = parent;
 			*failed_slot = slot;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_default && key->strategy
+				== PARTITION_STRATEGY_LIST)
+				result = parent->indexes[partdesc->boundinfo->default_index];
 			break;
 		}
 		else if (parent->indexes[cur_index] >= 0)
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index a02904c..7277f6f 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -759,6 +759,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
 		ParseState *pstate;
 		Oid			parentId = linitial_oid(inheritOids);
 		Relation	parent;
+		PartitionDesc partdesc;
 
 		/* Already have strong enough lock on the parent */
 		parent = heap_open(parentId, NoLock);
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 89d2836..e0b27cf 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -2677,6 +2677,7 @@ partbound_datum:
 			Sconst			{ $$ = makeStringConst($1, @1); }
 			| NumericOnly	{ $$ = makeAConst($1, @1); }
 			| NULL_P		{ $$ = makeNullAConst(@1); }
+			| DEFAULT  { $$ = (Node *)makeDefElem("DEFAULT", NULL, @1); }
 		;
 
 partbound_datum_list:
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index e546194..c73f963 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -3304,47 +3304,50 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!(isDefaultPartitionBound(value)))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
+
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
 
-				if (equal(value, value2))
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 184e5da..65d8821 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -24,6 +24,7 @@
 #include "access/sysattr.h"
 #include "catalog/dependency.h"
 #include "catalog/indexing.h"
+#include "catalog/partition.h"
 #include "catalog/pg_aggregate.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_authid.h"
@@ -8619,8 +8620,14 @@ get_rule_expr(Node *node, deparse_context *context,
 						sep = "";
 						foreach(cell, spec->listdatums)
 						{
+							Node *value = lfirst(cell);
 							Const	   *val = lfirst(cell);
 
+							if (isDefaultPartitionBound(value))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								continue;
+							}
 							appendStringInfoString(buf, sep);
 							get_const_expr(val, context, -1);
 							sep = ", ";
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 421644c..40da35e 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -73,10 +73,11 @@ typedef struct PartitionDispatchData *PartitionDispatch;
 extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(PartitionKey key,
 					   PartitionBoundInfo p1, PartitionBoundInfo p2);
-
+extern bool isDefaultPartitionBound(Node *value);
 extern void check_new_partition_bound(char *relname, Relation parent, Node *bound);
 extern Oid	get_partition_parent(Oid relid);
 extern List *get_qual_from_partbound(Relation rel, Relation parent, Node *bound);
+extern List *generate_qual_for_defaultpart(Relation parent, Node *bound ,Oid *defid);
 extern List *map_partition_varattnos(List *expr, int target_varno,
 						Relation partrel, Relation parent);
 extern List *RelationGetPartitionQual(Relation rel);

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index e0d2665..38312f2 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -34,6 +34,7 @@
 #include "nodes/nodeFuncs.h"
 #include "nodes/parsenodes.h"
 #include "optimizer/clauses.h"
+#include "optimizer/prep.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
 #include "rewrite/rewriteManip.h"
@@ -90,6 +91,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_default;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	int			default_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -118,7 +123,8 @@ static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
 						   void *arg);
 
-static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec);
+static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec,
+								bool is_def, List *boundspecs);
 static List *get_qual_for_range(PartitionKey key, PartitionBoundSpec *spec);
 static Oid get_partition_operator(PartitionKey key, int col,
 					   StrategyNumber strategy, bool *need_relabel);
@@ -166,6 +172,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -249,9 +257,16 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
+					if (isDefaultPartitionBound(value))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
 					if (!val->constisnull)
 					{
 						list_value = (PartitionListValue *)
@@ -459,6 +474,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_default = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +512,8 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def && mapping[def_index] == -1)
+						mapping[def_index] = next_index++;
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +522,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->default_index = mapping[def_index];
+					else
+						boundinfo->default_index = -1;
 					break;
 				}
 
@@ -513,6 +536,7 @@ RelationBuildPartitionDesc(Relation rel)
 												sizeof(RangeDatumContent *));
 					boundinfo->indexes = (int *) palloc((ndatums + 1) *
 														sizeof(int));
+					boundinfo->has_default = found_def;
 
 					for (i = 0; i < ndatums; i++)
 					{
@@ -671,6 +695,7 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	PartitionDesc partdesc = RelationGetPartitionDesc(parent);
+	PartitionBoundInfo boundinfo;
 	ParseState *pstate = make_parsestate(NULL);
 	int			with = -1;
 	bool		overlap = false;
@@ -679,6 +704,8 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			{
+				boundinfo = partdesc->boundinfo;
+
 				Assert(spec->strategy == PARTITION_STRATEGY_LIST);
 
 				if (partdesc->nparts > 0)
@@ -688,13 +715,15 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 
 					Assert(boundinfo &&
 						   boundinfo->strategy == PARTITION_STRATEGY_LIST &&
-						   (boundinfo->ndatums > 0 || boundinfo->has_null));
+						   (boundinfo->ndatums > 0 || boundinfo->has_null
+							|| boundinfo->has_default));
 
 					foreach(cell, spec->listdatums)
 					{
-						Const	   *val = lfirst(cell);
+						Node	   *value = lfirst(cell);
+						Const	   *val = (Const *) value;
 
-						if (!val->constisnull)
+						if (!val->constisnull && !(isDefaultPartitionBound(value)))
 						{
 							int			offset;
 							bool		equal;
@@ -709,7 +738,14 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 								break;
 							}
 						}
-						else if (boundinfo->has_null)
+						else if (isDefaultPartitionBound(value) &&
+								 boundinfo->has_default)
+						{
+							overlap = true;
+							with = boundinfo->default_index;
+							break;
+						}
+						else if (val->constisnull && boundinfo->has_null)
 						{
 							overlap = true;
 							with = boundinfo->null_index;
@@ -836,6 +872,77 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						relname, get_rel_name(partdesc->oids[with])),
 				 parser_errposition(pstate, spec->location)));
 	}
+
+	/*
+	 * When adding a list partition after default partition, scan the
+	 * default partition for rows satisfying the new partition
+	 * constraint. If found don't allow addition of a new partition.
+	 * Otherwise continue with the creation of new  partition.
+	 */
+	if (spec->strategy == PARTITION_STRATEGY_LIST && partdesc->nparts > 0
+		&& boundinfo->has_default)
+	{
+		List	       *partConstraint = NIL;
+		ExprContext    *econtext;
+		EState	       *estate;
+		Relation	    defrel;
+		HeapScanDesc    scan;
+		HeapTuple	    tuple;
+		ExprState	   *partqualstate = NULL;
+		Snapshot	    snapshot;
+		Oid			    defid;
+		MemoryContext   oldCxt;
+		TupleTableSlot *tupslot;
+		TupleDesc	    tupdesc;
+
+
+		partConstraint = generate_qual_for_defaultpart(parent, bound, &defid);
+		partConstraint = (List *) eval_const_expressions(NULL,
+													(Node *) partConstraint);
+		partConstraint = (List *) canonicalize_qual((Expr *) partConstraint);
+		partConstraint = list_make1(make_ands_explicit(partConstraint));
+
+		/*
+		 * Generate the constraint and default execution states
+		 */
+		estate = CreateExecutorState();
+
+		defrel = heap_open(defid, AccessExclusiveLock);
+		tupdesc = CreateTupleDescCopy(RelationGetDescr(defrel));
+
+		/* Build expression execution states for partition check quals */
+		partqualstate = ExecPrepareCheck(partConstraint,
+						estate);
+
+		econtext = GetPerTupleExprContext(estate);
+		snapshot = RegisterSnapshot(GetLatestSnapshot());
+		scan = heap_beginscan(defrel, snapshot, 0, NULL);
+		tupslot = MakeSingleTupleTableSlot(tupdesc);
+
+		/*
+		 * Switch to per-tuple memory context and reset it for each tuple
+		 * produced, so we don't leak memory.
+		 */
+		oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
+
+		while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
+		{
+			ExecStoreTuple(tuple, tupslot, InvalidBuffer, false);
+			econtext->ecxt_scantuple = tupslot;
+			if (partqualstate && !ExecCheck(partqualstate, econtext))
+				ereport(ERROR,
+						(errcode(ERRCODE_CHECK_VIOLATION),
+				errmsg("new default partition constraint is violated by some row")));
+			ResetExprContext(econtext);
+			CHECK_FOR_INTERRUPTS();
+		}
+		MemoryContextSwitchTo(oldCxt);
+		heap_endscan(scan);
+		UnregisterSnapshot(snapshot);
+		ExecDropSingleTupleTableSlot(tupslot);
+		FreeExecutorState(estate);
+		heap_close(defrel, AccessExclusiveLock);
+	}
 }
 
 /*
@@ -884,6 +991,116 @@ get_partition_parent(Oid relid)
 }
 
 /*
+ * Returns true if the partition bound is default
+ */
+bool
+isDefaultPartitionBound(Node *value)
+{
+	if (IsA(value, DefElem))
+	{
+		DefElem *defvalue = (DefElem *) value;
+		if(!strcmp(defvalue->defname, "DEFAULT"))
+			return true;
+		return false;
+	}
+	return false;
+}
+
+/*
+ * Return the bound spec list to be used
+ * in partition constraint of default partition
+ */
+List *
+get_qual_for_default(Relation parent, Oid *defid)
+{
+	List	   *inhoids;
+	ListCell   *cell;
+	List	   *boundspecs = NIL;
+
+	inhoids = find_inheritance_children(RelationGetRelid(parent), AccessExclusiveLock);
+	foreach(cell, inhoids)
+	{
+		Oid			inhrelid = lfirst_oid(cell);
+		HeapTuple	tuple;
+		Datum		datum;
+		bool		isnull;
+		bool		def_elem = false;
+		PartitionBoundSpec *bspec;
+		ListCell *cell1;
+
+		tuple = SearchSysCache1(RELOID, inhrelid);
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+		/*
+		 * It is possible that the pg_class tuple of a partition has not been
+		 * updated yet to set its relpartbound field.  The only case where
+		 * this happens is when we open the parent relation to check using its
+		 * partition descriptor that a new partition's bound does not overlap
+		 * some existing partition.
+		 */
+		if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+
+		datum = SysCacheGetAttr(RELOID, tuple,
+								Anum_pg_class_relpartbound,
+								&isnull);
+		Assert(!isnull);
+		bspec = (PartitionBoundSpec *) stringToNode(TextDatumGetCString(datum));
+		foreach(cell1, bspec->listdatums)
+		{
+			Node *value = lfirst(cell1);
+			if (isDefaultPartitionBound(value))
+			{
+				def_elem = true;
+				*defid  = inhrelid;
+			}
+		}
+		if (!def_elem)
+		{
+			foreach(cell1, bspec->listdatums)
+			{
+				Node *value = lfirst(cell1);
+				boundspecs = lappend(boundspecs, value);
+			}
+		}
+		ReleaseSysCache(tuple);
+	}
+	return boundspecs;
+}
+
+/*
+ * Return a list of executable expressions as new partition constraint
+ * for default partition while adding a new partition after default
+ */
+List *
+generate_qual_for_defaultpart(Relation parent, Node *bound, Oid * defid)
+{
+	PartitionKey key = RelationGetPartitionKey(parent);
+	PartitionBoundSpec *spec;
+	List	   *partConstraint = NIL;
+	ListCell   *cell;
+	List       *boundspecs = NIL;
+	List       *bound_datums;
+
+	spec = (PartitionBoundSpec *) bound;
+	bound_datums = list_copy(spec->listdatums);
+
+	boundspecs = get_qual_for_default(parent, defid);
+
+	foreach(cell, bound_datums)
+	{
+		Node *value = lfirst(cell);
+		boundspecs = lappend(boundspecs, value);
+	}
+	partConstraint = get_qual_for_list(key, spec, true, boundspecs);
+	return partConstraint;
+}
+
+/*
  * get_qual_from_partbound
  *		Given a parser node for partition bound, return the list of executable
  *		expressions as partition constraint
@@ -894,6 +1111,10 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
+	bool		is_def = false;
+	Oid        defid;
+	ListCell   *cell;
+	List	   *boundspecs = NIL;
 
 	Assert(key != NULL);
 
@@ -901,9 +1122,16 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			Assert(spec->strategy == PARTITION_STRATEGY_LIST);
-			my_qual = get_qual_for_list(key, spec);
+			foreach(cell, spec->listdatums)
+			{
+				Node *value = lfirst(cell);
+				if (isDefaultPartitionBound(value))
+					is_def = true;
+			}
+			if (is_def)
+				boundspecs = get_qual_for_default(parent, &defid);
+			my_qual = get_qual_for_list(key, spec, is_def, boundspecs);
 			break;
-
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
 			my_qual = get_qual_for_range(key, spec);
@@ -1151,7 +1379,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
  * Returns a list of expressions to use as a list partition's constraint.
  */
 static List *
-get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
+get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec, bool is_def,
+					List *boundspecs)
 {
 	List	   *result;
 	ArrayExpr  *arr;
@@ -1177,12 +1406,14 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 	else
 		keyCol = (Expr *) copyObject(linitial(key->partexprs));
 
+	if (!is_def)
+		boundspecs = spec->listdatums;
 	/*
 	 * We must remove any NULL value in the list; we handle it separately
 	 * below.
 	 */
 	prev = NULL;
-	for (cell = list_head(spec->listdatums); cell; cell = next)
+	for (cell = list_head(boundspecs); cell; cell = next)
 	{
 		Const	   *val = (Const *) lfirst(cell);
 
@@ -1191,14 +1422,14 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		if (val->constisnull)
 		{
 			list_has_null = true;
-			spec->listdatums = list_delete_cell(spec->listdatums,
+			boundspecs = list_delete_cell(boundspecs,
 												cell, prev);
 		}
 		else
 			prev = cell;
 	}
 
-	if (!list_has_null)
+	if ((is_def && list_has_null) || (!is_def && !list_has_null))
 	{
 		/*
 		 * Gin up a col IS NOT NULL test that will be AND'd with other
@@ -1210,7 +1441,7 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		nulltest1->argisrow = false;
 		nulltest1->location = -1;
 	}
-	else
+	else if(!is_def && list_has_null)
 	{
 		/*
 		 * Gin up a col IS NULL test that will be OR'd with other expressions
@@ -1229,7 +1460,7 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		: key->parttypid[0];
 	arr->array_collid = key->parttypcoll[0];
 	arr->element_typeid = key->parttypid[0];
-	arr->elements = spec->listdatums;
+	arr->elements = boundspecs;
 	arr->multidims = false;
 	arr->location = -1;
 
@@ -1243,15 +1474,34 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 										  key->partcollation[0],
 										  COERCE_EXPLICIT_CAST);
 
+	/* Build leftop <> ALL(rightop). This is for default partition */
+	if (is_def)
+	{
+		/* Find the negator for the partition operator above */
+		if(get_negator(operoid) == InvalidOid)
+			ereport(ERROR, (errcode(ERRCODE_CHECK_VIOLATION),
+			errmsg("DEFAULT partition cannot be used without negator of operator  %s",
+						get_opname(operoid))));
+		operoid = get_negator(operoid);
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = false;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	/* Build leftop = ANY (rightop) */
-	opexpr = makeNode(ScalarArrayOpExpr);
-	opexpr->opno = operoid;
-	opexpr->opfuncid = get_opcode(operoid);
-	opexpr->useOr = true;
-	opexpr->inputcollid = key->partcollation[0];
-	opexpr->args = list_make2(keyCol, arr);
-	opexpr->location = -1;
-
+	else
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = true;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	if (nulltest1)
 		result = list_make2(nulltest1, opexpr);
 	else if (nulltest2)
@@ -1775,9 +2025,18 @@ get_partition_for_tuple(PartitionDispatch *pd,
 		 */
 		if (cur_index < 0)
 		{
-			result = -1;
-			*failed_at = parent;
-			*failed_slot = slot;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_default)
+				result = parent->indexes[partdesc->boundinfo->default_index];
+			else
+			{
+				result = -1;
+				*failed_at = parent;
+				*failed_slot = slot;
+			}
 			break;
 		}
 		else if (parent->indexes[cur_index] >= 0)
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 89d2836..e0b27cf 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -2677,6 +2677,7 @@ partbound_datum:
 			Sconst			{ $$ = makeStringConst($1, @1); }
 			| NumericOnly	{ $$ = makeAConst($1, @1); }
 			| NULL_P		{ $$ = makeNullAConst(@1); }
+			| DEFAULT  { $$ = (Node *)makeDefElem("DEFAULT", NULL, @1); }
 		;
 
 partbound_datum_list:
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index e546194..5e11873 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -33,6 +33,7 @@
 #include "catalog/heap.h"
 #include "catalog/index.h"
 #include "catalog/namespace.h"
+#include "catalog/partition.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_constraint.h"
@@ -3304,47 +3305,50 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!(isDefaultPartitionBound(value)))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
+
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
 
-				if (equal(value, value2))
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 184e5da..65d8821 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -24,6 +24,7 @@
 #include "access/sysattr.h"
 #include "catalog/dependency.h"
 #include "catalog/indexing.h"
+#include "catalog/partition.h"
 #include "catalog/pg_aggregate.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_authid.h"
@@ -8619,8 +8620,14 @@ get_rule_expr(Node *node, deparse_context *context,
 						sep = "";
 						foreach(cell, spec->listdatums)
 						{
+							Node *value = lfirst(cell);
 							Const	   *val = lfirst(cell);
 
+							if (isDefaultPartitionBound(value))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								continue;
+							}
 							appendStringInfoString(buf, sep);
 							get_const_expr(val, context, -1);
 							sep = ", ";
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 421644c..7cb4f0a 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -74,9 +74,12 @@ extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(PartitionKey key,
 					   PartitionBoundInfo p1, PartitionBoundInfo p2);
 
+extern bool isDefaultPartitionBound(Node *value);
 extern void check_new_partition_bound(char *relname, Relation parent, Node *bound);
 extern Oid	get_partition_parent(Oid relid);
 extern List *get_qual_from_partbound(Relation rel, Relation parent, Node *bound);
+extern List *generate_qual_for_defaultpart(Relation parent, Node *bound, Oid *defid);
+extern List *get_qual_for_default(Relation parent, Oid *defid);
 extern List *map_partition_varattnos(List *expr, int target_varno,
 						Relation partrel, Relation parent);
 extern List *RelationGetPartitionQual(Relation rel);

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index e0d2665..193c7fc 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -34,6 +34,7 @@
 #include "nodes/nodeFuncs.h"
 #include "nodes/parsenodes.h"
 #include "optimizer/clauses.h"
+#include "optimizer/prep.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
 #include "rewrite/rewriteManip.h"
@@ -90,6 +91,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_default;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	int			default_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -118,7 +123,8 @@ static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
 						   void *arg);
 
-static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec);
+static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec,
+								bool is_def, List *boundspecs);
 static List *get_qual_for_range(PartitionKey key, PartitionBoundSpec *spec);
 static Oid get_partition_operator(PartitionKey key, int col,
 					   StrategyNumber strategy, bool *need_relabel);
@@ -166,6 +172,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -249,9 +257,16 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
+					if (isDefaultPartitionBound(value))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
 					if (!val->constisnull)
 					{
 						list_value = (PartitionListValue *)
@@ -459,6 +474,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_default = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +512,8 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def && mapping[def_index] == -1)
+						mapping[def_index] = next_index++;
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +522,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->default_index = mapping[def_index];
+					else
+						boundinfo->default_index = -1;
 					break;
 				}
 
@@ -513,6 +536,7 @@ RelationBuildPartitionDesc(Relation rel)
 												sizeof(RangeDatumContent *));
 					boundinfo->indexes = (int *) palloc((ndatums + 1) *
 														sizeof(int));
+					boundinfo->has_default = found_def;
 
 					for (i = 0; i < ndatums; i++)
 					{
@@ -671,6 +695,7 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	PartitionDesc partdesc = RelationGetPartitionDesc(parent);
+	PartitionBoundInfo boundinfo;
 	ParseState *pstate = make_parsestate(NULL);
 	int			with = -1;
 	bool		overlap = false;
@@ -679,6 +704,8 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			{
+				boundinfo = partdesc->boundinfo;
+
 				Assert(spec->strategy == PARTITION_STRATEGY_LIST);
 
 				if (partdesc->nparts > 0)
@@ -688,13 +715,15 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 
 					Assert(boundinfo &&
 						   boundinfo->strategy == PARTITION_STRATEGY_LIST &&
-						   (boundinfo->ndatums > 0 || boundinfo->has_null));
+						   (boundinfo->ndatums > 0 || boundinfo->has_null
+							|| boundinfo->has_default));
 
 					foreach(cell, spec->listdatums)
 					{
-						Const	   *val = lfirst(cell);
+						Node	   *value = lfirst(cell);
+						Const	   *val = (Const *) value;
 
-						if (!val->constisnull)
+						if (!val->constisnull && !(isDefaultPartitionBound(value)))
 						{
 							int			offset;
 							bool		equal;
@@ -709,7 +738,14 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 								break;
 							}
 						}
-						else if (boundinfo->has_null)
+						else if (isDefaultPartitionBound(value) &&
+								 boundinfo->has_default)
+						{
+							overlap = true;
+							with = boundinfo->default_index;
+							break;
+						}
+						else if (val->constisnull && boundinfo->has_null)
 						{
 							overlap = true;
 							with = boundinfo->null_index;
@@ -836,6 +872,78 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						relname, get_rel_name(partdesc->oids[with])),
 				 parser_errposition(pstate, spec->location)));
 	}
+
+	/*
+	 * When adding a list partition after default partition, scan the
+	 * default partition for rows satisfying the new partition
+	 * constraint. If found don't allow addition of a new partition.
+	 * Otherwise continue with the creation of new  partition.
+	 */
+	if (spec->strategy == PARTITION_STRATEGY_LIST && partdesc->nparts > 0
+		&& boundinfo->has_default)
+	{
+		List	       *partConstraint = NIL;
+		ExprContext    *econtext;
+		EState	       *estate;
+		Relation	    defrel;
+		HeapScanDesc    scan;
+		HeapTuple	    tuple;
+		ExprState	   *partqualstate = NULL;
+		Snapshot	    snapshot;
+		Oid			    defid;
+		MemoryContext   oldCxt;
+		TupleTableSlot *tupslot;
+		TupleDesc	    tupdesc;
+
+
+		partConstraint = generate_qual_for_defaultpart(parent, bound, &defid);
+		partConstraint = (List *) eval_const_expressions(NULL,
+													(Node *) partConstraint);
+		partConstraint = (List *) canonicalize_qual((Expr *) partConstraint);
+		partConstraint = list_make1(make_ands_explicit(partConstraint));
+
+		/*
+		 * Generate the constraint and default execution states
+		 */
+		estate = CreateExecutorState();
+
+		defrel = heap_open(defid, AccessExclusiveLock);
+		tupdesc = CreateTupleDescCopy(RelationGetDescr(defrel));
+
+		/* Build expression execution states for partition check quals */
+		partqualstate = ExecPrepareCheck(partConstraint,
+						estate);
+
+		econtext = GetPerTupleExprContext(estate);
+		snapshot = RegisterSnapshot(GetLatestSnapshot());
+		scan = heap_beginscan(defrel, snapshot, 0, NULL);
+		tupslot = MakeSingleTupleTableSlot(tupdesc);
+
+		/*
+		 * Switch to per-tuple memory context and reset it for each tuple
+		 * produced, so we don't leak memory.
+		 */
+		oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
+
+		while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
+		{
+			ExecStoreTuple(tuple, tupslot, InvalidBuffer, false);
+			econtext->ecxt_scantuple = tupslot;
+			if (partqualstate && !ExecCheck(partqualstate, econtext))
+				ereport(ERROR,
+						(errcode(ERRCODE_CHECK_VIOLATION),
+				errmsg("new default partition constraint is violated by some row")));
+			ResetExprContext(econtext);
+			CHECK_FOR_INTERRUPTS();
+		}
+		CacheInvalidateRelcache(defrel);
+		MemoryContextSwitchTo(oldCxt);
+		heap_endscan(scan);
+		UnregisterSnapshot(snapshot);
+		ExecDropSingleTupleTableSlot(tupslot);
+		FreeExecutorState(estate);
+		heap_close(defrel, AccessExclusiveLock);
+	}
 }
 
 /*
@@ -884,6 +992,116 @@ get_partition_parent(Oid relid)
 }
 
 /*
+ * Returns true if the partition bound is default
+ */
+bool
+isDefaultPartitionBound(Node *value)
+{
+	if (IsA(value, DefElem))
+	{
+		DefElem *defvalue = (DefElem *) value;
+		if(!strcmp(defvalue->defname, "DEFAULT"))
+			return true;
+		return false;
+	}
+	return false;
+}
+
+/*
+ * Return the bound spec list to be used
+ * in partition constraint of default partition
+ */
+List *
+get_qual_for_default(Relation parent, Oid *defid)
+{
+	List	   *inhoids;
+	ListCell   *cell;
+	List	   *boundspecs = NIL;
+
+	inhoids = find_inheritance_children(RelationGetRelid(parent), AccessExclusiveLock);
+	foreach(cell, inhoids)
+	{
+		Oid			inhrelid = lfirst_oid(cell);
+		HeapTuple	tuple;
+		Datum		datum;
+		bool		isnull;
+		bool		def_elem = false;
+		PartitionBoundSpec *bspec;
+		ListCell *cell1;
+
+		tuple = SearchSysCache1(RELOID, inhrelid);
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+		/*
+		 * It is possible that the pg_class tuple of a partition has not been
+		 * updated yet to set its relpartbound field.  The only case where
+		 * this happens is when we open the parent relation to check using its
+		 * partition descriptor that a new partition's bound does not overlap
+		 * some existing partition.
+		 */
+		if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+
+		datum = SysCacheGetAttr(RELOID, tuple,
+								Anum_pg_class_relpartbound,
+								&isnull);
+		Assert(!isnull);
+		bspec = (PartitionBoundSpec *) stringToNode(TextDatumGetCString(datum));
+		foreach(cell1, bspec->listdatums)
+		{
+			Node *value = lfirst(cell1);
+			if (isDefaultPartitionBound(value))
+			{
+				def_elem = true;
+				*defid  = inhrelid;
+			}
+		}
+		if (!def_elem)
+		{
+			foreach(cell1, bspec->listdatums)
+			{
+				Node *value = lfirst(cell1);
+				boundspecs = lappend(boundspecs, value);
+			}
+		}
+		ReleaseSysCache(tuple);
+	}
+	return boundspecs;
+}
+
+/*
+ * Return a list of executable expressions as new partition constraint
+ * for default partition while adding a new partition after default
+ */
+List *
+generate_qual_for_defaultpart(Relation parent, Node *bound, Oid * defid)
+{
+	PartitionKey key = RelationGetPartitionKey(parent);
+	PartitionBoundSpec *spec;
+	List	   *partConstraint = NIL;
+	ListCell   *cell;
+	List       *boundspecs = NIL;
+	List       *bound_datums;
+
+	spec = (PartitionBoundSpec *) bound;
+	bound_datums = list_copy(spec->listdatums);
+
+	boundspecs = get_qual_for_default(parent, defid);
+
+	foreach(cell, bound_datums)
+	{
+		Node *value = lfirst(cell);
+		boundspecs = lappend(boundspecs, value);
+	}
+	partConstraint = get_qual_for_list(key, spec, true, boundspecs);
+	return partConstraint;
+}
+
+/*
  * get_qual_from_partbound
  *		Given a parser node for partition bound, return the list of executable
  *		expressions as partition constraint
@@ -894,6 +1112,10 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
+	bool		is_def = false;
+	Oid        defid;
+	ListCell   *cell;
+	List	   *boundspecs = NIL;
 
 	Assert(key != NULL);
 
@@ -901,9 +1123,16 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			Assert(spec->strategy == PARTITION_STRATEGY_LIST);
-			my_qual = get_qual_for_list(key, spec);
+			foreach(cell, spec->listdatums)
+			{
+				Node *value = lfirst(cell);
+				if (isDefaultPartitionBound(value))
+					is_def = true;
+			}
+			if (is_def)
+				boundspecs = get_qual_for_default(parent, &defid);
+			my_qual = get_qual_for_list(key, spec, is_def, boundspecs);
 			break;
-
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
 			my_qual = get_qual_for_range(key, spec);
@@ -1151,7 +1380,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
  * Returns a list of expressions to use as a list partition's constraint.
  */
 static List *
-get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
+get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec, bool is_def,
+					List *boundspecs)
 {
 	List	   *result;
 	ArrayExpr  *arr;
@@ -1177,12 +1407,14 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 	else
 		keyCol = (Expr *) copyObject(linitial(key->partexprs));
 
+	if (!is_def)
+		boundspecs = spec->listdatums;
 	/*
 	 * We must remove any NULL value in the list; we handle it separately
 	 * below.
 	 */
 	prev = NULL;
-	for (cell = list_head(spec->listdatums); cell; cell = next)
+	for (cell = list_head(boundspecs); cell; cell = next)
 	{
 		Const	   *val = (Const *) lfirst(cell);
 
@@ -1191,14 +1423,14 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		if (val->constisnull)
 		{
 			list_has_null = true;
-			spec->listdatums = list_delete_cell(spec->listdatums,
+			boundspecs = list_delete_cell(boundspecs,
 												cell, prev);
 		}
 		else
 			prev = cell;
 	}
 
-	if (!list_has_null)
+	if ((is_def && list_has_null) || (!is_def && !list_has_null))
 	{
 		/*
 		 * Gin up a col IS NOT NULL test that will be AND'd with other
@@ -1210,7 +1442,7 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		nulltest1->argisrow = false;
 		nulltest1->location = -1;
 	}
-	else
+	else if(!is_def && list_has_null)
 	{
 		/*
 		 * Gin up a col IS NULL test that will be OR'd with other expressions
@@ -1229,7 +1461,7 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		: key->parttypid[0];
 	arr->array_collid = key->parttypcoll[0];
 	arr->element_typeid = key->parttypid[0];
-	arr->elements = spec->listdatums;
+	arr->elements = boundspecs;
 	arr->multidims = false;
 	arr->location = -1;
 
@@ -1243,15 +1475,34 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 										  key->partcollation[0],
 										  COERCE_EXPLICIT_CAST);
 
+	/* Build leftop <> ALL(rightop). This is for default partition */
+	if (is_def)
+	{
+		/* Find the negator for the partition operator above */
+		if(get_negator(operoid) == InvalidOid)
+			ereport(ERROR, (errcode(ERRCODE_CHECK_VIOLATION),
+			errmsg("DEFAULT partition cannot be used without negator of operator  %s",
+						get_opname(operoid))));
+		operoid = get_negator(operoid);
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = false;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	/* Build leftop = ANY (rightop) */
-	opexpr = makeNode(ScalarArrayOpExpr);
-	opexpr->opno = operoid;
-	opexpr->opfuncid = get_opcode(operoid);
-	opexpr->useOr = true;
-	opexpr->inputcollid = key->partcollation[0];
-	opexpr->args = list_make2(keyCol, arr);
-	opexpr->location = -1;
-
+	else
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = true;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	if (nulltest1)
 		result = list_make2(nulltest1, opexpr);
 	else if (nulltest2)
@@ -1775,10 +2026,25 @@ get_partition_for_tuple(PartitionDispatch *pd,
 		 */
 		if (cur_index < 0)
 		{
-			result = -1;
-			*failed_at = parent;
-			*failed_slot = slot;
-			break;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_default)
+			{
+				result = parent->indexes[partdesc->boundinfo->default_index];
+				if (result >= 0)
+					break;
+				else
+					parent = pd[-parent->indexes[partdesc->boundinfo->default_index]];
+			}
+			else
+			{
+				result = -1;
+				*failed_at = parent;
+				*failed_slot = slot;
+				break;
+			}
 		}
 		else if (parent->indexes[cur_index] >= 0)
 		{
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 818d2c2..dffebc8 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -579,6 +579,8 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 %type <node>		ForValues
 %type <node>		partbound_datum
 %type <list>		partbound_datum_list
+%type <node>		default_partition
+%type <list>		default_part_list
 %type <partrange_datum>	PartitionRangeDatum
 %type <list>		range_datum_list
 
@@ -2669,6 +2671,17 @@ ForValues:
 
 					$$ = (Node *) n;
 				}
+			| default_part_list
+				{
+					PartitionBoundSpec *n = makeNode(PartitionBoundSpec);
+
+					n->strategy = PARTITION_DEFAULT;
+					n->listdatums = $1;
+					n->location = @1;
+
+					$$ = (Node *) n;
+				}
+
 		;
 
 partbound_datum:
@@ -2683,6 +2696,13 @@ partbound_datum_list:
 												{ $$ = lappend($1, $3); }
 		;
 
+default_partition:
+			DEFAULT  { $$ = (Node *)makeDefElem("DEFAULT", NULL, @1); }
+
+default_part_list:
+			default_partition						{ $$ = list_make1($1); }
+		;
+
 range_datum_list:
 			PartitionRangeDatum					{ $$ = list_make1($1); }
 			| range_datum_list ',' PartitionRangeDatum
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index e187409..13295a3 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -33,6 +33,7 @@
 #include "catalog/heap.h"
 #include "catalog/index.h"
 #include "catalog/namespace.h"
+#include "catalog/partition.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_constraint.h"
@@ -3298,55 +3299,67 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 										 false, false);
 
 		if (spec->strategy != PARTITION_STRATEGY_LIST)
-			ereport(ERROR,
-					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
-				  errmsg("invalid bound specification for a list partition"),
+		{
+			/*
+			 * If the partition is the default partition switch
+			 * back to PARTITION_STRATEGY_LIST
+			 */
+			if (spec->strategy == PARTITION_DEFAULT)
+				result_spec->strategy = PARTITION_STRATEGY_LIST;
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+					 errmsg("invalid bound specification for a list partition"),
 					 parser_errposition(pstate, exprLocation(bound))));
+		}
 
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!(isDefaultPartitionBound(value)))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
 
-				if (equal(value, value2))
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
+
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index cbde1ff..2764acc 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -24,6 +24,7 @@
 #include "access/sysattr.h"
 #include "catalog/dependency.h"
 #include "catalog/indexing.h"
+#include "catalog/partition.h"
 #include "catalog/pg_aggregate.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_authid.h"
@@ -8627,8 +8628,14 @@ get_rule_expr(Node *node, deparse_context *context,
 						sep = "";
 						foreach(cell, spec->listdatums)
 						{
+							Node *value = lfirst(cell);
 							Const	   *val = lfirst(cell);
 
+							if (isDefaultPartitionBound(value))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								continue;
+							}
 							appendStringInfoString(buf, sep);
 							get_const_expr(val, context, -1);
 							sep = ", ";
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 421644c..7cb4f0a 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -74,9 +74,12 @@ extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(PartitionKey key,
 					   PartitionBoundInfo p1, PartitionBoundInfo p2);
 
+extern bool isDefaultPartitionBound(Node *value);
 extern void check_new_partition_bound(char *relname, Relation parent, Node *bound);
 extern Oid	get_partition_parent(Oid relid);
 extern List *get_qual_from_partbound(Relation rel, Relation parent, Node *bound);
+extern List *generate_qual_for_defaultpart(Relation parent, Node *bound, Oid *defid);
+extern List *get_qual_for_default(Relation parent, Oid *defid);
 extern List *map_partition_varattnos(List *expr, int target_varno,
 						Relation partrel, Relation parent);
 extern List *RelationGetPartitionQual(Relation rel);
diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index e1d454a..5853c70 100644
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -780,6 +780,7 @@ typedef struct PartitionSpec
 
 #define PARTITION_STRATEGY_LIST		'l'
 #define PARTITION_STRATEGY_RANGE	'r'
+#define PARTITION_DEFAULT	'd'
 
 /*
  * PartitionBoundSpec - a partition bound specification

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index e0d2665..7d5a49b 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -34,6 +34,7 @@
 #include "nodes/nodeFuncs.h"
 #include "nodes/parsenodes.h"
 #include "optimizer/clauses.h"
+#include "optimizer/prep.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
 #include "rewrite/rewriteManip.h"
@@ -90,6 +91,10 @@ typedef struct PartitionBoundInfoData
 								 * for range partitioned tables */
 	int			null_index;		/* Index of the null-accepting partition; -1
 								 * for range partitioned tables */
+	bool		has_default;		/* Is there a default partition? Currently false
+								 * for a range partitioned table */
+	int			default_index;		/* Index of the default list partition. -1 for
+								 * range partitioned tables */
 } PartitionBoundInfoData;
 
 /*
@@ -118,7 +123,8 @@ static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
 static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
 						   void *arg);
 
-static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec);
+static List *get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec,
+								bool is_def, List *boundspecs);
 static List *get_qual_for_range(PartitionKey key, PartitionBoundSpec *spec);
 static Oid get_partition_operator(PartitionKey key, int col,
 					   StrategyNumber strategy, bool *need_relabel);
@@ -166,6 +172,8 @@ RelationBuildPartitionDesc(Relation rel)
 	/* List partitioning specific */
 	PartitionListValue **all_values = NULL;
 	bool		found_null = false;
+	bool		found_def = false;
+	int			def_index = -1;
 	int			null_index = -1;
 
 	/* Range partitioning specific */
@@ -249,9 +257,16 @@ RelationBuildPartitionDesc(Relation rel)
 
 				foreach(c, spec->listdatums)
 				{
+					Node *value = lfirst(c);
 					Const	   *val = lfirst(c);
 					PartitionListValue *list_value = NULL;
 
+					if (isDefaultPartitionBound(value))
+					{
+						found_def = true;
+						def_index = i;
+						continue;
+					}
 					if (!val->constisnull)
 					{
 						list_value = (PartitionListValue *)
@@ -459,6 +474,7 @@ RelationBuildPartitionDesc(Relation rel)
 			case PARTITION_STRATEGY_LIST:
 				{
 					boundinfo->has_null = found_null;
+					boundinfo->has_default = found_def;
 					boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
 
 					/*
@@ -496,6 +512,8 @@ RelationBuildPartitionDesc(Relation rel)
 						if (mapping[null_index] == -1)
 							mapping[null_index] = next_index++;
 					}
+					if (found_def && mapping[def_index] == -1)
+						mapping[def_index] = next_index++;
 
 					/* All partition must now have a valid mapping */
 					Assert(next_index == nparts);
@@ -504,6 +522,11 @@ RelationBuildPartitionDesc(Relation rel)
 						boundinfo->null_index = mapping[null_index];
 					else
 						boundinfo->null_index = -1;
+
+					if (found_def)
+						boundinfo->default_index = mapping[def_index];
+					else
+						boundinfo->default_index = -1;
 					break;
 				}
 
@@ -513,6 +536,7 @@ RelationBuildPartitionDesc(Relation rel)
 												sizeof(RangeDatumContent *));
 					boundinfo->indexes = (int *) palloc((ndatums + 1) *
 														sizeof(int));
+					boundinfo->has_default = found_def;
 
 					for (i = 0; i < ndatums; i++)
 					{
@@ -671,6 +695,7 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	PartitionDesc partdesc = RelationGetPartitionDesc(parent);
+	PartitionBoundInfo boundinfo;
 	ParseState *pstate = make_parsestate(NULL);
 	int			with = -1;
 	bool		overlap = false;
@@ -679,22 +704,25 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			{
+				boundinfo = partdesc->boundinfo;
+
 				Assert(spec->strategy == PARTITION_STRATEGY_LIST);
 
 				if (partdesc->nparts > 0)
 				{
-					PartitionBoundInfo boundinfo = partdesc->boundinfo;
 					ListCell   *cell;
 
 					Assert(boundinfo &&
 						   boundinfo->strategy == PARTITION_STRATEGY_LIST &&
-						   (boundinfo->ndatums > 0 || boundinfo->has_null));
+						   (boundinfo->ndatums > 0 || boundinfo->has_null
+							|| boundinfo->has_default));
 
 					foreach(cell, spec->listdatums)
 					{
-						Const	   *val = lfirst(cell);
+						Node	   *value = lfirst(cell);
+						Const	   *val = (Const *) value;
 
-						if (!val->constisnull)
+						if (!val->constisnull && !(isDefaultPartitionBound(value)))
 						{
 							int			offset;
 							bool		equal;
@@ -709,7 +737,14 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 								break;
 							}
 						}
-						else if (boundinfo->has_null)
+						else if (isDefaultPartitionBound(value) &&
+								 boundinfo->has_default)
+						{
+							overlap = true;
+							with = boundinfo->default_index;
+							break;
+						}
+						else if (val->constisnull && boundinfo->has_null)
 						{
 							overlap = true;
 							with = boundinfo->null_index;
@@ -836,6 +871,114 @@ check_new_partition_bound(char *relname, Relation parent, Node *bound)
 						relname, get_rel_name(partdesc->oids[with])),
 				 parser_errposition(pstate, spec->location)));
 	}
+
+	/*
+	 * When adding a list partition after default partition, scan the
+	 * default partition for rows satisfying the new partition
+	 * constraint. If found don't allow addition of a new partition.
+	 * Otherwise continue with the creation of new  partition.
+	 */
+	if (spec->strategy == PARTITION_STRATEGY_LIST && partdesc->nparts > 0
+		&& boundinfo->has_default)
+	{
+		List	       *partConstraint = NIL;
+		ExprContext    *econtext;
+		EState	       *estate;
+		Relation	    defrel;
+		HeapScanDesc    scan;
+		HeapTuple	    tuple;
+		ExprState	   *partqualstate = NULL;
+		Snapshot	    snapshot;
+		Oid			    defid;
+		MemoryContext   oldCxt;
+		TupleTableSlot *tupslot;
+		TupleDesc	    tupdesc;
+		List           *all_parts;
+		ListCell       *lc;
+
+
+		partConstraint = generate_qual_for_defaultpart(parent, bound, &defid);
+		partConstraint = (List *) eval_const_expressions(NULL,
+													(Node *) partConstraint);
+		partConstraint = (List *) canonicalize_qual((Expr *) partConstraint);
+		partConstraint = list_make1(make_ands_explicit(partConstraint));
+
+		/*
+		 * Generate the constraint and default execution states
+		 */
+		defrel = heap_open(defid, AccessExclusiveLock);
+
+		if (defrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+			all_parts = find_all_inheritors(RelationGetRelid(defrel),
+											AccessExclusiveLock, NULL);
+		else
+			all_parts = list_make1_oid(RelationGetRelid(defrel));
+
+		foreach(lc, all_parts)
+		{
+			Oid			part_relid = lfirst_oid(lc);
+			Relation	part_rel;
+			Expr	   *constr;
+			Expr	   *partition_constraint;
+
+			if (part_relid != RelationGetRelid(defrel))
+				part_rel = heap_open(part_relid, NoLock);
+			else
+				continue;
+
+			/*
+			 * Skip if it's a partitioned table.  Only RELKIND_RELATION
+			 * relations (ie, leaf partitions) need to be scanned.
+			 */
+			if (part_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+			{
+				heap_close(part_rel, NoLock);
+				continue;
+			}
+			tupdesc = CreateTupleDescCopy(RelationGetDescr(part_rel));
+			constr = linitial(partConstraint);
+			partition_constraint = (Expr *)
+				map_partition_varattnos((List *) constr, 1,
+										part_rel, parent);
+			estate = CreateExecutorState();
+
+			/* Build expression execution states for partition check quals */
+			partqualstate = ExecPrepareExpr(partition_constraint,
+							estate);
+
+			econtext = GetPerTupleExprContext(estate);
+			snapshot = RegisterSnapshot(GetLatestSnapshot());
+			scan = heap_beginscan(part_rel, snapshot, 0, NULL);
+			tupslot = MakeSingleTupleTableSlot(tupdesc);
+
+			/*
+			 * Switch to per-tuple memory context and reset it for each tuple
+			 * produced, so we don't leak memory.
+			 */
+			oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
+
+			while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
+			{
+				ExecStoreTuple(tuple, tupslot, InvalidBuffer, false);
+				econtext->ecxt_scantuple = tupslot;
+				if (partqualstate && !ExecCheck(partqualstate, econtext))
+					ereport(ERROR,
+							(errcode(ERRCODE_CHECK_VIOLATION),
+					errmsg("new default partition constraint is violated by some row")));
+				ResetExprContext(econtext);
+				CHECK_FOR_INTERRUPTS();
+			}
+			CacheInvalidateRelcache(part_rel);
+			MemoryContextSwitchTo(oldCxt);
+			heap_endscan(scan);
+			UnregisterSnapshot(snapshot);
+			ExecDropSingleTupleTableSlot(tupslot);
+			FreeExecutorState(estate);
+			heap_close(part_rel, NoLock);
+		}
+		CacheInvalidateRelcache(defrel);
+		heap_close(defrel, AccessExclusiveLock);
+	}
 }
 
 /*
@@ -884,6 +1027,117 @@ get_partition_parent(Oid relid)
 }
 
 /*
+ * Returns true if the partition bound is default
+ */
+bool
+isDefaultPartitionBound(Node *value)
+{
+	if (IsA(value, DefElem))
+	{
+		DefElem *defvalue = (DefElem *) value;
+		if(!strcmp(defvalue->defname, "DEFAULT"))
+			return true;
+		return false;
+	}
+	return false;
+}
+
+/*
+ * Return the bound spec list to be used
+ * in partition constraint of default partition
+ */
+List *
+get_qual_for_default(Relation parent, Oid *defid)
+{
+	List	   *inhoids;
+	ListCell   *cell;
+	List	   *boundspecs = NIL;
+
+	inhoids = find_inheritance_children(RelationGetRelid(parent), AccessExclusiveLock);
+	foreach(cell, inhoids)
+	{
+		Oid			inhrelid = lfirst_oid(cell);
+		HeapTuple	tuple;
+		Datum		datum;
+		bool		isnull;
+		bool		def_elem = false;
+		PartitionBoundSpec *bspec;
+		ListCell *cell1;
+
+		tuple = SearchSysCache1(RELOID, inhrelid);
+		if (!HeapTupleIsValid(tuple))
+			elog(ERROR, "cache lookup failed for relation %u", inhrelid);
+
+		/*
+		 * It is possible that the pg_class tuple of a partition has not been
+		 * updated yet to set its relpartbound field.  The only case where
+		 * this happens is when we open the parent relation to check using its
+		 * partition descriptor that a new partition's bound does not overlap
+		 * some existing partition.
+		 */
+		if (!((Form_pg_class) GETSTRUCT(tuple))->relispartition)
+		{
+			ReleaseSysCache(tuple);
+			continue;
+		}
+
+		datum = SysCacheGetAttr(RELOID, tuple,
+								Anum_pg_class_relpartbound,
+								&isnull);
+		Assert(!isnull);
+		bspec = (PartitionBoundSpec *) stringToNode(TextDatumGetCString(datum));
+		foreach(cell1, bspec->listdatums)
+		{
+			Node *value = lfirst(cell1);
+			if (isDefaultPartitionBound(value))
+			{
+				def_elem = true;
+				*defid  = inhrelid;
+				break;
+			}
+		}
+		if (!def_elem)
+		{
+			foreach(cell1, bspec->listdatums)
+			{
+				Node *value = lfirst(cell1);
+				boundspecs = lappend(boundspecs, value);
+			}
+		}
+		ReleaseSysCache(tuple);
+	}
+	return boundspecs;
+}
+
+/*
+ * Return a list of executable expressions as new partition constraint
+ * for default partition while adding a new partition after default
+ */
+List *
+generate_qual_for_defaultpart(Relation parent, Node *bound, Oid * defid)
+{
+	PartitionKey key = RelationGetPartitionKey(parent);
+	PartitionBoundSpec *spec;
+	List	   *partConstraint = NIL;
+	ListCell   *cell;
+	List       *boundspecs = NIL;
+	List       *bound_datums;
+
+	spec = (PartitionBoundSpec *) bound;
+	bound_datums = list_copy(spec->listdatums);
+
+	boundspecs = get_qual_for_default(parent, defid);
+
+	foreach(cell, bound_datums)
+	{
+		Node *value = lfirst(cell);
+		boundspecs = lappend(boundspecs, value);
+	}
+	partConstraint = get_qual_for_list(key, spec, true, boundspecs);
+	return partConstraint;
+}
+
+/*
  * get_qual_from_partbound
  *		Given a parser node for partition bound, return the list of executable
  *		expressions as partition constraint
@@ -894,6 +1148,10 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	PartitionBoundSpec *spec = (PartitionBoundSpec *) bound;
 	PartitionKey key = RelationGetPartitionKey(parent);
 	List	   *my_qual = NIL;
+	bool		is_def = false;
+	Oid        defid;
+	ListCell   *cell;
+	List	   *boundspecs = NIL;
 
 	Assert(key != NULL);
 
@@ -901,9 +1159,16 @@ get_qual_from_partbound(Relation rel, Relation parent, Node *bound)
 	{
 		case PARTITION_STRATEGY_LIST:
 			Assert(spec->strategy == PARTITION_STRATEGY_LIST);
-			my_qual = get_qual_for_list(key, spec);
+			foreach(cell, spec->listdatums)
+			{
+				Node *value = lfirst(cell);
+				if (isDefaultPartitionBound(value))
+					is_def = true;
+			}
+			if (is_def)
+				boundspecs = get_qual_for_default(parent, &defid);
+			my_qual = get_qual_for_list(key, spec, is_def, boundspecs);
 			break;
-
 		case PARTITION_STRATEGY_RANGE:
 			Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
 			my_qual = get_qual_for_range(key, spec);
@@ -1151,7 +1416,8 @@ RelationGetPartitionDispatchInfo(Relation rel, int lockmode,
  * Returns a list of expressions to use as a list partition's constraint.
  */
 static List *
-get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
+get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec, bool is_def,
+					List *boundspecs)
 {
 	List	   *result;
 	ArrayExpr  *arr;
@@ -1177,12 +1443,14 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 	else
 		keyCol = (Expr *) copyObject(linitial(key->partexprs));
 
+	if (!is_def)
+		boundspecs = spec->listdatums;
 	/*
 	 * We must remove any NULL value in the list; we handle it separately
 	 * below.
 	 */
 	prev = NULL;
-	for (cell = list_head(spec->listdatums); cell; cell = next)
+	for (cell = list_head(boundspecs); cell; cell = next)
 	{
 		Const	   *val = (Const *) lfirst(cell);
 
@@ -1191,14 +1459,14 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		if (val->constisnull)
 		{
 			list_has_null = true;
-			spec->listdatums = list_delete_cell(spec->listdatums,
+			boundspecs = list_delete_cell(boundspecs,
 												cell, prev);
 		}
 		else
 			prev = cell;
 	}
 
-	if (!list_has_null)
+	if ((is_def && list_has_null) || (!is_def && !list_has_null))
 	{
 		/*
 		 * Gin up a col IS NOT NULL test that will be AND'd with other
@@ -1210,7 +1478,7 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		nulltest1->argisrow = false;
 		nulltest1->location = -1;
 	}
-	else
+	else if(!is_def && list_has_null)
 	{
 		/*
 		 * Gin up a col IS NULL test that will be OR'd with other expressions
@@ -1229,7 +1497,7 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 		: key->parttypid[0];
 	arr->array_collid = key->parttypcoll[0];
 	arr->element_typeid = key->parttypid[0];
-	arr->elements = spec->listdatums;
+	arr->elements = boundspecs;
 	arr->multidims = false;
 	arr->location = -1;
 
@@ -1243,15 +1511,34 @@ get_qual_for_list(PartitionKey key, PartitionBoundSpec *spec)
 										  key->partcollation[0],
 										  COERCE_EXPLICIT_CAST);
 
+	/* Build leftop <> ALL(rightop). This is for default partition */
+	if (is_def)
+	{
+		/* Find the negator for the partition operator above */
+		if(get_negator(operoid) == InvalidOid)
+			ereport(ERROR, (errcode(ERRCODE_CHECK_VIOLATION),
+			errmsg("DEFAULT partition cannot be used without negator of operator  %s",
+						get_opname(operoid))));
+		operoid = get_negator(operoid);
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = false;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	/* Build leftop = ANY (rightop) */
-	opexpr = makeNode(ScalarArrayOpExpr);
-	opexpr->opno = operoid;
-	opexpr->opfuncid = get_opcode(operoid);
-	opexpr->useOr = true;
-	opexpr->inputcollid = key->partcollation[0];
-	opexpr->args = list_make2(keyCol, arr);
-	opexpr->location = -1;
-
+	else
+	{
+		opexpr = makeNode(ScalarArrayOpExpr);
+		opexpr->opno = operoid;
+		opexpr->opfuncid = get_opcode(operoid);
+		opexpr->useOr = true;
+		opexpr->inputcollid = key->partcollation[0];
+		opexpr->args = list_make2(keyCol, arr);
+		opexpr->location = -1;
+	}
 	if (nulltest1)
 		result = list_make2(nulltest1, opexpr);
 	else if (nulltest2)
@@ -1775,10 +2062,25 @@ get_partition_for_tuple(PartitionDispatch *pd,
 		 */
 		if (cur_index < 0)
 		{
-			result = -1;
-			*failed_at = parent;
-			*failed_slot = slot;
-			break;
+			/*
+			 * If partitioned table has a default partition, return
+			 * its sequence number
+			 */
+			if (partdesc->boundinfo->has_default)
+			{
+				result = parent->indexes[partdesc->boundinfo->default_index];
+				if (result >= 0)
+					break;
+				else
+					parent = pd[-parent->indexes[partdesc->boundinfo->default_index]];
+			}
+			else
+			{
+				result = -1;
+				*failed_at = parent;
+				*failed_slot = slot;
+				break;
+			}
 		}
 		else if (parent->indexes[cur_index] >= 0)
 		{
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 818d2c2..d471583 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -579,6 +579,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 %type <node>		ForValues
 %type <node>		partbound_datum
 %type <list>		partbound_datum_list
+%type <list>		default_partition
 %type <partrange_datum>	PartitionRangeDatum
 %type <list>		range_datum_list
 
@@ -2669,6 +2670,17 @@ ForValues:
 
 					$$ = (Node *) n;
 				}
+			| default_partition
+				{
+					PartitionBoundSpec *n = makeNode(PartitionBoundSpec);
+
+					n->strategy = PARTITION_DEFAULT;
+					n->listdatums = $1;
+					n->location = @1;
+
+					$$ = (Node *) n;
+				}
+
 		;
 
 partbound_datum:
@@ -2683,6 +2695,12 @@ partbound_datum_list:
 												{ $$ = lappend($1, $3); }
 		;
 
+default_partition:
+			DEFAULT	{
+						Node *def = (Node *)makeDefElem("DEFAULT", NULL, @1);
+						$$ = list_make1(def);
+					}
+
 range_datum_list:
 			PartitionRangeDatum					{ $$ = list_make1($1); }
 			| range_datum_list ',' PartitionRangeDatum
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index e187409..13295a3 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -33,6 +33,7 @@
 #include "catalog/heap.h"
 #include "catalog/index.h"
 #include "catalog/namespace.h"
+#include "catalog/partition.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_constraint.h"
@@ -3298,55 +3299,67 @@ transformPartitionBound(ParseState *pstate, Relation parent, Node *bound)
 										 false, false);
 
 		if (spec->strategy != PARTITION_STRATEGY_LIST)
-			ereport(ERROR,
-					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
-				  errmsg("invalid bound specification for a list partition"),
+		{
+			/*
+			 * If the partition is the default partition switch
+			 * back to PARTITION_STRATEGY_LIST
+			 */
+			if (spec->strategy == PARTITION_DEFAULT)
+				result_spec->strategy = PARTITION_STRATEGY_LIST;
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+					 errmsg("invalid bound specification for a list partition"),
 					 parser_errposition(pstate, exprLocation(bound))));
+		}
 
 		result_spec->listdatums = NIL;
 		foreach(cell, spec->listdatums)
 		{
-			A_Const    *con = (A_Const *) lfirst(cell);
-			Node	   *value;
-			ListCell   *cell2;
-			bool		duplicate;
-
-			value = (Node *) make_const(pstate, &con->val, con->location);
-			value = coerce_to_target_type(pstate,
-										  value, exprType(value),
-										  get_partition_col_typid(key, 0),
-										  get_partition_col_typmod(key, 0),
-										  COERCION_ASSIGNMENT,
-										  COERCE_IMPLICIT_CAST,
-										  -1);
-
-			if (value == NULL)
-				ereport(ERROR,
-						(errcode(ERRCODE_DATATYPE_MISMATCH),
-						 errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
-							 format_type_be(get_partition_col_typid(key, 0)),
-								colname),
-						 parser_errposition(pstate,
-											exprLocation((Node *) con))));
-
-			/* Simplify the expression */
-			value = (Node *) expression_planner((Expr *) value);
-
-			/* Don't add to the result if the value is a duplicate */
-			duplicate = false;
-			foreach(cell2, result_spec->listdatums)
+			Node *value = lfirst(cell);
+			/* Perform the transformation only for non default partition */
+			if (!(isDefaultPartitionBound(value)))
 			{
-				Const	   *value2 = (Const *) lfirst(cell2);
+				A_Const    *con = (A_Const *) lfirst(cell);
+				ListCell   *cell2;
+				bool		duplicate;
 
-				if (equal(value, value2))
+				value = (Node *) make_const(pstate, &con->val, con->location);
+				value = coerce_to_target_type(pstate,
+											value, exprType(value),
+											get_partition_col_typid(key, 0),
+											get_partition_col_typmod(key, 0),
+											COERCION_ASSIGNMENT,
+											COERCE_IMPLICIT_CAST,
+											-1);
+
+				if (value == NULL)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							errmsg("specified value cannot be cast to type \"%s\" of column \"%s\"",
+								format_type_be(get_partition_col_typid(key, 0)),
+									colname),
+							parser_errposition(pstate,
+												exprLocation((Node *) con))));
+
+				/* Simplify the expression */
+				value = (Node *) expression_planner((Expr *) value);
+
+				/* Don't add to the result if the value is a duplicate */
+				duplicate = false;
+				foreach(cell2, result_spec->listdatums)
 				{
-					duplicate = true;
-					break;
+					Const	   *value2 = (Const *) lfirst(cell2);
+
+					if (equal(value, value2))
+					{
+						duplicate = true;
+						break;
+					}
 				}
+				if (duplicate)
+					continue;
 			}
-			if (duplicate)
-				continue;
-
 			result_spec->listdatums = lappend(result_spec->listdatums,
 											  value);
 		}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index cbde1ff..c3c9e70 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -24,6 +24,7 @@
 #include "access/sysattr.h"
 #include "catalog/dependency.h"
 #include "catalog/indexing.h"
+#include "catalog/partition.h"
 #include "catalog/pg_aggregate.h"
 #include "catalog/pg_am.h"
 #include "catalog/pg_authid.h"
@@ -8616,25 +8617,39 @@ get_rule_expr(Node *node, deparse_context *context,
 				PartitionBoundSpec *spec = (PartitionBoundSpec *) node;
 				ListCell   *cell;
 				char	   *sep;
+				bool       is_def = false;
 
 				switch (spec->strategy)
 				{
 					case PARTITION_STRATEGY_LIST:
 						Assert(spec->listdatums != NIL);
-
-						appendStringInfoString(buf, "FOR VALUES");
-						appendStringInfoString(buf, " IN (");
-						sep = "";
 						foreach(cell, spec->listdatums)
 						{
-							Const	   *val = lfirst(cell);
+							Node *value = lfirst(cell);
 
-							appendStringInfoString(buf, sep);
-							get_const_expr(val, context, -1);
-							sep = ", ";
+							if (isDefaultPartitionBound(value))
+							{
+								appendStringInfoString(buf, "DEFAULT");
+								is_def = true;
+								break;
+							}
 						}
+						if(!is_def)
+						{
+							appendStringInfoString(buf, "FOR VALUES");
+							appendStringInfoString(buf, " IN (");
+							sep = "";
+							foreach(cell, spec->listdatums)
+							{
+								Const	   *val = lfirst(cell);
 
-						appendStringInfoString(buf, ")");
+								appendStringInfoString(buf, sep);
+								get_const_expr(val, context, -1);
+								sep = ", ";
+							}
+
+							appendStringInfoString(buf, ")");
+						}
 						break;
 
 					case PARTITION_STRATEGY_RANGE:
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index e2a3351..477d63c 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -2004,7 +2004,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, "");
 	/* Limited completion support for partition bound specification */
 	else if (TailMatches3("ATTACH", "PARTITION", MatchAny))
-		COMPLETE_WITH_CONST("FOR VALUES");
+		COMPLETE_WITH_LIST2("FOR VALUES", "DEFAULT");
 	else if (TailMatches2("FOR", "VALUES"))
 		COMPLETE_WITH_LIST2("FROM (", "IN (");
 	/*
@@ -2401,7 +2401,7 @@ psql_completion(const char *text, int start, int end)
 		COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_partitioned_tables, "");
 	/* Limited completion support for partition bound specification */
 	else if (TailMatches3("PARTITION", "OF", MatchAny))
-		COMPLETE_WITH_CONST("FOR VALUES");
+		COMPLETE_WITH_LIST2("FOR VALUES", "DEFAULT");
 
 /* CREATE TABLESPACE */
 	else if (Matches3("CREATE", "TABLESPACE", MatchAny))
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 421644c..7cb4f0a 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -74,9 +74,12 @@ extern void RelationBuildPartitionDesc(Relation relation);
 extern bool partition_bounds_equal(PartitionKey key,
 					   PartitionBoundInfo p1, PartitionBoundInfo p2);
 
+extern bool isDefaultPartitionBound(Node *value);
 extern void check_new_partition_bound(char *relname, Relation parent, Node *bound);
 extern Oid	get_partition_parent(Oid relid);
 extern List *get_qual_from_partbound(Relation rel, Relation parent, Node *bound);
+extern List *generate_qual_for_defaultpart(Relation parent, Node *bound, Oid *defid);
+extern List *get_qual_for_default(Relation parent, Oid *defid);
 extern List *map_partition_varattnos(List *expr, int target_varno,
 						Relation partrel, Relation parent);
 extern List *RelationGetPartitionQual(Relation rel);
diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index e1d454a..5853c70 100644
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -780,6 +780,7 @@ typedef struct PartitionSpec
 
 #define PARTITION_STRATEGY_LIST		'l'
 #define PARTITION_STRATEGY_RANGE	'r'
+#define PARTITION_DEFAULT	'd'
 
 /*
  * PartitionBoundSpec - a partition bound specification