postgres_fdw-2.patch

diff --git a/contrib/Makefile b/contrib/Makefile
index 2b31450..3eab73d 100644
--- a/contrib/Makefile
+++ b/contrib/Makefile
@@ -41,6 +41,7 @@ SUBDIRS = \
 		pgcrypto	\
 		pgrowlocks	\
 		pgstattuple	\
+		postgresql_fdw	\
 		seg		\
 		spi		\
 		tablefunc	\
diff --git a/contrib/README b/contrib/README
index 3c4e324..ccee6a4 100644
--- a/contrib/README
+++ b/contrib/README
@@ -159,6 +159,9 @@ pgstattuple -
 	space within a table
 	by Tatsuo Ishii <ishii@sraoss.co.jp>
 
+postgresql_fdw -
+	Foreign-data wrapper for external PostgreSQL servers
+
 seg -
 	Confidence-interval datatype (GiST indexing example)
 	by Gene Selkov, Jr. <selkovjr@mcs.anl.gov>
diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c
index 19b98fb..b1509dc 100644
--- a/contrib/dblink/dblink.c
+++ b/contrib/dblink/dblink.c
@@ -2309,6 +2309,9 @@ get_connect_string(const char *servername)
 		{
 			DefElem    *def = lfirst(cell);
 
+			if (!is_libpq_connection_option(def->defname))
+				continue;
+
 			appendStringInfo(buf, "%s='%s' ", def->defname,
 							 escape_param_str(strVal(def->arg)));
 		}
@@ -2317,6 +2320,9 @@ get_connect_string(const char *servername)
 		{
 			DefElem    *def = lfirst(cell);
 
+			if (!is_libpq_connection_option(def->defname))
+				continue;
+
 			appendStringInfo(buf, "%s='%s' ", def->defname,
 							 escape_param_str(strVal(def->arg)));
 		}
@@ -2326,6 +2332,9 @@ get_connect_string(const char *servername)
 
 			DefElem    *def = lfirst(cell);
 
+			if (!is_libpq_connection_option(def->defname))
+				continue;
+
 			appendStringInfo(buf, "%s='%s' ", def->defname,
 							 escape_param_str(strVal(def->arg)));
 		}
diff --git a/contrib/postgresql_fdw/.gitignore b/contrib/postgresql_fdw/.gitignore
new file mode 100644
index 0000000..4a8bf17
--- /dev/null
+++ b/contrib/postgresql_fdw/.gitignore
@@ -0,0 +1,3 @@
+/postgresql_fdw.sql
+# Generated subdirectories
+/results/
diff --git a/contrib/postgresql_fdw/Makefile b/contrib/postgresql_fdw/Makefile
new file mode 100644
index 0000000..b9cf9ec
--- /dev/null
+++ b/contrib/postgresql_fdw/Makefile
@@ -0,0 +1,22 @@
+# contrib/postgresql_fdw/Makefile
+
+MODULE_big = postgresql_fdw
+PG_CPPFLAGS = -I$(libpq_srcdir)
+OBJS	= postgresql_fdw.o
+SHLIB_LINK = $(libpq)
+
+DATA_built = postgresql_fdw.sql
+DATA = uninstall_postgresql_fdw.sql
+REGRESS = postgresql_fdw
+
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = contrib/postgresql_fdw
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/contrib/postgresql_fdw/expected/postgresql_fdw.out b/contrib/postgresql_fdw/expected/postgresql_fdw.out
new file mode 100644
index 0000000..bcc6a3c
--- /dev/null
+++ b/contrib/postgresql_fdw/expected/postgresql_fdw.out
@@ -0,0 +1,116 @@
+SET SEARCH_PATH = public;
+SET DATESTYLE = 'Postgres, MDY';
+-- =============================================================================
+-- Prepare section
+-- =============================================================================
+-- connect database for regression test
+\c contrib_regression
+-- install postgresql_fdw module
+SET client_min_messages = warning;
+\set ECHO none
+-- define fdw-related objects
+CREATE SERVER loopback1 FOREIGN DATA WRAPPER postgresql_fdw
+	OPTIONS (dbname 'contrib_regression');
+CREATE SERVER loopback2 FOREIGN DATA WRAPPER postgresql_fdw
+	OPTIONS (dbname 'contrib_regression');
+CREATE USER MAPPING FOR PUBLIC SERVER loopback1;
+CREATE USER MAPPING FOR PUBLIC SERVER loopback2 OPTIONS (user 'invalid');
+CREATE TABLE t1(
+	c1 integer,
+	c2 text,
+	c3 date
+);
+COPY t1 FROM stdin;
+CREATE TABLE t2(
+	c1 integer,
+	c2 text,
+	c3 date
+);
+COPY t2 FROM stdin;
+CREATE FOREIGN TABLE ft1 (
+	c1 integer OPTIONS (colname 'invalid'),
+	c2 text OPTIONS (colname 'C2'),
+	c3 date
+) SERVER loopback1 OPTIONS (relname 't1');
+ALTER FOREIGN TABLE ft1 ALTER COLUMN c1 OPTIONS (SET colname 'C1');
+ALTER FOREIGN TABLE ft1 ALTER COLUMN c2 OPTIONS (DROP colname);
+CREATE FOREIGN TABLE ft2 (
+	c1 integer,
+	c2 text,
+	c3 date
+) SERVER loopback2 OPTIONS (relname 'invalid');
+-- simple query and connection caching
+SELECT ft1.* FROM ft1 ORDER BY c1;
+ c1 | c2  |     c3     
+----+-----+------------
+  1 | foo | 01-01-1970
+  2 | bar | 01-02-1970
+  3 | buz | 01-03-1970
+(3 rows)
+
+SELECT * FROM ft2 ORDER BY c1; -- ERROR
+ERROR:  could not connect to server "loopback2"
+DETAIL:  FATAL:  role "invalid" does not exist
+
+ALTER USER MAPPING FOR PUBLIC SERVER loopback2 OPTIONS (DROP user);
+SELECT * FROM ft2 ORDER BY c1; -- ERROR
+ERROR:  could not execute foreign query
+DETAIL:  ERROR:  relation "public.invalid" does not exist
+LINE 1: SELECT c1, c2, c3 FROM public.invalid ft2
+                               ^
+
+HINT:  SELECT c1, c2, c3 FROM public.invalid ft2
+ALTER FOREIGN TABLE ft2 OPTIONS (SET relname 't2');
+SELECT * FROM ft2 ORDER BY c1;
+ c1 | c2  |     c3     
+----+-----+------------
+  1 | foo | 01-01-1970
+ 12 | bar | 01-02-1970
+ 13 | buz | 01-03-1970
+(3 rows)
+
+-- join two foreign tables
+SELECT * FROM ft1 JOIN ft2 ON (ft1.c1 = ft2.c1) ORDER BY ft1.c1;
+ c1 | c2  |     c3     | c1 | c2  |     c3     
+----+-----+------------+----+-----+------------
+  1 | foo | 01-01-1970 |  1 | foo | 01-01-1970
+(1 row)
+
+-- join itself
+SELECT * FROM ft1 t1 JOIN ft1 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1;
+ c1 | c2  |     c3     | c1 | c2  |     c3     
+----+-----+------------+----+-----+------------
+  1 | foo | 01-01-1970 |  1 | foo | 01-01-1970
+  2 | bar | 01-02-1970 |  2 | bar | 01-02-1970
+  3 | buz | 01-03-1970 |  3 | buz | 01-03-1970
+(3 rows)
+
+-- outer join
+SELECT * FROM ft1 t1 LEFT JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY 1,2,3,4,5,6;
+ c1 | c2  |     c3     | c1 | c2  |     c3     
+----+-----+------------+----+-----+------------
+  1 | foo | 01-01-1970 |  1 | foo | 01-01-1970
+  2 | bar | 01-02-1970 |    |     | 
+  3 | buz | 01-03-1970 |    |     | 
+(3 rows)
+
+-- WHERE clause push-down
+set client_min_messages = debug1;
+SELECT * FROM ft1 WHERE c1 = 1 AND c2 = lower('FOO') AND c3 < now();
+DEBUG:  deparsed SQL is "SELECT C1, c2, c3 FROM public.t1 ft1 WHERE ((c1 = 1) AND (c2 = 'foo'::text))"
+ c1 | c2  |     c3     
+----+-----+------------
+  1 | foo | 01-01-1970
+(1 row)
+
+reset client_min_messages;
+-- clean up
+DROP FOREIGN DATA WRAPPER postgresql_fdw CASCADE;
+NOTICE:  drop cascades to 6 other objects
+DETAIL:  drop cascades to server loopback1
+drop cascades to user mapping for public
+drop cascades to foreign table ft1
+drop cascades to server loopback2
+drop cascades to user mapping for public
+drop cascades to foreign table ft2
+DROP TABLE t1 CASCADE;
diff --git a/contrib/postgresql_fdw/postgresql_fdw.c b/contrib/postgresql_fdw/postgresql_fdw.c
new file mode 100644
index 0000000..4522d31
--- /dev/null
+++ b/contrib/postgresql_fdw/postgresql_fdw.c
@@ -0,0 +1,972 @@
+/*-------------------------------------------------------------------------
+ *
+ * postgresql_fdw.c
+ *		  foreign-data wrapper for PostgreSQL
+ *
+ * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *		  contrib/postgresql_fdw/postgresql_fdw.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "catalog/pg_namespace.h"
+#include "catalog/pg_operator.h"
+#include "catalog/pg_proc.h"
+#include "foreign/foreign.h"
+#include "funcapi.h"
+#include "libpq-fe.h"
+#include "mb/pg_wchar.h"
+#include "miscadmin.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "nodes/relation.h"
+#include "optimizer/clauses.h"
+#include "optimizer/cost.h"
+#include "parser/parsetree.h"
+#include "parser/scansup.h"
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+#include "utils/memutils.h"
+#include "utils/resowner.h"
+#include "utils/syscache.h"
+
+#include "postgresql_fdw.h"
+
+PG_MODULE_MAGIC;
+
+
+/*
+ * PostgreSQL specific portion of a foreign query request
+ */
+typedef struct pgFdwExecutionState
+{
+	PGconn	   *conn;
+	PGresult   *res;
+	List	   *colmap;
+	int			nextrow;
+} pgFdwExecutionState;
+
+extern Datum postgresql_fdw_handler(PG_FUNCTION_ARGS);
+
+/*
+ * FDW routines
+ */
+static FdwPlan *pgPlanRelScan(Oid foreigntableid, PlannerInfo *root,
+			  RelOptInfo *baserel);
+static FdwExecutionState *pgBeginScan(FdwPlan *plan, ParamListInfo params);
+static void pgIterate(FdwExecutionState *state, TupleTableSlot *slot);
+static void pgReScan(FdwExecutionState *state);
+static void pgEndScan(FdwExecutionState *state);
+
+/* helper for deparsing a request into SQL statement */
+
+static bool is_foreign_qual(PlannerInfo *root, RelOptInfo *baserel, Expr *expr);
+static char *deparseSql(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel, List **colmap);
+
+static void storeResult(pgFdwExecutionState *priv, TupleTableSlot *slot, int rowno);
+
+/*
+ * Connection management
+ */
+static PGconn *GetConnection(ForeignServer *server, UserMapping *user);
+static void ReleaseConnection(PGconn *conn);
+static void check_conn_params(const char **keywords, const char **values);
+static PGconn *connect_pg_server(ForeignServer *server, UserMapping *user);
+static void cleanup_connection(ResourceReleasePhase phase,
+							   bool isCommit,
+							   bool isTopLevel,
+							   void *arg);
+
+/*
+ * FdwRoutine of PostgreSQL wrapper
+ */
+static FdwRoutine postgresql_fdw_routine =
+{
+	pgPlanRelScan,
+	pgBeginScan,
+	pgIterate,
+	pgReScan,
+	pgEndScan
+};
+
+/*
+ * return foreign-data wrapper handler object to execute foreign-data wrapper
+ * routines.
+ */
+PG_FUNCTION_INFO_V1(postgresql_fdw_handler);
+Datum
+postgresql_fdw_handler(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_POINTER(&postgresql_fdw_routine);
+}
+
+static FdwPlan *
+pgPlanRelScan(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel)
+{
+	FdwPlan	   *plan = makeNode(FdwPlan);
+	char	   *sql;
+	List	   *colmap;
+
+	sql = deparseSql(foreigntableid, root, baserel, &colmap);
+
+	plan->explainInfo = sql;
+	plan->fdw_private = list_make2(makeString(sql), colmap);
+
+	return plan;
+}
+
+typedef struct
+{
+	PlannerInfo *root;
+	RelOptInfo *foreignrel;
+} remotely_executable_cxt;
+
+static bool
+is_proc_remotely_executable(Oid procid)
+{
+	/* assume that only built-in functions can be pushed down */
+	if (get_func_namespace(procid) != PG_CATALOG_NAMESPACE)
+		return false;
+	/* we don't check volatility here, that's done once at the top-level */
+
+	return true;
+}
+
+static bool
+is_not_remotely_executable_walker(Node *node, remotely_executable_cxt *context)
+{
+	if (node == NULL)
+		return false;
+
+	if (IsA(node, Query))
+		return true;
+
+	switch (nodeTag(node))
+	{
+		case T_Query:
+			/* give up on subqueries */
+			return true;
+		case T_Param:
+			/* TODO: pass internal parameters to the foreign server */
+			{
+				ParamKind	paramkind = ((Param *) node)->paramkind;
+				elog(DEBUG1, "%s() param=%s", __FUNCTION__,
+	  				paramkind == PARAM_EXTERN ? "PARAM_EXTERN" :
+	  				paramkind == PARAM_EXEC ? "PARAM_EXEC" :
+	  				paramkind == PARAM_SUBLINK ? "PARAM_SUBLINK" : "unkown");
+			}
+			if (((Param *) node)->paramkind != PARAM_EXTERN)
+				return true;
+			break;
+		case T_OpExpr:
+			{
+				OpExpr *op = (OpExpr *) node;
+				if (!is_proc_remotely_executable(op->opfuncid))
+					return true;
+				else
+					return false;
+			}
+		case T_FuncExpr:
+			{
+				FuncExpr *fe = (FuncExpr *) node;
+				if (!is_proc_remotely_executable(fe->funcid))
+					return true;
+				else
+					return false;
+			}
+
+		case T_TargetEntry:
+		case T_PlaceHolderVar:
+		case T_AppendRelInfo:
+		case T_PlaceHolderInfo:
+			/* TODO: research whether those complex nodes are evaluatable. */
+			return true;
+		case T_Var:
+			{
+				Var *var = (Var *) node;
+				if (var->varno != context->foreignrel->relid || var->varlevelsup != 0)
+					return true;
+				else
+					return false;
+			}
+
+		default:
+			break;
+	}
+
+	return expression_tree_walker(node, is_not_remotely_executable_walker,
+								  context);
+}
+
+
+/*
+ * Check whether the ExprState node can be evaluated in foreign server.
+ *
+ * An expression which consists of expressions below can be evaluated in
+ * the foreign server.
+ *  - constant value
+ *  - variable (foreign table column)
+ *  - external parameter (parameter of prepared statement)
+ *  - array
+ *  - bool expression (AND/OR/NOT)
+ *  - NULL test (IS [NOT] NULL)
+ *  - operator
+ *    - IMMUTABLE only
+ *    - It is required that the meaning of the operator be the same as the
+ *      local server in the foreign server. 
+ *  - function
+ *    - IMMUTABLE only
+ *    - It is required that the meaning of the operator be the same as the
+ *      local server in the foreign server. 
+ *  - scalar array operator (ANY/ALL)
+ */
+static bool
+is_foreign_qual(PlannerInfo *root, RelOptInfo *baserel, Expr *expr)
+{
+	remotely_executable_cxt context;
+
+	context.root = root;
+	context.foreignrel = baserel;
+	if (is_not_remotely_executable_walker((Node *) expr, &context))
+		return false;
+	if (contain_volatile_functions((Node *) expr))
+		return false;
+
+	return true;
+}
+
+/*
+ * Deparse query request into SQL statement.
+ *
+ * If an expression in PlanState.qual list satisfies is_foreign_qual(), the
+ * expression is:
+ *   - deparsed into WHERE clause of remote SQL statement to evaluate that
+ *     expression on remote side
+ *   - removed from PlanState.qual list to avoid duplicate evaluation, on
+ *     remote side and local side
+ */
+static char *
+deparseSql(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel,
+		   List **colmap)
+{
+	List		   *context;
+	StringInfoData	sql;
+	ForeignTable   *table = GetForeignTable(foreigntableid);
+	ListCell   *lc;
+	char	   *nspname = NULL;
+	char	   *relname = NULL;
+	bool	   *requiredatts;
+	RangeTblEntry *rte;
+	AttrNumber	attno;
+
+	/* extract ForeignScan and RangeTblEntry */
+
+	/* prepare to deparse plan */
+	initStringInfo(&sql);
+
+	/* 
+	 * deparse SELECT target list. We only fetch the necessary columns from
+	 * the remote server, but the result tuple needs to include all columns.
+	 * So we need a mapping of the columns actually fetched to the full
+	 * row type of the relation. Build that map here too.
+	 */
+	*colmap = NIL;
+	appendStringInfoString(&sql, "SELECT ");
+	requiredatts = palloc0((baserel->max_attr + 1) * sizeof(bool));
+	foreach (lc, baserel->reltargetlist)
+	{
+		Var *var = lfirst(lc);
+
+		if (var->varlevelsup != 0)
+			elog(ERROR, "unexpected varlevelsup: %d", var->varlevelsup);
+		if (var->varno != baserel->relid)
+			elog(ERROR, "reference to another relation in reltargetlist");
+		if (var->varattno < 0)
+			elog(ERROR, "fetching remote system attributes is not supported");
+		if (var->varattno > baserel->max_attr)
+			elog(ERROR, "unexpected attribute number %d", var->varattno);
+
+		requiredatts[var->varattno] = true;
+	}
+
+	/* whole row */
+	if (requiredatts[0] == true)
+		MemSet(requiredatts, true, baserel->max_attr + 1);
+
+	rte = rt_fetch(baserel->relid, root->parse->rtable);
+	for (attno = 1; attno <= baserel->max_attr; attno++)
+	{
+		if (requiredatts[attno])
+		{
+			char *attname;
+
+			if (*colmap != NIL)
+				appendStringInfoString(&sql, ", ");
+
+			attname  = get_rte_attribute_name(rte, attno);
+			appendStringInfoString(&sql, quote_identifier(attname));
+
+			*colmap = lappend_int(*colmap, attno);
+		}
+	}
+
+	/*
+	 * Deparse FROM
+	 *
+	 * If the foreign table has generic option "nspname" and/or "relname", use
+	 * them in the foreign query.  Otherwise, use local catalog names.
+	 */
+	foreach(lc, table->options)
+	{
+		DefElem *opt = lfirst(lc);
+		if (strcmp(opt->defname, "nspname") == 0)
+			nspname = pstrdup(strVal(opt->arg));
+		else if (strcmp(opt->defname, "relname") == 0)
+			relname = pstrdup(strVal(opt->arg));
+	}
+	if (nspname == NULL)
+		nspname = get_namespace_name(get_rel_namespace(foreigntableid));
+	if (relname == NULL)
+		relname = get_rel_name(foreigntableid);
+	appendStringInfo(&sql, " FROM %s.%s",
+					 quote_identifier(nspname), 
+					 quote_identifier(relname));
+	
+
+	/*
+	 * deparse WHERE cluase
+	 *
+	 * The expressions which satisfy is_foreign_qual() are deparsed into WHERE
+	 * clause of result SQL string, and they could be removed from qual of
+	 * PlanState to avoid duplicate evaluation at ExecScan().
+	 *
+	 * We never change the qual in the Plan node which was made by PREPARE
+	 * statement to make following EXECUTE statements work properly.  The Plan
+	 * node is used repeatedly to create PlanState for each EXECUTE statement.
+	 */
+	if (baserel->baserestrictinfo)
+	{
+		List	   *local_qual = NIL;
+		List	   *foreign_expr = NIL;
+		ListCell   *lc;
+
+		/*
+		 * Divide qual of PlanState into two lists, one for local evaluation
+		 * and one for foreign evaluation.
+		 */
+		foreach (lc, baserel->baserestrictinfo)
+		{
+			RestrictInfo *ri = (RestrictInfo *) lfirst(lc);
+
+			if (is_foreign_qual(root, baserel, ri->clause))
+			{
+				/* XXX: deparse and add to sql here */
+				foreign_expr = lappend(foreign_expr, ri->clause);
+			}
+			else
+				local_qual = lappend(local_qual, ri);
+		}
+		/*
+		 * XXX: If the remote side is not reliable enough, we can keep the qual
+		 * in PlanState as is and evaluate them on local side too.  If so, just
+		 * omit replacement below.
+		 */
+		baserel->baserestrictinfo = local_qual;
+
+		/*
+		 * Deparse quals to be evaluated in the foreign server if any.
+		 * TODO: modify deparse_expression() to deparse conditions which use
+		 * internal parameters.
+		 */
+		if (foreign_expr != NIL)
+		{
+			Node   *node;
+
+			context = deparse_context_for("foreigntable", foreigntableid);
+
+			node = (Node *) make_ands_explicit(foreign_expr);
+			node = copyObject(node);
+
+			/*
+			 * XXX: deparse_context_for creates a context where the relation
+			 * is relation no 1 in the range table. But the quals we have
+			 * use something else to refer to this foreign table. Make a
+			 * temporary copy of the quals and adjust varnos to 1.
+			 */
+			OffsetVarNodes(node, 1 - baserel->relid, 0);
+			appendStringInfo(&sql, " WHERE %s",
+				deparse_expression(node, context, false, false));
+			/*
+			 * The contents of the list MUST NOT be free-ed because they are
+			 * referenced from Plan.qual list.
+			 */
+			list_free(foreign_expr);
+		}
+	}
+
+	elog(DEBUG1, "deparsed SQL is \"%s\"", sql.data);
+
+	return sql.data;
+}
+
+/*
+ * Initiate actual scan on a foreign table.
+ * This function is called just after pgOpen() if the ForeignScan was executed
+ * for a real query or EXPLAIN statement with ANALYZE option.
+ */
+static FdwExecutionState *
+pgBeginScan(FdwPlan *plan, ParamListInfo params)
+{
+	FdwExecutionState *result = palloc(sizeof(FdwExecutionState));
+	pgFdwExecutionState *state;
+	PGconn	   *conn;
+	PGresult   *res;
+	int			numParams = params ? params->numParams : 0;
+	Oid		   *types = NULL;
+	const char **values = NULL;
+	const char *sql = strVal(linitial((List *) plan->fdw_private));
+	List	   *colmap = lsecond((List *) plan->fdw_private);
+
+	state = palloc(sizeof(pgFdwExecutionState));
+	state->colmap = colmap;
+
+	conn = GetConnection(GetForeignServer(plan->serverid),
+						 GetUserMapping(plan->userid, plan->serverid));
+	state->conn = conn;	
+
+	result->fdw_private = state;
+
+	elog(DEBUG3, "%s() called", __FUNCTION__);
+
+	/* construct parameter array in text format */
+	/* TODO: omit unused parameter */
+	if (numParams > 0)
+	{
+		int			i;
+
+		types = palloc0(sizeof(Oid) * numParams);
+		values = palloc0(sizeof(char *) * numParams);
+		for (i = 0; i < numParams; i++)
+		{
+			types[i] = params->params[i].ptype;
+			if (params->params[i].isnull)
+				values[i] = NULL;
+			else
+			{
+				Oid			out_func_oid;
+				bool		isvarlena;
+				FmgrInfo	func;
+
+				/* TODO: cache FmgrInfo to use it again after pgReOpen() */
+				/* TODO: send parameters in binary format rather than text */
+				getTypeOutputInfo(types[i], &out_func_oid, &isvarlena);
+				fmgr_info(out_func_oid, &func);
+				values[i] =
+					OutputFunctionCall(&func, params->params[i].value);
+			}
+		}
+	}
+
+	/*
+	 * Execute query with the parameters.
+	 * TODO: support internal parameters(PARAM_EXTERN)
+	 * TODO: support cursor mode for huge result sets.
+	 */
+	res = PQexecParams(conn, sql, numParams, types, values, NULL, NULL, 0);
+	if (numParams > 0)
+	{
+		int i;
+		pfree(types);
+		for (i = 0; i < numParams; i++)
+			pfree((char *) values[i]);
+		pfree(values);
+	}
+
+	/*
+	 * If the query has failed, reporting details is enough here.
+	 * Connections which are used by this query (including other scans) will
+	 * be cleaned up by the foreign connection manager.
+	 */
+	if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
+	{
+		char *msg;
+
+		msg = pstrdup(PQerrorMessage(conn));
+		PQclear(res);
+		ereport(ERROR,
+				(errmsg("could not execute foreign query"),
+				 errdetail("%s", msg),
+				 errhint("%s", sql)));
+	}
+
+	state->res = res;
+	state->nextrow = 0;
+
+	return result;
+}
+
+/*
+ * return tuples one by one.
+ *   - execute SQL statement which was deparsed in pgOpen()
+ *
+ * The all of result are fetched at once when pgIterate() is called first after
+ * pgOpen() or pgReOpen().
+ * pgIterate() moves the next tuple from tupstore to TupleTableSlot in
+ * ScanState.
+ */
+static void
+pgIterate(FdwExecutionState *state, TupleTableSlot *slot)
+{
+	pgFdwExecutionState *priv = state->fdw_private;
+
+	elog(DEBUG3, "%s() called", __FUNCTION__);
+
+	if (priv->nextrow == PQntuples(priv->res))
+		ExecClearTuple(slot);
+	else
+		storeResult(priv, slot, priv->nextrow++);
+}
+
+static void
+pgReScan(FdwExecutionState *state)
+{
+	((pgFdwExecutionState *)state->fdw_private)->nextrow = 0;
+}
+
+static void
+pgEndScan(FdwExecutionState *state)
+{
+	pgFdwExecutionState *priv = (pgFdwExecutionState *) state->fdw_private;
+
+	PQclear(priv->res);
+	pfree(priv);
+}
+
+/*
+ * Store a PGresult into tuplestore.
+ */
+static void
+storeResult(pgFdwExecutionState *priv, TupleTableSlot *slot, int rowno)
+{
+	int			nfields;
+	char	  **values;
+	AttInMetadata *attinmeta;
+	Form_pg_attribute *attrs;
+	TupleDesc	tupdesc = slot->tts_tupleDescriptor;
+	HeapTuple	tuple;
+	ListCell   *lc;
+	int			i;
+
+	nfields = PQnfields(priv->res);
+	attrs = tupdesc->attrs;
+
+	/* buffer should include dropped columns */
+	values = palloc0(sizeof(char *) * tupdesc->natts);
+
+	/* store tuple in the slot */
+	attinmeta = TupleDescGetAttInMetadata(tupdesc);
+
+	i = 0;
+	foreach(lc, priv->colmap)
+	{
+		AttrNumber attno = lfirst_int(lc);
+
+		/* check result and tuple descriptor have the same number of columns */
+		if (attno < 1 || attno > tupdesc->natts)
+			elog(ERROR, "invalid attribute number %d", attno);
+
+		/* skip dropped columns. */
+		if (attrs[attno - 1]->attisdropped ||
+			PQgetisnull(priv->res, rowno, i))
+		{
+			values[attno - 1] = NULL;
+		}
+		else
+			values[attno - 1] = PQgetvalue(priv->res, rowno, i);
+
+		i++;
+	}
+
+	/* build the tuple and put it into the tuplestore. */
+	tuple = BuildTupleFromCStrings(attinmeta, values);
+	ExecStoreTuple(tuple, slot, InvalidBuffer, false /* no need to pfree because we run in the per-tuple context */);
+
+	pfree(values);
+}
+
+#ifdef NOT_USED
+/*
+ * Retrieve cost-factors of the foreign server from catalog.
+ */
+static void
+get_server_costs(Oid relid, double *connection_cost, double *transfer_cost)
+{
+	ForeignTable   *table;
+	ForeignServer  *server;
+	int				n;
+	const char	  **keywords;
+	const char	  **values;
+	int				i;
+
+	/*
+	 * Retrieve generic options from the target table and its server to correct
+	 * costs.
+	 */
+	table = GetForeignTable(relid);
+	server = GetForeignServer(table->serverid);
+	n = list_length(table->options) + list_length(server->options) + 1;
+	keywords = (const char **) palloc(sizeof(char *) * n);
+	values = (const char **) palloc(sizeof(char *) * n);
+	n = 0;
+	n += flatten_generic_options(server->options, keywords + n, values + n);
+	n += flatten_generic_options(table->options, keywords + n, values + n);
+	keywords[n] = values[n] = NULL;
+
+	for (i = 0; keywords[i]; i++)
+	{
+		if (pg_strcasecmp(keywords[i], "connection_cost") == 0)
+			*connection_cost = strtod(values[i], NULL);
+		else if (pg_strcasecmp(keywords[i], "transfer_cost") == 0)
+			*transfer_cost = strtod(values[i], NULL);
+	}
+
+	pfree(keywords);
+	pfree(values);
+}
+#endif
+
+/*
+ * Estimate costs of scanning on a foreign table.
+ *
+ * baserel->baserestrictinfo can be used to examine quals on the relation.
+ */
+static void
+pgEstimateCosts(ForeignPath *path, PlannerInfo *root, RelOptInfo *baserel)
+{
+	RangeTblEntry  *rte;
+	double			connection_cost = 0.0;
+	double			transfer_cost = 0.0;
+
+	elog(DEBUG3, "%s() called", __FUNCTION__);
+
+	/*
+	 * Use cost_seqscan() to get approximate value.
+	 */
+	cost_seqscan(&path->path, root, baserel);
+
+	/* Get cost factor from catalog to correct costs. */
+	rte = planner_rt_fetch(baserel->relid, root);
+#ifdef NOT_USED
+	get_server_costs(rte->relid, &connection_cost, &transfer_cost);
+#endif
+	/* XXX arbitrary guesses */
+	connection_cost = 10.0;
+	transfer_cost = 1.0;
+	path->path.startup_cost += connection_cost;
+	path->path.total_cost += connection_cost;
+	path->path.total_cost += transfer_cost *
+						path->path.parent->width * path->path.parent->rows;
+}
+
+/* ============================================================================
+ * Connection management functions
+ * ==========================================================================*/
+
+/*
+ * Connection cache entry managed with hash table.
+ */
+typedef struct ConnCacheEntry
+{
+	/* hash key must be first */
+	char			name[NAMEDATALEN];	/* connection name; used as hash key */
+	int				refs;				/* reference counter */
+	PGconn		   *conn;				/* foreign server connection */
+} ConnCacheEntry;
+
+/*
+ * Hash table which is used to cache connection to PostgreSQL servers, will be
+ * initialized before first attempt to connect PostgreSQL server by the backend.
+ */
+static HTAB *FSConnectionHash;
+
+/*
+ * Get a PGconn which can be used to execute foreign query on the remote
+ * PostgreSQL server with the user's authorization.  If this was the first
+ * request for the server, new connection is established.
+ */
+static PGconn *
+GetConnection(ForeignServer *server, UserMapping *user)
+{
+	const char	   *conname = server->servername;
+	bool			found;
+	ConnCacheEntry *entry;
+	PGconn		   *conn = NULL;
+
+	/* initialize connection cache if it isn't */
+	if (FSConnectionHash == NULL)
+	{
+		HASHCTL		ctl;
+
+		/* hash key is the name of the connection */
+		MemSet(&ctl, 0, sizeof(ctl));
+		ctl.keysize = NAMEDATALEN;
+		ctl.entrysize = sizeof(ConnCacheEntry);
+		/* allocate FSConnectionHash in the cache context */
+		ctl.hcxt = CacheMemoryContext;
+		FSConnectionHash = hash_create("Foreign Connections", 32,
+									   &ctl,
+									   HASH_ELEM | HASH_CONTEXT);
+	}
+
+	/* Is there any cached and valid connection with such name? */
+	entry = hash_search(FSConnectionHash, conname, HASH_ENTER, &found);
+	if (found)
+	{
+		if (entry->conn != NULL)
+		{
+			entry->refs++;
+			elog(DEBUG3, "ref %d for %s", entry->refs, entry->name);
+			return entry->conn;
+		}
+
+		/*
+		 * Connection cache entry was found but connection in it is invalid.
+		 * We reuse entry to store newly established connection later.
+		 */
+	}
+	else
+	{
+		/*
+		 * Use ResourceOner to clean the connection up on error including
+		 * user interrupt.
+		 */
+		entry->refs = 0;
+		entry->conn = NULL;
+		RegisterResourceReleaseCallback(cleanup_connection, entry);
+	}
+
+	/*
+	 * Here we have to establish new connection.
+	 * Use PG_TRY block to ensure closing connection on error.
+	 */
+	PG_TRY();
+	{
+		/* Connect to the foreign PostgreSQL server */
+		conn = connect_pg_server(server, user);
+
+		/*
+		 * Initialize the cache entry to keep new connection.
+		 * Note: entry->name has been initialized in hash_search(HASH_ENTER).
+		 */
+		entry->refs = 1;
+		entry->conn = conn;
+		elog(DEBUG3, "connected to %s (%d)", entry->name, entry->refs);
+	}
+	PG_CATCH();
+	{
+		PQfinish(conn);
+		entry->refs = 0;
+		entry->conn = NULL;
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	return conn;
+}
+
+/*
+ * For non-superusers, insist that the connstr specify a password.	This
+ * prevents a password from being picked up from .pgpass, a service file,
+ * the environment, etc.  We don't want the postgres user's passwords
+ * to be accessible to non-superusers.
+ */
+static void
+check_conn_params(const char **keywords, const char **values)
+{
+	int			i;
+
+	/* no check required if superuser */
+	if (superuser())
+		return;
+
+	/* ok if params contain a non-empty password */
+	for (i = 0; keywords[i] != NULL; i++)
+	{
+		if (strcmp(keywords[i], "password") == 0 && values[i][0] != '\0')
+			return;
+	}
+
+	ereport(ERROR,
+		  (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
+		   errmsg("password is required"),
+		   errdetail("Non-superusers must provide a password in the connection string.")));
+}
+
+static int
+flatten_generic_options(List *defelems, const char **keywords, const char **values)
+{
+	ListCell *lc;
+	int i;
+
+	i = 0;
+	foreach(lc, defelems)
+	{
+		DefElem *d = (DefElem *) lfirst(lc);
+		keywords[i] = d->defname;
+		values[i] = strVal(d->arg);
+		i++;
+	}
+	return i;
+}
+
+static PGconn *
+connect_pg_server(ForeignServer *server, UserMapping *user)
+{
+	const char	   *conname = server->servername;
+	PGconn		   *conn;
+	const char	  **all_keywords;
+	const char	  **all_values;
+	const char	  **keywords;
+	const char	  **values;
+	int				n;
+	int				i, j;
+
+	/*
+	 * Construct connection params from generic options of ForeignServer and
+	 * UserMapping.  Generic options might not be a one of connection options.
+	 */
+	n = list_length(server->options) + list_length(user->options) + 1;
+	all_keywords = (const char **) palloc(sizeof(char *) * n);
+	all_values = (const char **) palloc(sizeof(char *) * n);
+	keywords = (const char **) palloc(sizeof(char *) * n);
+	values = (const char **) palloc(sizeof(char *) * n);
+	n = 0;
+	n += flatten_generic_options(server->options,
+								 all_keywords + n, all_values + n);
+	n += flatten_generic_options(user->options,
+								 all_keywords + n, all_values + n);
+	all_keywords[n] = all_values[n] = NULL;
+
+	for (i = 0, j = 0; all_keywords[i]; i++)
+	{
+		/* Use only libpq connection options. */
+		if (!is_libpq_connection_option(all_keywords[i]))
+			continue;
+		keywords[j] = all_keywords[i];
+		values[j] = all_values[i];
+		j++;
+	}
+	keywords[j] = values[j] = NULL;
+	pfree(all_keywords);
+	pfree(all_values);
+
+	/* verify connection parameters and do connect */
+	check_conn_params(keywords, values);
+	conn = PQconnectdbParams(keywords, values, 0);
+	if (!conn || PQstatus(conn) != CONNECTION_OK)
+		ereport(ERROR,
+				(errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
+				 errmsg("could not connect to server \"%s\"", conname),
+				 errdetail("%s", PQerrorMessage(conn))));
+	pfree(keywords);
+	pfree(values);
+
+	return conn;
+}
+
+/*
+ * Mark the connection as "unused", and close it if the caller was the last
+ * user of the connection.
+ */
+static void
+ReleaseConnection(PGconn *conn)
+{
+	HASH_SEQ_STATUS		scan;
+	ConnCacheEntry	   *entry;
+
+	if (conn == NULL)
+		return;
+
+	/*
+	 * We need to scan seqencially since we use the address to find appropriate
+	 * PGconn from the hash table.
+	 */ 
+	hash_seq_init(&scan, FSConnectionHash);
+	while ((entry = (ConnCacheEntry *) hash_seq_search(&scan)))
+	{
+		if (entry->conn == conn)
+			break;
+	}
+	hash_seq_term(&scan);
+
+	/*
+	 * If the released connection was an orphan, just close it.
+	 */
+	if (entry == NULL)
+	{
+		PQfinish(conn);
+		return;
+	}
+
+	/* If the caller was the last referer, unregister it from cache. */
+	entry->refs--;
+	elog(DEBUG3, "ref %d for %s", entry->refs, entry->name);
+	if (entry->refs == 0)
+	{
+		elog(DEBUG3, "closing connection \"%s\"", entry->name);
+		PQfinish(entry->conn);
+		entry->refs = 0;
+		entry->conn = NULL;
+	}
+}
+
+/*
+ * Clean the connection up via ResourceOwner when pgClose couldn't close the
+ * connection gracefully.
+ */
+static void
+cleanup_connection(ResourceReleasePhase phase,
+				   bool isCommit,
+				   bool isTopLevel,
+				   void *arg)
+{
+	ConnCacheEntry *entry = (ConnCacheEntry *) arg;
+
+	/*
+	 * If the transaction was committed, the connection has been closed via
+	 * pgClose() and ReleaseConnection().
+	 */
+	if (isCommit)
+		return;
+
+	/*
+	 * We clean the connection up on post-lock because foreign connections are
+	 * backend-internal resource.
+	 */
+	if (phase != RESOURCE_RELEASE_AFTER_LOCKS)
+		return;
+
+	/*
+	 * We ignore cleanup for ResourceOwners other than transaction.  At this
+	 * point, such a ResourceOwner is only Portal. 
+	 */
+	if (CurrentResourceOwner != CurTransactionResourceOwner)
+		return;
+
+	/*
+	 * We don't care whether we are in TopTransaction or Subtransaction.
+	 * Anyway, we close the connection and reset the reference counter.
+	 */
+	if (entry->conn != NULL)
+	{
+		elog(DEBUG3, "closing connection to %s", entry->name);
+		PQfinish(entry->conn);
+		entry->refs = 0;
+		entry->conn = NULL;
+	}
+	else
+		elog(DEBUG3, "connection to %s already closed", entry->name);
+}
diff --git a/contrib/postgresql_fdw/postgresql_fdw.h b/contrib/postgresql_fdw/postgresql_fdw.h
new file mode 100644
index 0000000..0af367c
--- /dev/null
+++ b/contrib/postgresql_fdw/postgresql_fdw.h
@@ -0,0 +1,18 @@
+/*
+ * postgresql_fdw.h
+ *
+ * Foreign-data wrapper handler for PostgreSQL
+ *
+ * contrib/postgresql_fdw/postgresql_fdw.h
+ * Copyright (c) 2010, PostgreSQL Global Development Group
+ * ALL RIGHTS RESERVED;
+ *
+ */
+
+#ifndef POSTGRESQL_FDW_H
+#define POSTGRESQL_FDW_H
+
+/* Connection name used for unnamed connection */
+#define UNNAMED_CONN_NAME	"unnamed"
+
+#endif   /* POSTGRESQL_FDW_H */
diff --git a/contrib/postgresql_fdw/postgresql_fdw.sql.in b/contrib/postgresql_fdw/postgresql_fdw.sql.in
new file mode 100644
index 0000000..93d5926
--- /dev/null
+++ b/contrib/postgresql_fdw/postgresql_fdw.sql.in
@@ -0,0 +1,14 @@
+/* contrib/postgresql/postgresql.sql.in */
+
+-- Adjust this setting to control where the objects get created.
+set search_path = public;
+
+CREATE OR REPLACE FUNCTION postgresql_fdw_handler ()
+RETURNS fdw_handler
+AS 'MODULE_PATHNAME','postgresql_fdw_handler'
+LANGUAGE C STRICT;
+
+CREATE FOREIGN DATA WRAPPER postgresql_fdw
+VALIDATOR postgresql_fdw_validator
+HANDLER postgresql_fdw_handler;
+
diff --git a/contrib/postgresql_fdw/sql/postgresql_fdw.sql b/contrib/postgresql_fdw/sql/postgresql_fdw.sql
new file mode 100644
index 0000000..291c7b6
--- /dev/null
+++ b/contrib/postgresql_fdw/sql/postgresql_fdw.sql
@@ -0,0 +1,84 @@
+SET SEARCH_PATH = public;
+SET DATESTYLE = 'Postgres, MDY';
+
+-- =============================================================================
+-- Prepare section
+-- =============================================================================
+-- connect database for regression test
+\c contrib_regression
+
+-- install postgresql_fdw module
+SET client_min_messages = warning;
+\set ECHO none
+\i postgresql_fdw.sql
+\set ECHO all
+
+-- define fdw-related objects
+CREATE SERVER loopback1 FOREIGN DATA WRAPPER postgresql_fdw
+	OPTIONS (dbname 'contrib_regression');
+CREATE SERVER loopback2 FOREIGN DATA WRAPPER postgresql_fdw
+	OPTIONS (dbname 'contrib_regression');
+
+CREATE USER MAPPING FOR PUBLIC SERVER loopback1;
+CREATE USER MAPPING FOR PUBLIC SERVER loopback2 OPTIONS (user 'invalid');
+
+CREATE TABLE t1(
+	c1 integer,
+	c2 text,
+	c3 date
+);
+
+COPY t1 FROM stdin;
+1	foo	1970-01-01
+2	bar	1970-01-02
+3	buz	1970-01-03
+\.
+
+CREATE TABLE t2(
+	c1 integer,
+	c2 text,
+	c3 date
+);
+
+COPY t2 FROM stdin;
+1	foo	1970-01-01
+12	bar	1970-01-02
+13	buz	1970-01-03
+\.
+
+CREATE FOREIGN TABLE ft1 (
+	c1 integer OPTIONS (colname 'invalid'),
+	c2 text OPTIONS (colname 'C2'),
+	c3 date
+) SERVER loopback1 OPTIONS (relname 't1');
+ALTER FOREIGN TABLE ft1 ALTER COLUMN c1 OPTIONS (SET colname 'C1');
+ALTER FOREIGN TABLE ft1 ALTER COLUMN c2 OPTIONS (DROP colname);
+
+CREATE FOREIGN TABLE ft2 (
+	c1 integer,
+	c2 text,
+	c3 date
+) SERVER loopback2 OPTIONS (relname 'invalid');
+
+-- simple query and connection caching
+SELECT ft1.* FROM ft1 ORDER BY c1;
+SELECT * FROM ft2 ORDER BY c1; -- ERROR
+ALTER USER MAPPING FOR PUBLIC SERVER loopback2 OPTIONS (DROP user);
+SELECT * FROM ft2 ORDER BY c1; -- ERROR
+ALTER FOREIGN TABLE ft2 OPTIONS (SET relname 't2');
+SELECT * FROM ft2 ORDER BY c1;
+
+-- join two foreign tables
+SELECT * FROM ft1 JOIN ft2 ON (ft1.c1 = ft2.c1) ORDER BY ft1.c1;
+-- join itself
+SELECT * FROM ft1 t1 JOIN ft1 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1;
+-- outer join
+SELECT * FROM ft1 t1 LEFT JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY 1,2,3,4,5,6;
+-- WHERE clause push-down
+set client_min_messages = debug1;
+SELECT * FROM ft1 WHERE c1 = 1 AND c2 = lower('FOO') AND c3 < now();
+reset client_min_messages;
+
+-- clean up
+DROP FOREIGN DATA WRAPPER postgresql_fdw CASCADE;
+DROP TABLE t1 CASCADE;
diff --git a/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql b/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql
new file mode 100644
index 0000000..a24bbd4
--- /dev/null
+++ b/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql
@@ -0,0 +1,7 @@
+/* contrib/postgresql_fdw/uninstall_postgresql_fdw.sql */
+
+-- Adjust this setting to control where the objects get dropped.
+set search_path = public;
+
+DROP FOREIGN DATA WRAPPER postgresql_fdw;
+DROP FUNCTION postgresql_fdw_handler ();
diff --git a/doc/src/sgml/contrib.sgml b/doc/src/sgml/contrib.sgml
index 75d08d5..d9bfc99 100644
--- a/doc/src/sgml/contrib.sgml
+++ b/doc/src/sgml/contrib.sgml
@@ -115,6 +115,7 @@ psql -d dbname -f <replaceable>SHAREDIR</>/contrib/<replaceable>module</>.sql
  &pgtestfsync;
  &pgtrgm;
  &pgupgrade;
+ &postgresql-fdw;
  &seg;
  &sepgsql;
  &contrib-spi;
diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml
index 659bcba..657e348 100644
--- a/doc/src/sgml/filelist.sgml
+++ b/doc/src/sgml/filelist.sgml
@@ -128,6 +128,7 @@
 <!entity pgtestfsync     SYSTEM "pgtestfsync.sgml">
 <!entity pgtrgm          SYSTEM "pgtrgm.sgml">
 <!entity pgupgrade       SYSTEM "pgupgrade.sgml">
+<!entity postgresql-fdw  SYSTEM "postgresql-fdw.sgml">
 <!entity seg             SYSTEM "seg.sgml">
 <!entity contrib-spi     SYSTEM "contrib-spi.sgml">
 <!entity sepgsql         SYSTEM "sepgsql.sgml">
diff --git a/doc/src/sgml/postgresql-fdw.sgml b/doc/src/sgml/postgresql-fdw.sgml
new file mode 100644
index 0000000..139ea9b
--- /dev/null
+++ b/doc/src/sgml/postgresql-fdw.sgml
@@ -0,0 +1,795 @@
+<!-- doc/src/sgml/postgresql_fdw.sgml -->
+
+<sect1 id="postgresql-fdw">
+ <title>postgresql_fdw</title>
+
+ <indexterm zone="postgresql-fdw">
+  <primary>postgresql_fdw</primary>
+ </indexterm>
+
+ <para>
+  The <filename>postgresql_fdw</> module provides foreign-data wrapper
+  handler function <function>postgresql_fdw_handler</function> which can be
+  used to access external <productname>PostgreSQL</> server via plain SQL.
+ </para>
+
+ <sect2>
+  <title>Functions</title>
+
+  <variablelist>
+   <varlistentry>
+    <term>
+     <function>postgresql_fdw_handler() returns fdw_handler</function>
+    </term>
+
+    <listitem>
+     <para>
+      <function>postgresql_fdw_handler</function> is a foreign-data wrapper
+      handler function which returns foreign-data wrapper handler for
+      PostgreSQL in type of <type>fdw_handler</type>.
+      Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be
+      called from a SQL statement.
+     </para>
+     <para>
+      Internally, it returns a pointer to a <structname>FdwRoutine</structname>
+      object which has set of foreign-data wrapper API functions for handling
+      foreign scan on the external PostgreSQL server.  Functions other than
+      Iterate can be NULL if the foreign-data wrapper has nothing to do in the
+      function.
+     </para>
+    </listitem>
+   </varlistentry>
+
+  </variablelist>
+
+ </sect2>
+
+ <sect2>
+  <title>Details of postgresql_fdw</title>
+
+  <sect3>
+   <title>Connection options</title>
+   <para>
+    The postgresql_fdw retrieves connection information from generic options of
+    user mapping and foriegn server.  All of generic options of these objects
+    are passed to <function>PQconnectdbParams()</function>.
+   </para>
+   <para>
+    Currently, all of the generic options which are allowed in the context of
+    user mapping and foreign server are libpq connection options.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Connection management</title>
+   <para>
+    The postgresql_fdw connects to a remote PostgreSQL server when
+    <function>pgConnectServer()</function> is called for the foreign server
+    first time in the local query.  The connection is used by all of remote
+    queries which are executed on same remote PostgreSQL server.
+    If the local query uses multiple foreign PostgreSQL servers, connections
+    are established for each server (not for each foreign table) and all of
+    them will be closed at the end of the query.  This also means that
+    connection pooling is not implemented in postgresql_fdw.
+   </para>
+   <para>
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Transaction management</title>
+   <para>
+    The postgresql_fdw never emit transaction command such as <command>BEGIN</>,
+    <command>ROLLBACK</> and <command>COMMIT</>. Thus, all SQL statements are
+    executed in each transaction when '<varname>autocommit</>' was set to 'on'. 
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Retrieving all tuples at once</title>
+   <para>
+    The postgresql_fdw retrieves all of the result tuples at once via libpq
+    when the query was executed.  Note that huge result set causes huge memory
+    consumption.  The memory for the result set will be freed at the end of the
+    each query.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>WHERE clause push-down</title>
+   <para>
+    The postgresql_fdw pushes some part of WHERE clause down to the remote
+    server, only if the evaluating the part of clause doesn't break the
+    consistency of the query.  If a clause consist of elements below, the
+    clause will be pushed down.
+   </para>
+   <table id="postgresql-fdw-push-downable">
+    <title>push-down-able elements</title>
+    <tgroup cols="2">
+     <thead>
+      <row>
+      <entry>Element</entry>
+       <entry>Note</entry>
+      </row>
+     </thead>
+     <tbody>
+      <row>
+       <entry>Constant value and column reference</entry>
+      <entry></entry>
+      </row>
+      <row>
+       <entry>Array of push-down-able type</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Parameter of <command>EXECUTE</command></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Bool expression such as <literal>A AND B</literal> or
+       <literal>A OR B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable operator</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>DISTINCT operator, such as
+       <literal>A IS DISTINCT FROM B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Scalar array operator, such as <literal>ALL(...)</literal> and
+       <literal>ANY(...)</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable function call</entry>
+       <entry></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
+  </sect3>
+
+ </sect2>
+
+</sect1>
+<!-- doc/src/sgml/postgresql_fdw.sgml -->
+
+<sect1 id="postgresql-fdw">
+ <title>postgresql_fdw</title>
+
+ <indexterm zone="postgresql-fdw">
+  <primary>postgresql_fdw</primary>
+ </indexterm>
+
+ <para>
+  The <filename>postgresql_fdw</> module provides foreign-data wrapper
+  handler function <function>postgresql_fdw_handler</function> which can be
+  used to access external <productname>PostgreSQL</> server via plain SQL.
+ </para>
+
+ <sect2>
+  <title>Functions</title>
+
+  <variablelist>
+   <varlistentry>
+    <term>
+     <function>postgresql_fdw_handler() returns fdw_handler</function>
+    </term>
+
+    <listitem>
+     <para>
+      <function>postgresql_fdw_handler</function> is a foreign-data wrapper
+      handler function which returns foreign-data wrapper handler for
+      PostgreSQL in type of <type>fdw_handler</type>.
+      Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be
+      called from a SQL statement.
+     </para>
+     <para>
+      Internally, it returns a pointer to a <structname>FdwRoutine</structname>
+      object which has set of foreign-data wrapper API functions for handling
+      foreign scan on the external PostgreSQL server.  Functions other than
+      Iterate can be NULL if the foreign-data wrapper has nothing to do in the
+      function.
+     </para>
+    </listitem>
+   </varlistentry>
+
+  </variablelist>
+
+ </sect2>
+
+ <sect2>
+  <title>Details of postgresql_fdw</title>
+
+  <sect3>
+   <title>Connection options</title>
+   <para>
+    The postgresql_fdw retrieves connection information from generic options of
+    user mapping and foriegn server.  All of generic options of these objects
+    are passed to <function>PQconnectdbParams()</function>.
+   </para>
+   <para>
+    Currently, all of the generic options which are allowed in the context of
+    user mapping and foreign server are libpq connection options.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Connection management</title>
+   <para>
+    The postgresql_fdw connects to a remote PostgreSQL server when
+    <function>pgConnectServer()</function> is called for the foreign server
+    first time in the local query.  The connection is used by all of remote
+    queries which are executed on same remote PostgreSQL server.
+    If the local query uses multiple foreign PostgreSQL servers, connections
+    are established for each server (not for each foreign table) and all of
+    them will be closed at the end of the query.  This also means that
+    connection pooling is not implemented in postgresql_fdw.
+   </para>
+   <para>
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Transaction management</title>
+   <para>
+    The postgresql_fdw never emit transaction command such as <command>BEGIN</>,
+    <command>ROLLBACK</> and <command>COMMIT</>. Thus, all SQL statements are
+    executed in each transaction when '<varname>autocommit</>' was set to 'on'. 
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Retrieving all tuples at once</title>
+   <para>
+    The postgresql_fdw retrieves all of the result tuples at once via libpq
+    when the query was executed.  Note that huge result set causes huge memory
+    consumption.  The memory for the result set will be freed at the end of the
+    each query.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>WHERE clause push-down</title>
+   <para>
+    The postgresql_fdw pushes some part of WHERE clause down to the remote
+    server, only if the evaluating the part of clause doesn't break the
+    consistency of the query.  If a clause consist of elements below, the
+    clause will be pushed down.
+   </para>
+   <table id="postgresql-fdw-push-downable">
+    <title>push-down-able elements</title>
+    <tgroup cols="2">
+     <thead>
+      <row>
+      <entry>Element</entry>
+       <entry>Note</entry>
+      </row>
+     </thead>
+     <tbody>
+      <row>
+       <entry>Constant value and column reference</entry>
+      <entry></entry>
+      </row>
+      <row>
+       <entry>Array of push-down-able type</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Parameter of <command>EXECUTE</command></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Bool expression such as <literal>A AND B</literal> or
+       <literal>A OR B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable operator</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>DISTINCT operator, such as
+       <literal>A IS DISTINCT FROM B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Scalar array operator, such as <literal>ALL(...)</literal> and
+       <literal>ANY(...)</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable function call</entry>
+       <entry></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
+  </sect3>
+
+ </sect2>
+
+</sect1>
+<!-- doc/src/sgml/postgresql_fdw.sgml -->
+
+<sect1 id="postgresql-fdw">
+ <title>postgresql_fdw</title>
+
+ <indexterm zone="postgresql-fdw">
+  <primary>postgresql_fdw</primary>
+ </indexterm>
+
+ <para>
+  The <filename>postgresql_fdw</> module provides foreign-data wrapper
+  handler function <function>postgresql_fdw_handler</function> which can be
+  used to access external <productname>PostgreSQL</> server via plain SQL.
+ </para>
+
+ <sect2>
+  <title>Functions</title>
+
+  <variablelist>
+   <varlistentry>
+    <term>
+     <function>postgresql_fdw_handler() returns fdw_handler</function>
+    </term>
+
+    <listitem>
+     <para>
+      <function>postgresql_fdw_handler</function> is a foreign-data wrapper
+      handler function which returns foreign-data wrapper handler for
+      PostgreSQL in type of <type>fdw_handler</type>.
+      Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be
+      called from a SQL statement.
+     </para>
+     <para>
+      Internally, it returns a pointer to a <structname>FdwRoutine</structname>
+      object which has set of foreign-data wrapper API functions for handling
+      foreign scan on the external PostgreSQL server.  Functions other than
+      Iterate can be NULL if the foreign-data wrapper has nothing to do in the
+      function.
+     </para>
+    </listitem>
+   </varlistentry>
+
+  </variablelist>
+
+ </sect2>
+
+ <sect2>
+  <title>Details of postgresql_fdw</title>
+
+  <sect3>
+   <title>Connection options</title>
+   <para>
+    The postgresql_fdw retrieves connection information from generic options of
+    user mapping and foriegn server.  All of generic options of these objects
+    are passed to <function>PQconnectdbParams()</function>.
+   </para>
+   <para>
+    Currently, all of the generic options which are allowed in the context of
+    user mapping and foreign server are libpq connection options.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Connection management</title>
+   <para>
+    The postgresql_fdw connects to a remote PostgreSQL server when
+    <function>pgConnectServer()</function> is called for the foreign server
+    first time in the local query.  The connection is used by all of remote
+    queries which are executed on same remote PostgreSQL server.
+    If the local query uses multiple foreign PostgreSQL servers, connections
+    are established for each server (not for each foreign table) and all of
+    them will be closed at the end of the query.  This also means that
+    connection pooling is not implemented in postgresql_fdw.
+   </para>
+   <para>
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Transaction management</title>
+   <para>
+    The postgresql_fdw never emit transaction command such as <command>BEGIN</>,
+    <command>ROLLBACK</> and <command>COMMIT</>. Thus, all SQL statements are
+    executed in each transaction when '<varname>autocommit</>' was set to 'on'. 
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Retrieving all tuples at once</title>
+   <para>
+    The postgresql_fdw retrieves all of the result tuples at once via libpq
+    when the query was executed.  Note that huge result set causes huge memory
+    consumption.  The memory for the result set will be freed at the end of the
+    each query.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>WHERE clause push-down</title>
+   <para>
+    The postgresql_fdw pushes some part of WHERE clause down to the remote
+    server, only if the evaluating the part of clause doesn't break the
+    consistency of the query.  If a clause consist of elements below, the
+    clause will be pushed down.
+   </para>
+   <table id="postgresql-fdw-push-downable">
+    <title>push-down-able elements</title>
+    <tgroup cols="2">
+     <thead>
+      <row>
+      <entry>Element</entry>
+       <entry>Note</entry>
+      </row>
+     </thead>
+     <tbody>
+      <row>
+       <entry>Constant value and column reference</entry>
+      <entry></entry>
+      </row>
+      <row>
+       <entry>Array of push-down-able type</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Parameter of <command>EXECUTE</command></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Bool expression such as <literal>A AND B</literal> or
+       <literal>A OR B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable operator</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>DISTINCT operator, such as
+       <literal>A IS DISTINCT FROM B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Scalar array operator, such as <literal>ALL(...)</literal> and
+       <literal>ANY(...)</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable function call</entry>
+       <entry></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
+  </sect3>
+
+ </sect2>
+
+</sect1>
+<!-- doc/src/sgml/postgresql_fdw.sgml -->
+
+<sect1 id="postgresql-fdw">
+ <title>postgresql_fdw</title>
+
+ <indexterm zone="postgresql-fdw">
+  <primary>postgresql_fdw</primary>
+ </indexterm>
+
+ <para>
+  The <filename>postgresql_fdw</> module provides foreign-data wrapper
+  handler function <function>postgresql_fdw_handler</function> which can be
+  used to access external <productname>PostgreSQL</> server via plain SQL.
+ </para>
+
+ <sect2>
+  <title>Functions</title>
+
+  <variablelist>
+   <varlistentry>
+    <term>
+     <function>postgresql_fdw_handler() returns fdw_handler</function>
+    </term>
+
+    <listitem>
+     <para>
+      <function>postgresql_fdw_handler</function> is a foreign-data wrapper
+      handler function which returns foreign-data wrapper handler for
+      PostgreSQL in type of <type>fdw_handler</type>.
+      Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be
+      called from a SQL statement.
+     </para>
+     <para>
+      Internally, it returns a pointer to a <structname>FdwRoutine</structname>
+      object which has set of foreign-data wrapper API functions for handling
+      foreign scan on the external PostgreSQL server.  Functions other than
+      Iterate can be NULL if the foreign-data wrapper has nothing to do in the
+      function.
+     </para>
+    </listitem>
+   </varlistentry>
+
+  </variablelist>
+
+ </sect2>
+
+ <sect2>
+  <title>Details of postgresql_fdw</title>
+
+  <sect3>
+   <title>Connection options</title>
+   <para>
+    The postgresql_fdw retrieves connection information from generic options of
+    user mapping and foriegn server.  All of generic options of these objects
+    are passed to <function>PQconnectdbParams()</function>.
+   </para>
+   <para>
+    Currently, all of the generic options which are allowed in the context of
+    user mapping and foreign server are libpq connection options.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Connection management</title>
+   <para>
+    The postgresql_fdw connects to a remote PostgreSQL server when
+    <function>pgConnectServer()</function> is called for the foreign server
+    first time in the local query.  The connection is used by all of remote
+    queries which are executed on same remote PostgreSQL server.
+    If the local query uses multiple foreign PostgreSQL servers, connections
+    are established for each server (not for each foreign table) and all of
+    them will be closed at the end of the query.  This also means that
+    connection pooling is not implemented in postgresql_fdw.
+   </para>
+   <para>
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Transaction management</title>
+   <para>
+    The postgresql_fdw never emit transaction command such as <command>BEGIN</>,
+    <command>ROLLBACK</> and <command>COMMIT</>. Thus, all SQL statements are
+    executed in each transaction when '<varname>autocommit</>' was set to 'on'. 
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Retrieving all tuples at once</title>
+   <para>
+    The postgresql_fdw retrieves all of the result tuples at once via libpq
+    when the query was executed.  Note that huge result set causes huge memory
+    consumption.  The memory for the result set will be freed at the end of the
+    each query.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>WHERE clause push-down</title>
+   <para>
+    The postgresql_fdw pushes some part of WHERE clause down to the remote
+    server, only if the evaluating the part of clause doesn't break the
+    consistency of the query.  If a clause consist of elements below, the
+    clause will be pushed down.
+   </para>
+   <table id="postgresql-fdw-push-downable">
+    <title>push-down-able elements</title>
+    <tgroup cols="2">
+     <thead>
+      <row>
+      <entry>Element</entry>
+       <entry>Note</entry>
+      </row>
+     </thead>
+     <tbody>
+      <row>
+       <entry>Constant value and column reference</entry>
+      <entry></entry>
+      </row>
+      <row>
+       <entry>Array of push-down-able type</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Parameter of <command>EXECUTE</command></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Bool expression such as <literal>A AND B</literal> or
+       <literal>A OR B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable operator</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>DISTINCT operator, such as
+       <literal>A IS DISTINCT FROM B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Scalar array operator, such as <literal>ALL(...)</literal> and
+       <literal>ANY(...)</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable function call</entry>
+       <entry></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
+  </sect3>
+
+ </sect2>
+
+</sect1>
+<!-- doc/src/sgml/postgresql_fdw.sgml -->
+
+<sect1 id="postgresql-fdw">
+ <title>postgresql_fdw</title>
+
+ <indexterm zone="postgresql-fdw">
+  <primary>postgresql_fdw</primary>
+ </indexterm>
+
+ <para>
+  The <filename>postgresql_fdw</> module provides foreign-data wrapper
+  handler function <function>postgresql_fdw_handler</function> which can be
+  used to access external <productname>PostgreSQL</> server via plain SQL.
+ </para>
+
+ <sect2>
+  <title>Functions</title>
+
+  <variablelist>
+   <varlistentry>
+    <term>
+     <function>postgresql_fdw_handler() returns fdw_handler</function>
+    </term>
+
+    <listitem>
+     <para>
+      <function>postgresql_fdw_handler</function> is a foreign-data wrapper
+      handler function which returns foreign-data wrapper handler for
+      PostgreSQL in type of <type>fdw_handler</type>.
+      Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be
+      called from a SQL statement.
+     </para>
+     <para>
+      Internally, it returns a pointer to a <structname>FdwRoutine</structname>
+      object which has set of foreign-data wrapper API functions for handling
+      foreign scan on the external PostgreSQL server.  Functions other than
+      Iterate can be NULL if the foreign-data wrapper has nothing to do in the
+      function.
+     </para>
+    </listitem>
+   </varlistentry>
+
+  </variablelist>
+
+ </sect2>
+
+ <sect2>
+  <title>Details of postgresql_fdw</title>
+
+  <sect3>
+   <title>Connection options</title>
+   <para>
+    The postgresql_fdw retrieves connection information from generic options of
+    user mapping and foriegn server.  All of generic options of these objects
+    are passed to <function>PQconnectdbParams()</function>.
+   </para>
+   <para>
+    Currently, all of the generic options which are allowed in the context of
+    user mapping and foreign server are libpq connection options.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Connection management</title>
+   <para>
+    The postgresql_fdw connects to a remote PostgreSQL server when
+    <function>pgConnectServer()</function> is called for the foreign server
+    first time in the local query.  The connection is used by all of remote
+    queries which are executed on same remote PostgreSQL server.
+    If the local query uses multiple foreign PostgreSQL servers, connections
+    are established for each server (not for each foreign table) and all of
+    them will be closed at the end of the query.  This also means that
+    connection pooling is not implemented in postgresql_fdw.
+   </para>
+   <para>
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Transaction management</title>
+   <para>
+    The postgresql_fdw never emit transaction command such as <command>BEGIN</>,
+    <command>ROLLBACK</> and <command>COMMIT</>. Thus, all SQL statements are
+    executed in each transaction when '<varname>autocommit</>' was set to 'on'. 
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>Retrieving all tuples at once</title>
+   <para>
+    The postgresql_fdw retrieves all of the result tuples at once via libpq
+    when the query was executed.  Note that huge result set causes huge memory
+    consumption.  The memory for the result set will be freed at the end of the
+    each query.
+   </para>
+  </sect3>
+
+  <sect3>
+   <title>WHERE clause push-down</title>
+   <para>
+    The postgresql_fdw pushes some part of WHERE clause down to the remote
+    server, only if the evaluating the part of clause doesn't break the
+    consistency of the query.  If a clause consist of elements below, the
+    clause will be pushed down.
+   </para>
+   <table id="postgresql-fdw-push-downable">
+    <title>push-down-able elements</title>
+    <tgroup cols="2">
+     <thead>
+      <row>
+      <entry>Element</entry>
+       <entry>Note</entry>
+      </row>
+     </thead>
+     <tbody>
+      <row>
+       <entry>Constant value and column reference</entry>
+      <entry></entry>
+      </row>
+      <row>
+       <entry>Array of push-down-able type</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Parameter of <command>EXECUTE</command></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Bool expression such as <literal>A AND B</literal> or
+       <literal>A OR B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable operator</entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>DISTINCT operator, such as
+       <literal>A IS DISTINCT FROM B</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Scalar array operator, such as <literal>ALL(...)</literal> and
+       <literal>ANY(...)</literal></entry>
+       <entry></entry>
+      </row>
+      <row>
+       <entry>Immutable function call</entry>
+       <entry></entry>
+      </row>
+     </tbody>
+    </tgroup>
+   </table>
+
+  </sect3>
+
+ </sect2>
+
+</sect1>
diff --git a/src/backend/foreign/foreign.c b/src/backend/foreign/foreign.c
index 8089fc6..65e0c32 100644
--- a/src/backend/foreign/foreign.c
+++ b/src/backend/foreign/foreign.c
@@ -433,55 +433,82 @@ pg_options_to_table(PG_FUNCTION_ARGS)
 /*
  * Describes the valid options for postgresql FDW, server, and user mapping.
  */
-struct ConnectionOption
+struct PgFdwOption
 {
 	const char *optname;
 	Oid			optcontext;		/* Oid of catalog in which option may appear */
+	bool		is_conn_opt;	/* True if the option is a connection option */
 };
 
 /*
- * Copied from fe-connect.c PQconninfoOptions.
- *
+ * Valid options for postgresql_fdw.
+ * Connection options are copied from fe-connect.c PQconninfoOptions.
  * The list is small - don't bother with bsearch if it stays so.
  */
-static struct ConnectionOption libpq_conninfo_options[] = {
-	{"authtype", ForeignServerRelationId},
-	{"service", ForeignServerRelationId},
-	{"user", UserMappingRelationId},
-	{"password", UserMappingRelationId},
-	{"connect_timeout", ForeignServerRelationId},
-	{"dbname", ForeignServerRelationId},
-	{"host", ForeignServerRelationId},
-	{"hostaddr", ForeignServerRelationId},
-	{"port", ForeignServerRelationId},
-	{"tty", ForeignServerRelationId},
-	{"options", ForeignServerRelationId},
-	{"requiressl", ForeignServerRelationId},
-	{"sslmode", ForeignServerRelationId},
-	{"gsslib", ForeignServerRelationId},
-	{NULL, InvalidOid}
+static struct PgFdwOption valid_options[] = {
+	/* Connection Options */
+	{"authtype", ForeignServerRelationId, true},
+	{"service", ForeignServerRelationId, true},
+	{"user", UserMappingRelationId, true},
+	{"password", UserMappingRelationId, true},
+	{"connect_timeout", ForeignServerRelationId, true},
+	{"dbname", ForeignServerRelationId, true},
+	{"host", ForeignServerRelationId, true},
+	{"hostaddr", ForeignServerRelationId, true},
+	{"port", ForeignServerRelationId, true},
+	{"tty", ForeignServerRelationId, true},
+	{"options", ForeignServerRelationId, true},
+	{"requiressl", ForeignServerRelationId, true},
+	{"sslmode", ForeignServerRelationId, true},
+	{"gsslib", ForeignServerRelationId, true},
+
+	/* Catalog options */
+	{"nspname", ForeignTableRelationId, false},
+	{"relname", ForeignTableRelationId, false},
+	{"colname", AttributeRelationId, false},
+
+	/* Planner cost options */
+	{"connection_cost", ForeignServerRelationId, false},
+	{"transfer_cost", ForeignServerRelationId, false},
+
+	/* Centinel */
+	{NULL, InvalidOid, false}
 };
 
-
 /*
- * Check if the provided option is one of libpq conninfo options.
+ * Check if the provided option is one of valid options.
  * context is the Oid of the catalog the option came from, or 0 if we
  * don't care.
  */
 static bool
-is_conninfo_option(const char *option, Oid context)
+is_valid_option(const char *option, Oid context)
 {
-	struct ConnectionOption *opt;
+	struct PgFdwOption *opt;
 
-	for (opt = libpq_conninfo_options; opt->optname; opt++)
+	for (opt = valid_options; opt->optname; opt++)
 		if (context == opt->optcontext && strcmp(opt->optname, option) == 0)
 			return true;
 	return false;
 }
 
+/*
+ * Check if the provided option is one of libpq conninfo options.
+ * XXX: Should be moved to interface/libpq or backend/libpq?
+ */
+bool
+is_libpq_connection_option(const char *option)
+{
+	struct PgFdwOption *opt;
+
+	for (opt = valid_options; opt->optname; opt++)
+		if (opt->is_conn_opt && strcmp(opt->optname, option) == 0)
+			return true;
+	return false;
+}
 
 /*
- * Validate the generic option given to SERVER or USER MAPPING.
+ * Validate the generic option given to FOREIGN DATA WRAPPER, SERVER, USER
+ * MAPPING or FOREIGN TABLE.
  * Raise an ERROR if the option or its value is considered
  * invalid.
  *
@@ -500,9 +527,9 @@ postgresql_fdw_validator(PG_FUNCTION_ARGS)
 	{
 		DefElem    *def = lfirst(cell);
 
-		if (!is_conninfo_option(def->defname, catalog))
+		if (!is_valid_option(def->defname, catalog))
 		{
-			struct ConnectionOption *opt;
+			struct PgFdwOption *opt;
 			StringInfoData buf;
 
 			/*
@@ -510,7 +537,7 @@ postgresql_fdw_validator(PG_FUNCTION_ARGS)
 			 * with list of valid options for the object.
 			 */
 			initStringInfo(&buf);
-			for (opt = libpq_conninfo_options; opt->optname; opt++)
+			for (opt = valid_options; opt->optname; opt++)
 				if (catalog == opt->optcontext)
 					appendStringInfo(&buf, "%s%s", (buf.len > 0) ? ", " : "",
 									 opt->optname);
diff --git a/src/include/foreign/foreign.h b/src/include/foreign/foreign.h
index b0cb37c..e2ef32c 100644
--- a/src/include/foreign/foreign.h
+++ b/src/include/foreign/foreign.h
@@ -80,4 +80,6 @@ extern ForeignTable *GetForeignTable(Oid relid);
 extern FdwRoutine *GetFdwRoutineByRelId(Oid relid);
 extern FdwRoutine *GetFdwRoutine(Oid fdwhandler);
 
+extern bool is_libpq_connection_option(const char *option);
+
 #endif   /* FOREIGN_H */
diff --git a/src/test/regress/expected/foreign_data.out b/src/test/regress/expected/foreign_data.out
index 8f7eac5..9e4f3e0 100644
--- a/src/test/regress/expected/foreign_data.out
+++ b/src/test/regress/expected/foreign_data.out
@@ -284,7 +284,7 @@ CREATE SERVER s6 VERSION '16.0' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbna
 CREATE SERVER s7 TYPE 'oracle' VERSION '17.0' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
 CREATE SERVER s8 FOREIGN DATA WRAPPER postgresql OPTIONS (foo '1'); -- ERROR
 ERROR:  invalid option "foo"
-HINT:  Valid options in this context are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib
+HINT:  Valid options in this context are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib, connection_cost, transfer_cost
 CREATE SERVER s8 FOREIGN DATA WRAPPER postgresql OPTIONS (host 'localhost', dbname 's8db');
 \des+
                                                 List of foreign servers
@@ -395,7 +395,7 @@ ERROR:  permission denied for foreign-data wrapper foo
 RESET ROLE;
 ALTER SERVER s8 OPTIONS (foo '1');                          -- ERROR option validation
 ERROR:  invalid option "foo"
-HINT:  Valid options in this context are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib
+HINT:  Valid options in this context are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib, connection_cost, transfer_cost
 ALTER SERVER s8 OPTIONS (connect_timeout '30', SET dbname 'db1', DROP host);
 SET ROLE regress_test_role;
 ALTER SERVER s1 OWNER TO regress_test_indirect;             -- ERROR