diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c
index 69bf65d..326fa62 100644
--- a/src/backend/executor/execQual.c
+++ b/src/backend/executor/execQual.c
@@ -58,7 +58,6 @@
 #include "utils/typcache.h"
 #include "utils/xml.h"
 
-
 /* static function decls */
 static Datum ExecEvalArrayRef(ArrayRefExprState *astate,
 				 ExprContext *econtext,
@@ -149,6 +148,8 @@ static Datum ExecEvalMinMax(MinMaxExprState *minmaxExpr,
 			   bool *isNull, ExprDoneCond *isDone);
 static Datum ExecEvalXml(XmlExprState *xmlExpr, ExprContext *econtext,
 			bool *isNull, ExprDoneCond *isDone);
+static Datum ExecEvalXmlTable(XmlTableState *xmltable, ExprContext *econtext,
+			bool *isnull, ExprDoneCond *isDone);
 static Datum ExecEvalNullIf(FuncExprState *nullIfExpr,
 			   ExprContext *econtext,
 			   bool *isNull, ExprDoneCond *isDone);
@@ -2073,6 +2074,7 @@ ExecMakeTableFunctionResult(ExprState *funcexpr,
 	MemoryContext oldcontext;
 	bool		direct_function_call;
 	bool		first_time = true;
+	bool		xmltable_call;
 
 	callerContext = CurrentMemoryContext;
 
@@ -2118,6 +2120,7 @@ ExecMakeTableFunctionResult(ExprState *funcexpr,
 		 * This path is similar to ExecMakeFunctionResult.
 		 */
 		direct_function_call = true;
+		xmltable_call = false;
 
 		/*
 		 * Initialize function cache if first time through
@@ -2172,10 +2175,16 @@ ExecMakeTableFunctionResult(ExprState *funcexpr,
 			}
 		}
 	}
+	else if (funcexpr && IsA(funcexpr, XmlTableState))
+	{
+		direct_function_call = false;
+		xmltable_call = true;
+	}
 	else
 	{
 		/* Treat funcexpr as a generic expression */
 		direct_function_call = false;
+		xmltable_call = false;
 		InitFunctionCallInfoData(fcinfo, NULL, 0, InvalidOid, NULL, NULL);
 	}
 
@@ -2213,6 +2222,14 @@ ExecMakeTableFunctionResult(ExprState *funcexpr,
 			pgstat_end_function_usage(&fcusage,
 									  rsinfo.isDone != ExprMultipleResult);
 		}
+		else if (xmltable_call)
+		{
+			XmlTableState *xmltable = (XmlTableState *) funcexpr;
+
+			xmltable->rsinfo = &rsinfo;
+			result = ExecEvalExpr(funcexpr, econtext,
+								  &fcinfo.isnull, &rsinfo.isDone);
+		}
 		else
 		{
 			result = ExecEvalExpr(funcexpr, econtext,
@@ -3737,6 +3754,178 @@ ExecEvalXml(XmlExprState *xmlExpr, ExprContext *econtext,
 	return (Datum) 0;
 }
 
+static Datum
+ExecEvalXmlTable(XmlTableState *xmltable,
+				   ExprContext *econtext,
+				   bool *isNull, ExprDoneCond *isDone)
+{
+	Datum		*values;
+	bool		*nulls;
+	int			i;
+	int			ncols = xmltable->ncolumns;
+	ReturnSetInfo	*rsinfo = xmltable->rsinfo;
+	Tuplestorestate *tupstore;
+	MemoryContext	per_query_ctx;
+	MemoryContext	oldctx;
+	TupleDesc tupdesc = xmltable->rsinfo->expectedDesc;
+	Datum	value;
+	bool	isnull;
+	char **paths;
+	PgXmlTableContext	*xmltableCxt;
+	text		*xpath_expr_text;
+	xmltype		*data;
+	FmgrInfo	*in_functions;
+	Oid			*typioparams;
+
+	/* first execution, prepare in_function array */
+	if (xmltable->in_functions == NULL)
+	{
+		Oid			in_func_oid;
+		Form_pg_attribute *attr;
+
+		per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+		oldctx = MemoryContextSwitchTo(per_query_ctx);
+
+		attr = tupdesc->attrs;
+		Assert(tupdesc->natts == ncols);
+
+		in_functions = xmltable->in_functions = palloc(sizeof(FmgrInfo) * ncols);
+		typioparams = xmltable->typioparams = palloc(sizeof(Oid) * ncols);
+		for(i = 0; i < ncols; i++)
+		{
+			getTypeInputInfo(attr[i]->atttypid,
+								&in_func_oid, &typioparams[i]);
+			fmgr_info(in_func_oid, &in_functions[i]);
+		}
+
+		MemoryContextSwitchTo(oldctx);
+	}
+	else
+	{
+		in_functions = xmltable->in_functions;
+		typioparams = xmltable->typioparams;
+	}
+
+	paths = palloc(sizeof(char *) * ncols);
+	for (i = 0; i < ncols; i++)
+	{
+		char		*curr_path;
+		bool		use_prefix = false;
+		bool		use_suffix = true;
+		int		j;
+		char		*last_char_ptr;
+
+		if (xmltable->path_exprs[i] != NULL)
+		{
+			value = ExecEvalExpr(xmltable->path_exprs[i], econtext, &isnull, NULL);
+
+			if (isnull)
+				elog(ERROR, "expression of PATH of column %s is NULL",
+								  NameStr(tupdesc->attrs[i]->attname));
+			paths[i] = text_to_cstring(DatumGetTextP(value));
+		}
+		else
+			paths[i] = NameStr(tupdesc->attrs[i]->attname);
+
+		/* When doesn't start with any special cha, we should to append ref to parent node */
+		curr_path = paths[i];
+		if (curr_path[0] != '.' && curr_path[0] != '/')
+			use_prefix = true;
+
+		last_char_ptr = curr_path + strlen(curr_path) - 1;
+		if (*last_char_ptr == ')' || *last_char_ptr == '/')
+			use_suffix = false;
+
+		/* path shoud be reference to attribute */
+		if (use_suffix)
+		{
+			for (j = strlen(curr_path); j > 0; j--)
+			{
+				if (*last_char_ptr == '/')
+					break;
+				if (*last_char_ptr-- == '@')
+				{
+					use_suffix = false;
+					break;
+				}
+			}
+		}
+
+		if (use_prefix || use_suffix)
+		{
+			char *buffer = palloc(strlen(curr_path) + 1 + 2 + 7);
+
+			sprintf(buffer, "%s%s%s", use_prefix ? "./" : "", curr_path, use_suffix ? "/text()" : "");
+			paths[i] = buffer;
+		}
+	}
+
+	value = ExecEvalExpr(xmltable->query_string, econtext, &isnull, NULL);
+	if (isnull)
+		elog(ERROR, "query string should not be NULL");
+	xpath_expr_text = DatumGetTextP(value);
+
+	value = ExecEvalExpr(xmltable->expr, econtext, &isnull, NULL);
+	if (isnull)
+		elog(ERROR, "input value should not be NULL (ToDo: should be fixed in future)");
+	data = DatumGetXmlP(value);
+
+	values = palloc0(sizeof(Datum) * ncols);
+	nulls = palloc0(sizeof(bool) * ncols);
+
+	xmltableCxt = makeXmlTableCxt(xpath_expr_text, data, ncols, paths, in_functions, typioparams, tupdesc);
+
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldctx = MemoryContextSwitchTo(per_query_ctx);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+
+	for(;;)
+	{
+		MemoryContextSwitchTo(oldctx);
+
+		if (XmlTableGetRow(xmltableCxt))
+		{
+			bool		isnull;
+			Datum		value;
+			HeapTuple		tuple;
+
+			for (i = 0; i < ncols; i++)
+			{
+				value = XmlTableGetValue(xmltableCxt, i, &isnull);
+				if (isnull && xmltable->default_exprs[i] != NULL)
+					value = ExecEvalExpr(xmltable->default_exprs[i], econtext, &isnull, NULL);
+
+				if (isnull)
+					nulls[i] = true;
+				else
+				{
+					values[i] = value;
+					nulls[i] = false;
+				}
+			}
+			tuple = heap_form_tuple(tupdesc, values, nulls);
+
+			MemoryContextSwitchTo(per_query_ctx);
+			tuplestore_puttuple(tupstore, tuple);
+		}
+		else
+			break;
+	}
+
+	MemoryContextSwitchTo(per_query_ctx);
+	tuplestore_donestoring(tupstore);
+
+	XmlTableCxtFree(xmltableCxt);
+
+	*isDone = ExprSingleResult;
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = CreateTupleDescCopy(tupdesc);		/* this destroy passed tupdesc, use copy! */
+
+	return (Datum) 0;
+}
+
+
 /* ----------------------------------------------------------------
  *		ExecEvalNullIf
  *
@@ -5107,6 +5296,37 @@ ExecInitExpr(Expr *node, PlanState *parent)
 				state = (ExprState *) xstate;
 			}
 			break;
+		case T_XmlTable:
+			{
+				XmlTable *xt = (XmlTable *) node;
+				XmlTableState *xstate = makeNode(XmlTableState);
+				ListCell	   *l;
+				int				i = 0;
+				int				ncols;
+
+				xstate->xprstate.evalfunc = (ExprStateEvalFunc) ExecEvalXmlTable;
+				xstate->query_string = ExecInitExpr((Expr *) xt->query_string, parent);
+				xstate->expr = ExecInitExpr((Expr *) xt->expr, parent);
+
+				ncols = list_length(xt->coldeflist);
+				xstate->ncolumns = ncols;
+				xstate->path_exprs = palloc0(sizeof(ExprState *) * ncols);
+				xstate->default_exprs = palloc0(sizeof(ExprState *) * ncols);
+
+				foreach(l, xt->coldeflist)
+				{
+					ColumnDef *def = (ColumnDef *) lfirst(l);
+
+					if (def->cooked_path)
+						xstate->path_exprs[i] = ExecInitExpr((Expr *) def->cooked_path, parent);
+					if (def->cooked_default)
+						xstate->default_exprs[i] = ExecInitExpr((Expr *) def->cooked_default, parent);
+					i++;
+				}
+
+				state = (ExprState *) xstate;
+			}
+			break;
 		case T_NullTest:
 			{
 				NullTest   *ntest = (NullTest *) node;
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 3244c76..3f8baf8 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -2553,6 +2553,7 @@ _copyRangeTableSample(const RangeTableSample *from)
 	return newnode;
 }
 
+
 static TypeCast *
 _copyTypeCast(const TypeCast *from)
 {
@@ -2607,6 +2608,8 @@ _copyColumnDef(const ColumnDef *from)
 	COPY_SCALAR_FIELD(storage);
 	COPY_NODE_FIELD(raw_default);
 	COPY_NODE_FIELD(cooked_default);
+	COPY_NODE_FIELD(raw_path);
+	COPY_NODE_FIELD(cooked_path);
 	COPY_NODE_FIELD(collClause);
 	COPY_SCALAR_FIELD(collOid);
 	COPY_NODE_FIELD(constraints);
@@ -2688,6 +2691,19 @@ _copyXmlSerialize(const XmlSerialize *from)
 	return newnode;
 }
 
+static XmlTable *
+_copyXmlTable(const XmlTable *from)
+{
+	XmlTable *newnode = makeNode(XmlTable);
+
+	COPY_NODE_FIELD(query_string);
+	COPY_NODE_FIELD(expr);
+	COPY_NODE_FIELD(coldeflist);
+	COPY_LOCATION_FIELD(location);
+
+	return newnode;
+}
+
 static RoleSpec *
 _copyRoleSpec(const RoleSpec *from)
 {
@@ -5062,6 +5078,9 @@ copyObject(const void *from)
 		case T_XmlSerialize:
 			retval = _copyXmlSerialize(from);
 			break;
+		case T_XmlTable:
+			retval = _copyXmlTable(from);
+			break;
 		case T_RoleSpec:
 			retval = _copyRoleSpec(from);
 			break;
diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index 1eb6799..e6e61c3 100644
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -2339,6 +2339,7 @@ _equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b)
 	return true;
 }
 
+
 static bool
 _equalIndexElem(const IndexElem *a, const IndexElem *b)
 {
@@ -2365,6 +2366,8 @@ _equalColumnDef(const ColumnDef *a, const ColumnDef *b)
 	COMPARE_SCALAR_FIELD(storage);
 	COMPARE_NODE_FIELD(raw_default);
 	COMPARE_NODE_FIELD(cooked_default);
+	COMPARE_NODE_FIELD(raw_path);
+	COMPARE_NODE_FIELD(cooked_path);
 	COMPARE_NODE_FIELD(collClause);
 	COMPARE_SCALAR_FIELD(collOid);
 	COMPARE_NODE_FIELD(constraints);
@@ -2610,6 +2613,17 @@ _equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b)
 }
 
 static bool
+_equalXmlTable(const XmlTable *a, const XmlTable *b)
+{
+	COMPARE_NODE_FIELD(query_string);
+	COMPARE_NODE_FIELD(expr);
+	COMPARE_NODE_FIELD(coldeflist);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
+static bool
 _equalRoleSpec(const RoleSpec *a, const RoleSpec *b)
 {
 	COMPARE_SCALAR_FIELD(roletype);
@@ -3366,6 +3380,9 @@ equal(const void *a, const void *b)
 		case T_XmlSerialize:
 			retval = _equalXmlSerialize(a, b);
 			break;
+		case T_XmlTable:
+			retval = _equalXmlTable(a, b);
+			break;
 		case T_RoleSpec:
 			retval = _equalRoleSpec(a, b);
 			break;
diff --git a/src/backend/nodes/nodeFuncs.c b/src/backend/nodes/nodeFuncs.c
index cd39167..b728d6b 100644
--- a/src/backend/nodes/nodeFuncs.c
+++ b/src/backend/nodes/nodeFuncs.c
@@ -226,6 +226,12 @@ exprType(const Node *expr)
 			else
 				type = XMLOID;
 			break;
+		case T_XmlTable:
+			if (((const XmlTable *) expr)->coldeflist == NIL)
+				type = XMLOID;
+			else
+				type = RECORDOID;
+			break;
 		case T_NullTest:
 			type = BOOLOID;
 			break;
@@ -720,6 +726,8 @@ expression_returns_set_walker(Node *node, void *context)
 		return false;
 	if (IsA(node, XmlExpr))
 		return false;
+	if (IsA(node, XmlTable))
+		return true;
 
 	return expression_tree_walker(node, expression_returns_set_walker,
 								  context);
@@ -1096,6 +1104,9 @@ exprSetCollation(Node *expr, Oid collation)
 				   (collation == DEFAULT_COLLATION_OID) :
 				   (collation == InvalidOid));
 			break;
+		case T_XmlTable:
+			Assert(!OidIsValid(collation));		/* result is always XML */
+			break;
 		case T_NullTest:
 			Assert(!OidIsValid(collation));		/* result is always boolean */
 			break;
@@ -1512,6 +1523,9 @@ exprLocation(const Node *expr)
 			/* XMLSERIALIZE keyword should always be the first thing */
 			loc = ((const XmlSerialize *) expr)->location;
 			break;
+		case T_XmlTable:
+			loc = ((const XmlTable *) expr)->location;
+			break;
 		case T_GroupingSet:
 			loc = ((const GroupingSet *) expr)->location;
 			break;
@@ -2067,6 +2081,27 @@ expression_tree_walker(Node *node,
 					return true;
 			}
 			break;
+		case T_XmlTable:
+			{
+				XmlTable *xt = (XmlTable *) node;
+				ListCell	*l;
+
+				if (walker(xt->query_string, context))
+					return true;
+				if (walker(xt->expr, context))
+					return true;
+
+				foreach(l, xt->coldeflist)
+				{
+					ColumnDef	*def = (ColumnDef *) lfirst(l);
+
+					if (walker(def->cooked_default, context))
+						return true;
+					if (walker(def->cooked_path, context))
+						return true;
+				}
+			}
+			break;
 		case T_NullTest:
 			return walker(((NullTest *) node)->arg, context);
 		case T_BooleanTest:
@@ -2781,6 +2816,35 @@ expression_tree_mutator(Node *node,
 				return (Node *) newnode;
 			}
 			break;
+		case T_XmlTable:
+			{
+				XmlTable	*xt = (XmlTable *) node;
+				XmlTable	*newnode;
+				List	   *resultlist = NIL;
+				ListCell	*l;
+
+				FLATCOPY(newnode, xt, XmlTable);
+				MUTATE(newnode->query_string, xt->query_string, Node *);
+				MUTATE(newnode->expr, xt->expr, Node *);
+
+				resultlist = NIL;
+				foreach(l, xt->coldeflist)
+				{
+					ColumnDef *def = (ColumnDef *) lfirst(l);
+					ColumnDef *newdef;
+
+					FLATCOPY(newdef, def, ColumnDef);
+					MUTATE(newdef->cooked_default, def->cooked_default, Node *);
+					MUTATE(newdef->cooked_path, def->cooked_path, Node *);
+
+					resultlist = lappend(resultlist, newdef);
+				}
+
+				newnode->coldeflist = resultlist;
+
+				return (Node *) newnode;
+			}
+			break;
 		case T_NullTest:
 			{
 				NullTest   *ntest = (NullTest *) node;
@@ -3547,6 +3611,8 @@ raw_expression_tree_walker(Node *node,
 					return true;
 				if (walker(coldef->raw_default, context))
 					return true;
+				if (walker(coldef->raw_path, context))
+					return true;
 				if (walker(coldef->collClause, context))
 					return true;
 				/* for now, constraints are ignored */
@@ -3575,6 +3641,18 @@ raw_expression_tree_walker(Node *node,
 					return true;
 			}
 			break;
+		case T_XmlTable:
+			{
+				XmlTable *xt = (XmlTable *) node;
+
+				if (walker(xt->query_string, context))
+					return true;
+				if (walker(xt->expr, context))
+					return true;
+				if (walker(xt->coldeflist, context))
+					return true;
+			}
+			break;
 		case T_WithClause:
 			return walker(((WithClause *) node)->ctes, context);
 		case T_InferClause:
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index acaf4ea..d69bc16 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2562,6 +2562,17 @@ _outXmlSerialize(StringInfo str, const XmlSerialize *node)
 }
 
 static void
+_outXmlTable(StringInfo str, const XmlTable *node)
+{
+	WRITE_NODE_TYPE("XMLTABLE");
+
+	WRITE_NODE_FIELD(query_string);
+	WRITE_NODE_FIELD(expr);
+	WRITE_NODE_FIELD(coldeflist);
+	WRITE_LOCATION_FIELD(location);
+}
+
+static void
 _outColumnDef(StringInfo str, const ColumnDef *node)
 {
 	WRITE_NODE_TYPE("COLUMNDEF");
@@ -2575,6 +2586,8 @@ _outColumnDef(StringInfo str, const ColumnDef *node)
 	WRITE_CHAR_FIELD(storage);
 	WRITE_NODE_FIELD(raw_default);
 	WRITE_NODE_FIELD(cooked_default);
+	WRITE_NODE_FIELD(raw_path);
+	WRITE_NODE_FIELD(cooked_path);
 	WRITE_NODE_FIELD(collClause);
 	WRITE_OID_FIELD(collOid);
 	WRITE_NODE_FIELD(constraints);
@@ -3845,6 +3858,9 @@ outNode(StringInfo str, const void *obj)
 			case T_XmlSerialize:
 				_outXmlSerialize(str, obj);
 				break;
+			case T_XmlTable:
+				_outXmlTable(str, obj);
+				break;
 			case T_ForeignKeyCacheInfo:
 				_outForeignKeyCacheInfo(str, obj);
 				break;
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 0cae446..3ae4722 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -132,7 +132,7 @@ typedef struct ImportQual
 #define parser_yyerror(msg)  scanner_yyerror(msg, yyscanner)
 #define parser_errposition(pos)  scanner_errposition(pos, yyscanner)
 
-static void base_yyerror(YYLTYPE *yylloc, core_yyscan_t yyscanner,
+static void base_yyerror(YYLTYPE *yylloc,	 core_yyscan_t yyscanner,
 						 const char *msg);
 static Node *makeColumnRef(char *colname, List *indirection,
 						   int location, core_yyscan_t yyscanner);
@@ -227,6 +227,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 	struct ImportQual	*importqual;
 	InsertStmt			*istmt;
 	VariableSetStmt		*vsetstmt;
+	XmlTableColOpt		*xmltablecolopt;
 }
 
 %type <node>	stmt schema_stmt
@@ -372,6 +373,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 				create_generic_options alter_generic_options
 				relation_expr_list dostmt_opt_list
 				transform_element_list transform_type_list
+				XmltableColumnList
 
 %type <list>	group_by_list
 %type <node>	group_by_item empty_grouping_set rollup_clause cube_clause
@@ -540,6 +542,10 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 %type <str>		opt_existing_window_name
 %type <boolean> opt_if_not_exists
 
+%type <node>	xmltable_column
+%type <xmltablecolopt>	xmltable_column_option
+%type <list>			opt_xmltable_column_option_list xmltable_column_option_list
+
 /*
  * Non-keyword token types.  These are hard-wired into the "flex" lexer.
  * They must be listed first so that their numeric codes do not depend on
@@ -571,7 +577,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 
 	CACHE CALLED CASCADE CASCADED CASE CAST CATALOG_P CHAIN CHAR_P
 	CHARACTER CHARACTERISTICS CHECK CHECKPOINT CLASS CLOSE
-	CLUSTER COALESCE COLLATE COLLATION COLUMN COMMENT COMMENTS COMMIT
+	CLUSTER COALESCE COLLATE COLLATION COLUMN COLUMNS COMMENT COMMENTS COMMIT
 	COMMITTED CONCURRENTLY CONFIGURATION CONFLICT CONNECTION CONSTRAINT
 	CONSTRAINTS CONTENT_P CONTINUE_P CONVERSION_P COPY COST CREATE
 	CROSS CSV CUBE CURRENT_P
@@ -615,7 +621,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 	OBJECT_P OF OFF OFFSET OIDS ON ONLY OPERATOR OPTION OPTIONS OR
 	ORDER ORDINALITY OUT_P OUTER_P OVER OVERLAPS OVERLAY OWNED OWNER
 
-	PARALLEL PARSER PARTIAL PARTITION PASSING PASSWORD PLACING PLANS POLICY
+	PARALLEL PARSER PARTIAL PARTITION PASSING PATH PASSWORD PLACING PLANS POLICY
 	POSITION PRECEDING PRECISION PRESERVE PREPARE PREPARED PRIMARY
 	PRIOR PRIVILEGES PROCEDURAL PROCEDURE PROGRAM
 
@@ -645,7 +651,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query);
 	WHEN WHERE WHITESPACE_P WINDOW WITH WITHIN WITHOUT WORK WRAPPER WRITE
 
 	XML_P XMLATTRIBUTES XMLCONCAT XMLELEMENT XMLEXISTS XMLFOREST XMLPARSE
-	XMLPI XMLROOT XMLSERIALIZE
+	XMLPI XMLROOT XMLSERIALIZE XMLTABLE
 
 	YEAR_P YES_P
 
@@ -12617,6 +12623,24 @@ func_expr_common_subexpr:
 					n->location = @1;
 					$$ = (Node *)n;
 				}
+			| XMLTABLE '(' c_expr xmlexists_argument ')'
+				{
+					XmlTable *n = makeNode(XmlTable);
+					n->query_string = $3;
+					n->expr = $4;
+					n->coldeflist = NIL;
+					n->location = @1;
+					$$ = (Node *)n;
+				}
+			| XMLTABLE '(' c_expr xmlexists_argument COLUMNS XmltableColumnList ')'
+				{
+					XmlTable *n = makeNode(XmlTable);
+					n->query_string = $3;
+					n->expr = $4;
+					n->coldeflist = $6;
+					n->location = @1;
+					$$ = (Node *)n;
+				}
 		;
 
 /*
@@ -12692,6 +12716,66 @@ xmlexists_argument:
 				}
 		;
 
+xmltable_column_option:
+			DEFAULT c_expr
+				{
+					$$ = palloc(sizeof(XmlTableColOpt));
+
+					$$->typ = XMLTABLE_COLUMN_OPT_DEFAULT;
+					$$->expr = $2;
+				}
+			| PATH c_expr
+				{
+					$$ = palloc(sizeof(XmlTableColOpt));
+
+					$$->typ = XMLTABLE_COLUMN_OPT_PATH;
+					$$->expr = $2;
+				}
+		;
+
+xmltable_column_option_list:
+			xmltable_column_option									{ $$ = list_make1($1); }
+			| xmltable_column_option_list xmltable_column_option	{ $$ = lappend($1, $2); }
+		;
+
+opt_xmltable_column_option_list:
+			xmltable_column_option_list			{ $$ = $1; }
+			| /* EMPTY */						{ $$ = NULL; }
+		;
+
+xmltable_column:
+			ColId Typename opt_xmltable_column_option_list
+				{
+					ListCell	*l;
+					ColumnDef		*c = makeNode(ColumnDef);
+
+					c->colname = $1;
+					c->typeName = $2;
+					c->raw_default = NULL;
+					c->raw_path = NULL;
+					c->storage = 55;
+
+					foreach(l, $3)
+					{
+						XmlTableColOpt *opt = (XmlTableColOpt *) lfirst(l);
+
+						if (opt->typ == XMLTABLE_COLUMN_OPT_PATH)
+							c->raw_path = opt->expr;
+						else if (opt->typ == XMLTABLE_COLUMN_OPT_DEFAULT)
+							c->raw_default = opt->expr;
+						else
+							elog(ERROR, "unknown xmltable column option");
+					}
+
+					c->location = @1;
+					$$ = (Node *) c;
+				}
+		;
+
+XmltableColumnList:
+				xmltable_column								{ $$ = list_make1($1); }
+				| XmltableColumnList ',' xmltable_column	{ $$ = lappend($1, $3); }
+		;
 
 /*
  * Aggregate decoration clauses
@@ -13755,6 +13839,7 @@ unreserved_keyword:
 			| CLASS
 			| CLOSE
 			| CLUSTER
+			| COLUMNS
 			| COMMENT
 			| COMMENTS
 			| COMMIT
@@ -13888,6 +13973,7 @@ unreserved_keyword:
 			| PARTITION
 			| PASSING
 			| PASSWORD
+			| PATH
 			| PLANS
 			| POLICY
 			| PRECEDING
@@ -14057,6 +14143,7 @@ col_name_keyword:
 			| XMLPI
 			| XMLROOT
 			| XMLSERIALIZE
+			| XMLTABLE
 		;
 
 /* Type/function identifier --- keywords that can be type or function names.
diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c
index 751de4b..b409b93 100644
--- a/src/backend/parser/parse_clause.c
+++ b/src/backend/parser/parse_clause.c
@@ -113,7 +113,7 @@ transformFromClause(ParseState *pstate, List *frmList)
 
 	/*
 	 * The grammar will have produced a list of RangeVars, RangeSubselects,
-	 * RangeFunctions, and/or JoinExprs. Transform each one (possibly adding
+	 * RangeFunctions and/or JoinExprs. Transform each one (possibly adding
 	 * entries to the rtable), check for duplicate refnames, and then add it
 	 * to the joinlist and namespace.
 	 *
@@ -821,7 +821,6 @@ transformRangeTableSample(ParseState *pstate, RangeTableSample *rts)
 	return tablesample;
 }
 
-
 /*
  * transformFromClauseItem -
  *	  Transform a FROM-clause item, adding any required entries to the
diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index cead212..0d779cf 100644
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -99,6 +99,7 @@ static Node *transformAExprIn(ParseState *pstate, A_Expr *a);
 static Node *transformAExprBetween(ParseState *pstate, A_Expr *a);
 static Node *transformBoolExpr(ParseState *pstate, BoolExpr *a);
 static Node *transformFuncCall(ParseState *pstate, FuncCall *fn);
+static Node *transformXmlTable(ParseState *pstate, XmlTable *xt);
 static Node *transformMultiAssignRef(ParseState *pstate, MultiAssignRef *maref);
 static Node *transformCaseExpr(ParseState *pstate, CaseExpr *c);
 static Node *transformSubLink(ParseState *pstate, SubLink *sublink);
@@ -314,6 +315,10 @@ transformExprRecurse(ParseState *pstate, Node *expr)
 			result = transformXmlSerialize(pstate, (XmlSerialize *) expr);
 			break;
 
+		case T_XmlTable:
+			result = transformXmlTable(pstate, (XmlTable *) expr);
+			break;
+
 		case T_NullTest:
 			{
 				NullTest   *n = (NullTest *) expr;
@@ -1474,6 +1479,50 @@ transformFuncCall(ParseState *pstate, FuncCall *fn)
 }
 
 static Node *
+transformXmlTable(ParseState *pstate, XmlTable *xt)
+{
+	ListCell	*l;
+
+	XmlTable *newxt = makeNode(XmlTable);
+
+	newxt->query_string = coerce_to_specific_type(pstate,
+								transformExprRecurse(pstate, xt->query_string),
+										 TEXTOID,
+										 "XMLTABLE");
+	newxt->expr = coerce_to_specific_type(pstate,
+								transformExprRecurse(pstate, xt->expr),
+										 XMLOID,
+										 "XMLTABLE");
+
+	newxt->location = xt->location;
+
+	foreach(l, xt->coldeflist)
+	{
+		ColumnDef *def = (ColumnDef *) lfirst(l);
+
+		if (def->raw_default)
+		{
+			Oid		targetType = typenameTypeId(pstate, def->typeName);;
+
+			def->cooked_default = coerce_to_specific_type(pstate,
+										transformExprRecurse(pstate, def->raw_default),
+												 targetType,
+												 "XMLTYPE");
+		}
+
+		if (def->raw_path)
+			def->cooked_path = coerce_to_specific_type(pstate,
+									transformExprRecurse(pstate, def->raw_path),
+											 TEXTOID,
+											 "XMLTABLE");
+	}
+
+	newxt->coldeflist = xt->coldeflist;
+
+	return (Node *) newxt;
+}
+
+static Node *
 transformMultiAssignRef(ParseState *pstate, MultiAssignRef *maref)
 {
 	SubLink    *sublink;
diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c
index fc93063..a4de207 100644
--- a/src/backend/parser/parse_target.c
+++ b/src/backend/parser/parse_target.c
@@ -1794,6 +1794,9 @@ FigureColnameInternal(Node *node, char **name)
 		case T_XmlSerialize:
 			*name = "xmlserialize";
 			return 2;
+		case T_XmlTable:
+			*name = "xmltable";
+			return 2;
 		default:
 			break;
 	}
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index d68ca7a..e6dd75e 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -8022,6 +8022,38 @@ get_rule_expr(Node *node, deparse_context *context,
 			}
 			break;
 
+		case T_XmlTable:
+			{
+				XmlTable    *xt = (XmlTable *) node;
+
+				appendStringInfoString(buf, "XMLTABLE(");
+				get_rule_expr((Node *) xt->query_string, context, true);
+				appendStringInfoString(buf, " PASSING ");
+				get_rule_expr((Node *) xt->expr, context, true);
+
+				if (xt->coldeflist != NIL)
+				{
+					ListCell	*l;
+					bool isFirst = true;
+
+					appendStringInfoString(buf, " COLUMNS ");
+					foreach(l, xt->coldeflist)
+					{
+						ColumnDef *def = (ColumnDef *) lfirst(l);
+
+						if (!isFirst)
+							appendStringInfoString(buf, ", ");
+						else
+							isFirst = false;
+						appendStringInfo(buf, "%s", def->colname);
+					}
+					appendStringInfoChar(buf, ' ');
+				}
+
+				appendStringInfoChar(buf, ')');
+			}
+			break;
+
 		case T_NullTest:
 			{
 				NullTest   *ntest = (NullTest *) node;
diff --git a/src/backend/utils/adt/xml.c b/src/backend/utils/adt/xml.c
index 7ed5bcb..e5a7701 100644
--- a/src/backend/utils/adt/xml.c
+++ b/src/backend/utils/adt/xml.c
@@ -115,6 +115,27 @@ struct PgXmlErrorContext
 	xmlExternalEntityLoader saved_entityfunc;
 };
 
+struct PgXmlTableContext
+{
+	int			ncols;
+	char	  **paths;
+	TupleDesc			tupdesc;
+
+	PgXmlErrorContext  *xmlerrcxt;
+	xmlParserCtxtPtr ctxt;
+	xmlDocPtr doc;
+	xmlXPathContextPtr xpathctx;
+	xmlXPathCompExprPtr xpathcomp;
+	xmlXPathObjectPtr xpathobj;
+
+	volatile xmlXPathCompExprPtr *xpathscomp;
+
+	FmgrInfo		*in_functions;
+	Oid				*typioparams;
+
+	long int		rc;
+};
+
 static xmlParserInputPtr xmlPgEntityLoader(const char *URL, const char *ID,
 				  xmlParserCtxtPtr ctxt);
 static void xml_errorHandler(void *data, xmlErrorPtr error);
@@ -4073,3 +4094,356 @@ xml_is_well_formed_content(PG_FUNCTION_ARGS)
 	return 0;
 #endif   /* not USE_LIBXML */
 }
+
+/*
+ * Convert XML node to cstring (dump subtree in case of element,
+ * return value otherwise)
+ */
+static char *
+xml_xmlnodetostr(xmlNodePtr cur, PgXmlErrorContext *xmlerrcxt)
+{
+	char *result;
+
+	if (cur->type == XML_ELEMENT_NODE)
+	{
+		xmlBufferPtr buf;
+		xmlNodePtr	cur_copy;
+
+		buf = xmlBufferCreate();
+
+		/*
+		 * The result of xmlNodeDump() won't contain namespace definitions
+		 * from parent nodes, but xmlCopyNode() duplicates a node along with
+		 * its required namespace definitions.
+		 */
+		cur_copy = xmlCopyNode(cur, 1);
+
+		if (cur_copy == NULL)
+			xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
+						"could not copy node");
+
+		PG_TRY();
+		{
+			xmlNodeDump(buf, NULL, cur_copy, 0, 1);
+			result = pstrdup((const char*) xmlBufferContent(buf));
+		}
+		PG_CATCH();
+		{
+			xmlFreeNode(cur_copy);
+			xmlBufferFree(buf);
+			PG_RE_THROW();
+		}
+		PG_END_TRY();
+		xmlFreeNode(cur_copy);
+		xmlBufferFree(buf);
+	}
+	else
+	{
+		xmlChar    *str;
+
+		str = xmlXPathCastNodeToString(cur);
+		PG_TRY();
+		{
+			/* Here we rely on XML having the same representation as TEXT */
+			char	   *escaped = escape_xml((char *) str);
+
+			result = escaped;
+		}
+		PG_CATCH();
+		{
+			xmlFree(str);
+			PG_RE_THROW();
+		}
+		PG_END_TRY();
+		xmlFree(str);
+	}
+
+	return result;
+}
+
+/*
+ * Support for XMLTABLE function
+ */
+PgXmlTableContext *
+makeXmlTableCxt(text *xpath_expr_text, xmltype *data, int ncols, char **paths, FmgrInfo *in_functions, Oid *typioparams, TupleDesc tupdesc)
+{
+#ifdef USE_LIBXML
+	PgXmlTableContext *cxt = palloc(sizeof(struct PgXmlTableContext));
+	PgXmlErrorContext *xmlerrcxt;
+
+	volatile xmlParserCtxtPtr ctxt = NULL;
+	volatile xmlDocPtr doc = NULL;
+	volatile xmlXPathContextPtr xpathctx = NULL;
+	volatile xmlXPathCompExprPtr xpathcomp = NULL;
+	volatile xmlXPathObjectPtr xpathobj = NULL;
+	volatile xmlXPathCompExprPtr *xpathscomp = NULL;
+	volatile xmlXPathCompExprPtr _xpathcomp = NULL;
+	int32		len;
+	int32		xpath_len;
+	xmlChar	   *string;
+	xmlChar	   *xpath_expr;
+	int				i;
+
+	cxt->ncols = ncols;
+	cxt->paths = paths;
+	cxt->in_functions = in_functions;
+	cxt->typioparams = typioparams;
+	cxt->tupdesc = tupdesc;
+	cxt->rc = 0;
+
+	cxt->xmlerrcxt = xmlerrcxt = pg_xml_init(PG_XML_STRICTNESS_ALL);
+
+	len = VARSIZE(data) - VARHDRSZ;
+	xpath_len = VARSIZE(xpath_expr_text) - VARHDRSZ;
+	if (xpath_len == 0)
+		ereport(ERROR,
+					(errcode(ERRCODE_DATA_EXCEPTION),
+					 errmsg("empty XPath expression")));
+
+	string = (xmlChar *) palloc((len + 1) * sizeof(xmlChar));
+	memcpy(string, VARDATA(data), len);
+	string[len] = '\0';
+
+	xpath_expr = (xmlChar *) palloc((xpath_len + 1) * sizeof(xmlChar));
+	memcpy(xpath_expr, VARDATA(xpath_expr_text), xpath_len);
+	xpath_expr[xpath_len] = '\0';
+
+	cxt->xpathscomp = xpathscomp = palloc0(sizeof(xmlXPathCompExprPtr) * ncols);
+
+	PG_TRY();
+	{
+		xmlInitParser();
+
+		cxt->ctxt = ctxt = xmlNewParserCtxt();
+		if (ctxt == NULL || xmlerrcxt->err_occurred)
+			xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
+						"could not allocate parser context");
+		cxt->doc = doc = xmlCtxtReadMemory(ctxt, (char *) string, len, NULL, NULL, 0);
+		if (doc == NULL || xmlerrcxt->err_occurred)
+			xml_ereport(xmlerrcxt, ERROR, ERRCODE_INVALID_XML_DOCUMENT,
+						"could not parse XML document");
+		cxt->xpathctx = xpathctx = xmlXPathNewContext(doc);
+		if (xpathctx == NULL || xmlerrcxt->err_occurred)
+			xml_ereport(xmlerrcxt, ERROR, ERRCODE_OUT_OF_MEMORY,
+						"could not allocate XPath context");
+		xpathctx->node = xmlDocGetRootElement(doc);
+		if (xpathctx->node == NULL || xmlerrcxt->err_occurred)
+			xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
+						"could not find root XML element");
+
+		cxt->xpathcomp = xpathcomp = xmlXPathCompile(xpath_expr);
+		if (xpathcomp == NULL || xmlerrcxt->err_occurred)
+			xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
+						"invalid XPath expression");
+
+		cxt->xpathobj = xpathobj = xmlXPathCompiledEval(xpathcomp, xpathctx);
+		if (xpathobj == NULL || xmlerrcxt->err_occurred)
+			xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
+						"could not create XPath object");
+
+		for(i = 0; i < ncols; i++)
+		{
+			int32 l = strlen(paths[i]);
+			xmlChar *buffer = palloc((l + 1) * sizeof(xmlChar));
+			memcpy(buffer, paths[i], l);
+			buffer[l] = '\0';
+
+			_xpathcomp = xmlXPathCompile(buffer);
+			if (_xpathcomp == NULL || xmlerrcxt->err_occurred)
+				xml_ereport(xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
+						"invalid XPath expression");
+			cxt->xpathscomp[i] = _xpathcomp;
+		}
+	}
+	PG_CATCH();
+	{
+		if (xpathobj)
+			xmlXPathFreeObject(xpathobj);
+		if (xpathcomp)
+			xmlXPathFreeCompExpr(xpathcomp);
+		if (_xpathcomp)
+			xmlXPathFreeCompExpr(_xpathcomp);
+		if (xpathctx)
+			xmlXPathFreeContext(xpathctx);
+		if (doc)
+			xmlFreeDoc(doc);
+		if (ctxt)
+			xmlFreeParserCtxt(ctxt);
+
+		if (xpathscomp)
+		{
+			int		i;
+
+			for (i = 0; i < ncols; i++)
+			{
+				if (xpathscomp[i])
+					xmlXPathFreeCompExpr(xpathscomp[i]);
+			}
+			pfree((void *) xpathscomp);
+		}
+
+		pg_xml_done(xmlerrcxt, true);
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	return cxt;
+#else
+	NO_XML_SUPPORT();
+	return NULL;
+#endif   /* not USE_LIBXML */
+
+}
+
+void
+XmlTableCxtFree(PgXmlTableContext *cxt)
+{
+#ifdef USE_LIBXML
+
+	if (cxt->xpathobj)
+		xmlXPathFreeObject(cxt->xpathobj);
+	if (cxt->xpathcomp)
+		xmlXPathFreeCompExpr(cxt->xpathcomp);
+	if (cxt->xpathctx)
+		xmlXPathFreeContext(cxt->xpathctx);
+	if (cxt->doc)
+		xmlFreeDoc(cxt->doc);
+	if (cxt->ctxt)
+		xmlFreeParserCtxt(cxt->ctxt);
+
+	if (cxt->xpathscomp)
+	{
+		int		i;
+
+		for (i = 0; i < cxt->ncols; i++)
+		{
+			if (cxt->xpathscomp[i])
+				xmlXPathFreeCompExpr(cxt->xpathscomp[i]);
+		}
+		pfree((void *) cxt->xpathscomp);
+	}
+
+	pg_xml_done(cxt->xmlerrcxt, true);
+
+	pfree(cxt);
+#else
+	NO_XML_SUPPORT();
+	return;
+#endif   /* not USE_LIBXML */
+}
+
+bool
+XmlTableGetRow(PgXmlTableContext *cxt)
+{
+#ifdef USE_LIBXML
+	if (cxt->xpathobj->type == XPATH_NODESET)
+	{
+		if (cxt->xpathobj->nodesetval != NULL)
+		{
+			if (cxt->rc < cxt->xpathobj->nodesetval->nodeNr)
+			{
+				cxt->rc++;
+				return true;
+			}
+		}
+	}
+
+	return false;
+#else
+	NO_XML_SUPPORT();
+	return false;
+#endif   /* not USE_LIBXML */
+
+}
+
+Datum
+XmlTableGetValue(PgXmlTableContext *cxt, int colnum, bool *isnull)
+{
+#ifdef USE_LIBXML
+	volatile xmlXPathObjectPtr _xpathobj = NULL;
+
+	if (cxt->xpathobj->type == XPATH_NODESET &&
+		  cxt->xpathobj->nodesetval != NULL)
+	{
+		xmlNodePtr		cur;
+	
+		Assert(cxt->rc <= cxt->xpathobj->nodesetval->nodeNr);
+
+		cur = cxt->xpathobj->nodesetval->nodeTab[cxt->rc - 1];
+
+		if (cur->type == XML_ELEMENT_NODE)
+		{
+
+			PG_TRY();
+			{
+				xmlXPathSetContextNode(cur, cxt->xpathctx);
+				_xpathobj = xmlXPathCompiledEval(cxt->xpathscomp[colnum], cxt->xpathctx);
+				if (_xpathobj == NULL || cxt->xmlerrcxt->err_occurred)
+					xml_ereport(cxt->xmlerrcxt, ERROR, ERRCODE_INTERNAL_ERROR,
+							"could not create XPath object");
+
+				switch (_xpathobj->type)
+				{
+					case XPATH_NODESET:
+						{
+							if (_xpathobj->nodesetval != NULL)
+							{
+								int result = _xpathobj->nodesetval->nodeNr;
+
+								if (result == 0)
+									*isnull = true;
+								else if (result == 1)
+								{
+									char *cstr = xml_xmlnodetostr(_xpathobj->nodesetval->nodeTab[0],
+																 cxt->xmlerrcxt);
+									Datum value = InputFunctionCall(&cxt->in_functions[colnum],
+																    cstr,
+																    cxt->typioparams[colnum],
+																    cxt->tupdesc->attrs[colnum]->atttypmod);
+
+									*isnull = false;
+									return value;
+								}
+								else
+									elog(ERROR, "too much rows");
+							}
+							else
+								*isnull = false;
+						break;
+						}
+					case XPATH_STRING:
+						*isnull = false;
+						return PointerGetDatum(cstring_to_text((char *) _xpathobj->stringval));
+						break;
+					default:
+						elog(ERROR, "xpath expression result type %d is unsupported",
+							 _xpathobj->type);
+						return 0;			/* keep compiler quiet */
+				}
+
+				//xmlXPathFreeContext(_xpathctx);
+				xmlXPathFreeObject(_xpathobj);
+			}
+			PG_CATCH();
+			{
+				if (_xpathobj)
+					xmlXPathFreeObject(_xpathobj);
+
+				XmlTableCxtFree(cxt);
+
+				PG_RE_THROW();
+			}
+			PG_END_TRY();
+		}
+	}
+
+	*isnull = true;
+
+	return (Datum) 0;
+#else
+	NO_XML_SUPPORT();
+	return (Datum) 0;
+#endif   /* not USE_LIBXML */
+
+}
diff --git a/src/backend/utils/fmgr/funcapi.c b/src/backend/utils/fmgr/funcapi.c
index 5d179ae..7fc30c2 100644
--- a/src/backend/utils/fmgr/funcapi.c
+++ b/src/backend/utils/fmgr/funcapi.c
@@ -20,6 +20,7 @@
 #include "funcapi.h"
 #include "nodes/nodeFuncs.h"
 #include "parser/parse_coerce.h"
+#include "parser/parse_type.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
@@ -39,7 +40,9 @@ static bool resolve_polymorphic_tupdesc(TupleDesc tupdesc,
 							oidvector *declared_args,
 							Node *call_expr);
 static TypeFuncClass get_type_func_class(Oid typid);
-
+static TypeFuncClass xmltable_get_result_type(XmlTable *expr,
+						 Oid *resultTypeId,
+						 TupleDesc *resultTupleDesc);
 
 /*
  * init_MultiFuncCall
@@ -243,6 +246,10 @@ get_expr_result_type(Node *expr,
 										  NULL,
 										  resultTypeId,
 										  resultTupleDesc);
+	else if (expr && IsA(expr, XmlTable))
+		result = xmltable_get_result_type((XmlTable *) expr,
+										  resultTypeId,
+										  resultTupleDesc);
 	else
 	{
 		/* handle as a generic expression; no chance to resolve RECORD */
@@ -1398,3 +1405,36 @@ TypeGetTupleDesc(Oid typeoid, List *colaliases)
 
 	return tupdesc;
 }
+
+static TypeFuncClass 
+xmltable_get_result_type(XmlTable *xt,
+						 Oid *resultTypeId,
+						 TupleDesc *resultTupleDesc)
+{
+	ListCell	*l;
+	int			i = 1;
+	TupleDesc	tupdesc;
+
+	tupdesc = CreateTemplateTupleDesc(list_length(xt->coldeflist), false);
+
+	foreach(l, xt->coldeflist)
+	{
+		ColumnDef *def = (ColumnDef *) lfirst(l);
+
+		Oid		typId = typenameTypeId(NULL, def->typeName);
+
+		TupleDescInitEntry(tupdesc, i++, def->colname, typId, -1, 0);
+	}
+
+	if (resultTypeId)
+		*resultTypeId = RECORDOID;
+
+	if (tupdesc->tdtypeid == RECORDOID &&
+		tupdesc->tdtypmod < 0)
+		assign_record_type_typmod(tupdesc);
+	if (resultTupleDesc)
+		*resultTupleDesc = tupdesc;
+
+	return TYPEFUNC_COMPOSITE;
+}
+
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index e7fd7bd..63f0f7f 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -959,6 +959,23 @@ typedef struct XmlExprState
 } XmlExprState;
 
 /* ----------------
+ *		XmlTableState node
+ * ----------------
+ */
+typedef struct XmlTableState
+{
+	ExprState			xprstate;
+	ExprState		   *query_string;		/* ExprStates for query string */
+	ExprState		   *expr;				/* ExprStates for XML parameter */
+	int					ncolumns;			/* number of columns */
+	ExprState		  **path_exprs;			/* ExprStates for column PATH expressions  */
+	ExprState		  **default_exprs;		/* ExprStates for defaults */
+	ReturnSetInfo	   *rsinfo;				/* link to outer world */
+	FmgrInfo		   *in_functions;		/* array of input function for each column */
+	Oid				   *typioparams;		/* array of column types for in_function */
+} XmlTableState;
+
+/* ----------------
  *		NullTestState node
  * ----------------
  */
diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
index 6b850e4..d255c4a 100644
--- a/src/include/nodes/nodes.h
+++ b/src/include/nodes/nodes.h
@@ -212,6 +212,7 @@ typedef enum NodeTag
 	T_CoalesceExprState,
 	T_MinMaxExprState,
 	T_XmlExprState,
+	T_XmlTableState,
 	T_NullTestState,
 	T_CoerceToDomainState,
 	T_DomainConstraintState,
@@ -447,6 +448,7 @@ typedef enum NodeTag
 	T_LockingClause,
 	T_RowMarkClause,
 	T_XmlSerialize,
+	T_XmlTable,
 	T_WithClause,
 	T_InferClause,
 	T_OnConflictClause,
diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index 1481fff..c815eff 100644
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -565,6 +565,7 @@ typedef struct RangeTableSample
 	int			location;		/* method name location, or -1 if unknown */
 } RangeTableSample;
 
+
 /*
  * ColumnDef - column definition (used in various creates)
  *
@@ -595,6 +596,8 @@ typedef struct ColumnDef
 	char		storage;		/* attstorage setting, or 0 for default */
 	Node	   *raw_default;	/* default value (untransformed parse tree) */
 	Node	   *cooked_default; /* default value (transformed expr tree) */
+	Node	   *raw_path;		/* path value (untransformed parse tree) */
+	Node	   *cooked_path;	/* path value (transformed expr tree *) */
 	CollateClause *collClause;	/* untransformed COLLATE spec, if any */
 	Oid			collOid;		/* collation OID (InvalidOid if not set) */
 	List	   *constraints;	/* other constraints on column */
@@ -697,6 +700,30 @@ typedef struct XmlSerialize
 	int			location;		/* token location, or -1 if unknown */
 } XmlSerialize;
 
+/*
+ * XmlTable - implementation of Xmltable function
+ *
+ */
+typedef enum
+{
+	XMLTABLE_COLUMN_OPT_PATH,
+	XMLTABLE_COLUMN_OPT_DEFAULT
+} XmlTableColOptType;
+
+typedef struct
+{
+	XmlTableColOptType		typ;
+	Node					*expr;
+} XmlTableColOpt;
+
+typedef struct XmlTable
+{
+	NodeTag		type;
+	Node	   *query_string;	/* XPath query for row selection */
+	Node	   *expr;			/* XML content */
+	List	   *coldeflist;		/* definition of columns of produced table */
+	int			location;		/* method name location, or -1 if unknown */
+} XmlTable;
 
 /****************************************************************************
  *	Nodes for a Query tree
diff --git a/src/include/parser/kwlist.h b/src/include/parser/kwlist.h
index 17ffef5..0872675 100644
--- a/src/include/parser/kwlist.h
+++ b/src/include/parser/kwlist.h
@@ -81,6 +81,7 @@ PG_KEYWORD("coalesce", COALESCE, COL_NAME_KEYWORD)
 PG_KEYWORD("collate", COLLATE, RESERVED_KEYWORD)
 PG_KEYWORD("collation", COLLATION, TYPE_FUNC_NAME_KEYWORD)
 PG_KEYWORD("column", COLUMN, RESERVED_KEYWORD)
+PG_KEYWORD("columns", COLUMNS, UNRESERVED_KEYWORD)
 PG_KEYWORD("comment", COMMENT, UNRESERVED_KEYWORD)
 PG_KEYWORD("comments", COMMENTS, UNRESERVED_KEYWORD)
 PG_KEYWORD("commit", COMMIT, UNRESERVED_KEYWORD)
@@ -289,6 +290,7 @@ PG_KEYWORD("partial", PARTIAL, UNRESERVED_KEYWORD)
 PG_KEYWORD("partition", PARTITION, UNRESERVED_KEYWORD)
 PG_KEYWORD("passing", PASSING, UNRESERVED_KEYWORD)
 PG_KEYWORD("password", PASSWORD, UNRESERVED_KEYWORD)
+PG_KEYWORD("path", PATH, UNRESERVED_KEYWORD)
 PG_KEYWORD("placing", PLACING, RESERVED_KEYWORD)
 PG_KEYWORD("plans", PLANS, UNRESERVED_KEYWORD)
 PG_KEYWORD("policy", POLICY, UNRESERVED_KEYWORD)
@@ -442,6 +444,7 @@ PG_KEYWORD("xmlparse", XMLPARSE, COL_NAME_KEYWORD)
 PG_KEYWORD("xmlpi", XMLPI, COL_NAME_KEYWORD)
 PG_KEYWORD("xmlroot", XMLROOT, COL_NAME_KEYWORD)
 PG_KEYWORD("xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD)
+PG_KEYWORD("xmltable", XMLTABLE, COL_NAME_KEYWORD)
 PG_KEYWORD("year", YEAR_P, UNRESERVED_KEYWORD)
 PG_KEYWORD("yes", YES_P, UNRESERVED_KEYWORD)
 PG_KEYWORD("zone", ZONE, UNRESERVED_KEYWORD)
diff --git a/src/include/utils/xml.h b/src/include/utils/xml.h
index 2eab8a5..c42e8e7 100644
--- a/src/include/utils/xml.h
+++ b/src/include/utils/xml.h
@@ -45,6 +45,7 @@ typedef enum
 
 /* struct PgXmlErrorContext is private to xml.c */
 typedef struct PgXmlErrorContext PgXmlErrorContext;
+typedef struct PgXmlTableContext PgXmlTableContext;
 
 #define DatumGetXmlP(X)		((xmltype *) PG_DETOAST_DATUM(X))
 #define XmlPGetDatum(X)		PointerGetDatum(X)
@@ -109,4 +110,9 @@ extern int	xmlbinary;			/* XmlBinaryType, but int for guc enum */
 
 extern int	xmloption;			/* XmlOptionType, but int for guc enum */
 
+extern PgXmlTableContext *makeXmlTableCxt(text *xpath_expr_text, xmltype *data, int ncols, char **paths, FmgrInfo *in_functions, Oid *typioparams, TupleDesc tupdesc);
+extern void XmlTableCxtFree(PgXmlTableContext *cxt);
+extern bool XmlTableGetRow(PgXmlTableContext *cxt);
+extern Datum XmlTableGetValue(PgXmlTableContext *cxt, int colnum, bool *isnull);
+
 #endif   /* XML_H */
diff --git a/src/test/regress/expected/xml.out b/src/test/regress/expected/xml.out
index f21e119..6392659 100644
--- a/src/test/regress/expected/xml.out
+++ b/src/test/regress/expected/xml.out
@@ -948,3 +928,57 @@ SELECT XMLPARSE(DOCUMENT '<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4
  <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd"><chapter>&nbsp;</chapter>
 (1 row)
 
+CREATE TABLE xmldata(data xml);
+INSERT INTO xmldata VALUES('<ROWS>
+<ROW id="1">
+  <COUNTRY_ID>AU</COUNTRY_ID>
+  <COUNTRY_NAME>Australia</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID>
+</ROW>
+<ROW id="2">
+  <COUNTRY_ID>CN</COUNTRY_ID>
+  <COUNTRY_NAME>China</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID>
+</ROW>
+<ROW id="3">
+  <COUNTRY_ID>HK</COUNTRY_ID>
+  <COUNTRY_NAME>HongKong</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID>
+</ROW>
+<ROW id="4">
+  <COUNTRY_ID>IN</COUNTRY_ID>
+  <COUNTRY_NAME>India</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID>
+</ROW>
+<ROW id="5">
+  <COUNTRY_ID>JP</COUNTRY_ID>
+  <COUNTRY_NAME>Japan</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID><PREMIER_NAME>Sinzo Abe</PREMIER_NAME>
+</ROW>
+<ROW id="6">
+  <COUNTRY_ID>SG</COUNTRY_ID>
+  <COUNTRY_NAME>Singapore</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID><SIZE unit="km">791</SIZE>
+</ROW>
+</ROWS>');
+SELECT  xmltable.*
+   FROM (SELECT data FROM xmldata) x,
+        LATERAL xmltable('/ROWS/ROW'
+                         PASSING data
+                         COLUMNS id int PATH '@id',
+                                  country_name text PATH 'COUNTRY_NAME',
+                                  country_id text PATH 'COUNTRY_ID',
+                                  region_id int PATH 'REGION_ID',
+                                  size float PATH 'SIZE',
+                                  unit text PATH 'SIZE/@unit',
+                                  premier_name text PATH 'PREMIER_NAME' DEFAULT 'not specified');
+ id | country_name | country_id | region_id | size | unit | premier_name  
+----+--------------+------------+-----------+------+------+---------------
+  1 | Australia    | AU         |         3 |      |      | not specified
+  2 | China        | CN         |         3 |      |      | not specified
+  3 | HongKong     | HK         |         3 |      |      | not specified
+  4 | India        | IN         |         3 |      |      | not specified
+  5 | Japan        | JP         |         3 |      |      | Sinzo Abe
+  6 | Singapore    | SG         |         3 |  791 | km   | not specified
+(6 rows)
+
diff --git a/src/test/regress/sql/xml.sql b/src/test/regress/sql/xml.sql
index 08a0b30..00445a3 100644
--- a/src/test/regress/sql/xml.sql
+++ b/src/test/regress/sql/xml.sql
@@ -270,3 +270,50 @@ SELECT XMLPARSE(DOCUMENT '<!DOCTYPE foo [<!ENTITY c SYSTEM "/etc/passwd">]><foo>
 SELECT XMLPARSE(DOCUMENT '<!DOCTYPE foo [<!ENTITY c SYSTEM "/etc/no.such.file">]><foo>&c;</foo>');
 -- This might or might not load the requested DTD, but it mustn't throw error.
 SELECT XMLPARSE(DOCUMENT '<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd"><chapter>&nbsp;</chapter>');
+
+CREATE TABLE xmldata(data xml);
+INSERT INTO xmldata VALUES('<ROWS>
+<ROW id="1">
+  <COUNTRY_ID>AU</COUNTRY_ID>
+  <COUNTRY_NAME>Australia</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID>
+</ROW>
+<ROW id="2">
+  <COUNTRY_ID>CN</COUNTRY_ID>
+  <COUNTRY_NAME>China</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID>
+</ROW>
+<ROW id="3">
+  <COUNTRY_ID>HK</COUNTRY_ID>
+  <COUNTRY_NAME>HongKong</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID>
+</ROW>
+<ROW id="4">
+  <COUNTRY_ID>IN</COUNTRY_ID>
+  <COUNTRY_NAME>India</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID>
+</ROW>
+<ROW id="5">
+  <COUNTRY_ID>JP</COUNTRY_ID>
+  <COUNTRY_NAME>Japan</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID><PREMIER_NAME>Sinzo Abe</PREMIER_NAME>
+</ROW>
+<ROW id="6">
+  <COUNTRY_ID>SG</COUNTRY_ID>
+  <COUNTRY_NAME>Singapore</COUNTRY_NAME>
+  <REGION_ID>3</REGION_ID><SIZE unit="km">791</SIZE>
+</ROW>
+</ROWS>');
+
+SELECT  xmltable.*
+   FROM (SELECT data FROM xmldata) x,
+        LATERAL xmltable('/ROWS/ROW'
+                         PASSING data
+                         COLUMNS id int PATH '@id',
+                                  country_name text PATH 'COUNTRY_NAME',
+                                  country_id text PATH 'COUNTRY_ID',
+                                  region_id int PATH 'REGION_ID',
+                                  size float PATH 'SIZE',
+                                  unit text PATH 'SIZE/@unit',
+                                  premier_name text PATH 'PREMIER_NAME' DEFAULT 'not specified');
+
