WIP: Join push-down for foreign tables

diff --git a/contrib/file_fdw/file_fdw.c b/contrib/file_fdw/file_fdw.c
index 1cf3b3c..4a7ffa6 100644
*** a/contrib/file_fdw/file_fdw.c
--- b/contrib/file_fdw/file_fdw.c
***************
*** 26,32 ****
  #include "nodes/makefuncs.h"
  #include "optimizer/cost.h"
  #include "utils/rel.h"
! #include "utils/syscache.h"
  
  PG_MODULE_MAGIC;
  
--- 26,32 ----
  #include "nodes/makefuncs.h"
  #include "optimizer/cost.h"
  #include "utils/rel.h"
! #include "utils/lsyscache.h"
  
  PG_MODULE_MAGIC;
  
*************** get_file_fdw_attribute_options(Oid relid
*** 345,398 ****
  	/* Retrieve FDW options for all user-defined attributes. */
  	for (attnum = 1; attnum <= natts; attnum++)
  	{
! 		HeapTuple	tuple;
! 		Form_pg_attribute attr;
! 		Datum		datum;
! 		bool		isnull;
  
  		/* Skip dropped attributes. */
  		if (tupleDesc->attrs[attnum - 1]->attisdropped)
  			continue;
  
! 		/*
! 		 * We need the whole pg_attribute tuple not just what is in the
! 		 * tupleDesc, so must do a catalog lookup.
! 		 */
! 		tuple = SearchSysCache2(ATTNUM,
! 								RelationGetRelid(rel),
! 								Int16GetDatum(attnum));
! 		if (!HeapTupleIsValid(tuple))
! 			elog(ERROR, "cache lookup failed for attribute %d of relation %u",
! 				 attnum, RelationGetRelid(rel));
! 		attr = (Form_pg_attribute) GETSTRUCT(tuple);
! 
! 		datum = SysCacheGetAttr(ATTNUM,
! 								tuple,
! 								Anum_pg_attribute_attfdwoptions,
! 								&isnull);
! 		if (!isnull)
  		{
! 			List	   *options = untransformRelOptions(datum);
! 			ListCell   *lc;
  
! 			foreach(lc, options)
  			{
! 				DefElem	   *def = (DefElem *) lfirst(lc);
! 
! 				if (strcmp(def->defname, "force_not_null") == 0)
  				{
! 					if (defGetBoolean(def))
! 					{
! 						char   *attname = pstrdup(NameStr(attr->attname));
  
! 						fnncolumns = lappend(fnncolumns, makeString(attname));
! 					}
  				}
- 				/* maybe in future handle other options here */
  			}
  		}
- 
- 		ReleaseSysCache(tuple);
  	}
  
  	heap_close(rel, AccessShareLock);
--- 345,373 ----
  	/* Retrieve FDW options for all user-defined attributes. */
  	for (attnum = 1; attnum <= natts; attnum++)
  	{
! 		List	   *options;
! 		ListCell   *lc;
  
  		/* Skip dropped attributes. */
  		if (tupleDesc->attrs[attnum - 1]->attisdropped)
  			continue;
  
! 		options = GetForeignColumnOptions(relid, attnum);
! 		foreach(lc, options)
  		{
! 			DefElem	   *def = (DefElem *) lfirst(lc);
  
! 			if (strcmp(def->defname, "force_not_null") == 0)
  			{
! 				if (defGetBoolean(def))
  				{
! 					char   *attname = pstrdup(get_attname(relid, attnum));
  
! 					fnncolumns = lappend(fnncolumns, makeString(attname));
  				}
  			}
+ 			/* maybe in future handle other options here */
  		}
  	}
  
  	heap_close(rel, AccessShareLock);
diff --git a/doc/src/sgml/fdwhandler.sgml b/doc/src/sgml/fdwhandler.sgml
index db02d13..43ad6ed 100644
*** a/doc/src/sgml/fdwhandler.sgml
--- b/doc/src/sgml/fdwhandler.sgml
*************** GetForeignTable(Oid relid);
*** 297,302 ****
--- 297,332 ----
      </para>
  
      <para>
+ <programlisting>
+ char *
+ GetFdwOptionValue(Oid relid, AttrNumber attnum, const char *optname);
+ </programlisting>
+ 
+      This function returns a copy (created in current memory context) of the
+      value of the given option for the given object (relation or its column).
+      If attnum is InvalidAttrNumber, pg_attribute is ignored.
+      If specified option is set in multiple object level, the one in the
+      finest-grained object is used; e.g. priority is given to user mapping 
+      over than a foreign server for the mapping or foreign-data wrapper for the
+      server.
+      This function would be useful when you know which option is needed but you
+      don't know which object(s) have it.
+      If you already know the source object, it would be more efficient to use
+      object retrieval functions.
+     </para>
+ 
+     <para>
+ <programlisting>
+ List *
+ GetForeignTableColumnOptions(Oid relid, AttrNumber attnum);
+ </programlisting>
+ 
+      This function returns per-column FDW options for a column with given
+      relation oid and attribute number in the form of list of
+      <structname>DefElem</structname>.
+     </para>
+ 
+     <para>
       Some object types have name-based functions.
      </para>
  
diff --git a/src/backend/foreign/foreign.c b/src/backend/foreign/foreign.c
index a7d30a1..df0e373 100644
*** a/src/backend/foreign/foreign.c
--- b/src/backend/foreign/foreign.c
*************** GetForeignTable(Oid relid)
*** 248,253 ****
--- 248,361 ----
  
  
  /*
+  * If an option entry which matches the given name was found in the given
+  * list, returns a copy of arg string, otherwise returns NULL.
+  */
+ static char *
+ get_options_value(List *options, const char *optname)
+ {
+ 	ListCell   *lc;
+ 
+ 	/* Find target option from the list. */
+ 	foreach (lc, options)
+ 	{
+ 		DefElem	   *def = lfirst(lc);
+ 
+ 		if (strcmp(def->defname, optname) == 0)
+ 			return pstrdup(strVal(def->arg));
+ 	}
+ 
+ 	return NULL;
+ }
+ 
+ /*
+  * Returns a copy of the value of specified option with searching the option
+  * from appropriate catalog.  If an option was stored in multiple object
+  * levels, one in the finest-grained object level is used; lookup order is:
+  *   1) pg_attribute (only when attnum != InvalidAttrNumber)
+  *   2) pg_foreign_table
+  *   3) pg_user_mapping
+  *   4) pg_foreign_server
+  *   5) pg_foreign_data_wrapper
+  * This priority rule would be useful in most cases using FDW options.
+  *
+  * If attnum was InvalidAttrNumber, we don't retrieve FDW optiosn from
+  * pg_attribute.attfdwoptions.
+  */
+ char *
+ GetFdwOptionValue(Oid relid, AttrNumber attnum, const char *optname)
+ {
+ 	ForeignTable   *table = NULL;
+ 	UserMapping	   *user = NULL;
+ 	ForeignServer  *server = NULL;
+ 	ForeignDataWrapper  *wrapper = NULL;
+ 	char		   *value;
+ 
+ 	/* Do we need to use pg_attribute.attfdwoptions too? */
+ 	if (attnum != InvalidAttrNumber)
+ 	{
+ 		value = get_options_value(GetForeignColumnOptions(relid, attnum),
+ 								  optname);
+ 		if (value != NULL)
+ 			return value;
+ 	}
+ 
+ 	table = GetForeignTable(relid);
+ 	value = get_options_value(table->options, optname);
+ 	if (value != NULL)
+ 		return value;
+ 
+ 	user = GetUserMapping(GetOuterUserId(), table->serverid);
+ 	value = get_options_value(user->options, optname);
+ 	if (value != NULL)
+ 		return value;
+ 
+ 	server = GetForeignServer(table->serverid);
+ 	value = get_options_value(server->options, optname);
+ 	if (value != NULL)
+ 		return value;
+ 
+ 	wrapper = GetForeignDataWrapper(server->fdwid);
+ 	value = get_options_value(wrapper->options, optname);
+ 	if (value != NULL)
+ 		return value;
+ 
+ 	return NULL;
+ }
+ 
+ 
+ /*
+  * GetForeignColumnOptions - Get attfdwoptions of given relation/attnum as
+  * list of DefElem.
+  */
+ List *
+ GetForeignColumnOptions(Oid relid, AttrNumber attnum)
+ {
+ 	List	   *options;
+ 	HeapTuple	tp;
+ 	Datum		datum;
+ 	bool		isnull;
+ 
+ 	tp = SearchSysCache2(ATTNUM,
+ 						 ObjectIdGetDatum(relid),
+ 						 Int16GetDatum(attnum));
+ 	if (!HeapTupleIsValid(tp))
+ 		elog(ERROR, "cache lookup failed for attribute %d of relation %u", attnum, relid);
+ 	datum = SysCacheGetAttr(ATTNUM,
+ 							tp,
+ 							Anum_pg_attribute_attfdwoptions,
+ 							&isnull);
+ 	if (isnull)
+ 		options = NIL;
+ 	else
+ 		options = untransformRelOptions(datum);
+ 
+ 	ReleaseSysCache(tp);
+ 
+ 	return options;
+ }
+ 
+ /*
   * GetFdwRoutine - call the specified foreign-data wrapper handler routine
   * to get its FdwRoutine struct.
   */
diff --git a/src/include/foreign/foreign.h b/src/include/foreign/foreign.h
index 2c436ae..b6c8d5b 100644
*** a/src/include/foreign/foreign.h
--- b/src/include/foreign/foreign.h
*************** extern ForeignDataWrapper *GetForeignDat
*** 75,80 ****
--- 75,83 ----
  extern ForeignDataWrapper *GetForeignDataWrapperByName(const char *name,
  							bool missing_ok);
  extern ForeignTable *GetForeignTable(Oid relid);
+ extern char *GetFdwOptionValue(Oid relid, AttrNumber attnum,
+ 							const char *optname);
+ extern List *GetForeignColumnOptions(Oid relid, AttrNumber attnum);
  
  extern Oid	get_foreign_data_wrapper_oid(const char *fdwname, bool missing_ok);
  extern Oid	get_foreign_server_oid(const char *servername, bool missing_ok);

diff --git a/contrib/Makefile b/contrib/Makefile
index 0c238aa..e09e61e 100644
*** a/contrib/Makefile
--- b/contrib/Makefile
*************** SUBDIRS = \
*** 41,46 ****
--- 41,47 ----
  		pgbench		\
  		pgcrypto	\
  		pgrowlocks	\
+ 		pgsql_fdw	\
  		pgstattuple	\
  		seg		\
  		spi		\
diff --git a/contrib/README b/contrib/README
index a1d42a1..d3fa211 100644
*** a/contrib/README
--- b/contrib/README
*************** pgrowlocks -
*** 158,163 ****
--- 158,167 ----
  	A function to return row locking information
  	by Tatsuo Ishii <ishii@sraoss.co.jp>
  
+ pgsql_fdw -
+ 	Foreign-data wrapper for external PostgreSQL servers.
+ 	by Shigeru Hanada <shigeru.hanada@gmail.com>
+ 
  pgstattuple -
  	Functions to return statistics about "dead" tuples and free
  	space within a table
diff --git a/contrib/pgsql_fdw/.gitignore b/contrib/pgsql_fdw/.gitignore
index ...0854728 .
*** a/contrib/pgsql_fdw/.gitignore
--- b/contrib/pgsql_fdw/.gitignore
***************
*** 0 ****
--- 1,4 ----
+ # Generated subdirectories
+ /results/
+ *.o
+ *.so
diff --git a/contrib/pgsql_fdw/Makefile b/contrib/pgsql_fdw/Makefile
index ...6943409 .
*** a/contrib/pgsql_fdw/Makefile
--- b/contrib/pgsql_fdw/Makefile
***************
*** 0 ****
--- 1,22 ----
+ # pgsql_fdw/Makefile
+ 
+ MODULE_big = pgsql_fdw
+ OBJS	= pgsql_fdw.o option.o deparse.o connection.o
+ PG_CPPFLAGS = -I$(libpq_srcdir)
+ SHLIB_LINK = $(libpq)
+ 
+ EXTENSION = pgsql_fdw
+ DATA = pgsql_fdw--1.0.sql
+ 
+ REGRESS = pgsql_fdw
+ 
+ ifdef USE_PGXS
+ PG_CONFIG = pg_config
+ PGXS := $(shell $(PG_CONFIG) --pgxs)
+ include $(PGXS)
+ else
+ subdir = contrib/pgsql_fdw
+ top_builddir = ../..
+ include $(top_builddir)/src/Makefile.global
+ include $(top_srcdir)/contrib/contrib-global.mk
+ endif
diff --git a/contrib/pgsql_fdw/connection.c b/contrib/pgsql_fdw/connection.c
index ...e2d8d2a .
*** a/contrib/pgsql_fdw/connection.c
--- b/contrib/pgsql_fdw/connection.c
***************
*** 0 ****
--- 1,504 ----
+ /*-------------------------------------------------------------------------
+  *
+  * connection.c
+  *		  Connection management for pgsql_fdw
+  *
+  * Portions Copyright (c) 2011, PostgreSQL Global Development Group
+  *
+  * IDENTIFICATION
+  *		  pgsql_fdw/connection.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ #include "catalog/pg_type.h"
+ #include "foreign/foreign.h"
+ #include "funcapi.h"
+ #include "libpq-fe.h"
+ #include "mb/pg_wchar.h"
+ #include "miscadmin.h"
+ #include "utils/array.h"
+ #include "utils/builtins.h"
+ #include "utils/hsearch.h"
+ #include "utils/memutils.h"
+ #include "utils/resowner.h"
+ #include "utils/tuplestore.h"
+ 
+ #include "pgsql_fdw.h"
+ #include "connection.h"
+ 
+ /* ============================================================================
+  * Connection management functions
+  * ==========================================================================*/
+ 
+ /*
+  * Connection cache entry managed with hash table.
+  */
+ typedef struct ConnCacheEntry
+ {
+ 	/* hash key must be first */
+ 	Oid				serverid;	/* oid of foreign server */
+ 	Oid				userid;		/* oid of local user */
+ 
+ 	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;
+ 
+ /* ----------------------------------------------------------------------------
+  * prototype of private functions
+  * --------------------------------------------------------------------------*/
+ static void
+ cleanup_connection(ResourceReleasePhase phase,
+ 				   bool isCommit,
+ 				   bool isTopLevel,
+ 				   void *arg);
+ static PGconn *connect_pg_server(ForeignServer *server, UserMapping *user);
+ /*
+  * 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.
+  */
+ PGconn *
+ GetConnection(ForeignServer *server, UserMapping *user)
+ {
+ 	bool			found;
+ 	ConnCacheEntry *entry;
+ 	ConnCacheEntry	key;
+ 	PGconn		   *conn = NULL;
+ 
+ 	/* initialize connection cache if it isn't */
+ 	if (FSConnectionHash == NULL)
+ 	{
+ 		HASHCTL		ctl;
+ 
+ 		/* hash key is a pair of oids: serverid and userid */
+ 		MemSet(&ctl, 0, sizeof(ctl));
+ 		ctl.keysize = sizeof(Oid) + sizeof(Oid);
+ 		ctl.entrysize = sizeof(ConnCacheEntry);
+ 		ctl.hash = tag_hash;
+ 		ctl.match = memcmp;
+ 		ctl.keycopy = memcpy;
+ 		/* allocate FSConnectionHash in the cache context */
+ 		ctl.hcxt = CacheMemoryContext;
+ 		FSConnectionHash = hash_create("Foreign Connections", 32,
+ 									   &ctl,
+ 									   HASH_ELEM | HASH_CONTEXT |
+ 									   HASH_FUNCTION | HASH_COMPARE |
+ 									   HASH_KEYCOPY);
+ 	}
+ 
+ 	/* Create key value for the entry. */
+ 	MemSet(&key, 0, sizeof(key));
+ 	key.serverid = server->serverid;
+ 	key.userid = GetOuterUserId();
+ 
+ 	/* Is there any cached and valid connection with such key? */
+ 	entry = hash_search(FSConnectionHash, &key, HASH_ENTER, &found);
+ 	if (found)
+ 	{
+ 		if (entry->conn != NULL)
+ 		{
+ 			entry->refs++;
+ 			elog(DEBUG1,
+ 				 "reuse connection %u/%u (%d)",
+ 				 entry->serverid,
+ 				 entry->userid,
+ 				 entry->refs);
+ 			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 ResourceOwner to clean the connection up on error including
+ 		 * user interrupt.
+ 		 */
+ 		elog(DEBUG1,
+ 			 "create entry for %u/%u (%d)",
+ 			 entry->serverid,
+ 			 entry->userid,
+ 			 entry->refs);
+ 		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: key items of entry has been initialized in
+ 		 * hash_search(HASH_ENTER).
+ 		 */
+ 		entry->refs = 1;
+ 		entry->conn = conn;
+ 		elog(DEBUG1,
+ 			 "connected to %u/%u (%d)",
+ 			 entry->serverid,
+ 			 entry->userid,
+ 			 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 PGconn *
+ connect_pg_server(ForeignServer *server, UserMapping *user)
+ {
+ 	const char	   *conname = server->servername;
+ 	PGconn		   *conn;
+ 	PGresult	   *res;
+ 	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.  Those two object hold only libpq options.
+ 	 * Extra 3 items are for:
+ 	 *   *) fallback_application_name
+ 	 *   *) client_encoding
+ 	 *   *) NULL termination (end marker)
+ 	 *
+ 	 * Note: We don't omit any parameters even target database might be older
+ 	 * than local, because unexpected parameters are just ignored.
+ 	 */
+ 	n = list_length(server->options) + list_length(user->options) + 3;
+ 	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 += ExtractConnectionOptions(server->options,
+ 								  all_keywords + n, all_values + n);
+ 	n += ExtractConnectionOptions(user->options,
+ 								  all_keywords + n, all_values + n);
+ 	all_keywords[n] = all_values[n] = NULL;
+ 
+ 	for (i = 0, j = 0; all_keywords[i]; i++)
+ 	{
+ 		keywords[j] = all_keywords[i];
+ 		values[j] = all_values[i];
+ 		j++;
+ 	}
+ 
+ 	/* Use "pgsql_fdw" as fallback_application_name. */
+ 	keywords[j] = "fallback_application_name";
+ 	values[j++] = "pgsql_fdw";
+ 
+ 	/* Set client_encoding so that libpq can convert encoding properly. */
+ 	keywords[j] = "client_encoding";
+ 	values[j++] = GetDatabaseEncodingName();
+ 
+ 	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);
+ 
+ 	/*
+ 	 * Check that non-superuser has used password to establish connection.
+ 	 * This check logic is based on dblink_security_check() in contrib/dblink.
+ 	 *
+ 	 * XXX Should we check this even if we don't provide unsafe version like
+ 	 * dblink_connect_u()?
+ 	 */
+ 	if (!superuser() && !PQconnectionUsedPassword(conn))
+ 	{
+ 		PQfinish(conn);
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
+ 				 errmsg("password is required"),
+ 				 errdetail("Non-superuser cannot connect if the server does not request a password."),
+ 				 errhint("Target server's authentication method must be changed.")));
+ 	}
+ 
+ 	/*
+ 	 * Start transaction to use cursor to retrieve data separately.
+ 	 */
+ 	res = PQexec(conn, "BEGIN");
+ 	if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+ 		elog(ERROR, "could not start transaction");
+ 
+ 	return conn;
+ }
+ 
+ /*
+  * Mark the connection as "unused", and close it if the caller was the last
+  * user of the connection.
+  */
+ void
+ ReleaseConnection(PGconn *conn)
+ {
+ 	HASH_SEQ_STATUS		scan;
+ 	ConnCacheEntry	   *entry;
+ 
+ 	if (conn == NULL)
+ 		return;
+ 
+ 	/*
+ 	 * We need to scan sequentially 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;
+ 	}
+ 	if (entry != NULL)
+ 		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 referrer, unregister it from cache.
+ 	 * TODO: Note that sharing connections requires a mechanism to detect
+ 	 * change of FDW object to invalidate lasting connections.
+ 	 */
+ 	entry->refs--;
+ 	elog(DEBUG1,
+ 		 "connection %u/%u released (%d)",
+ 		 entry->serverid,
+ 		 entry->userid,
+ 		 entry->refs);
+ }
+ 
+ /*
+  * Clean the connection up via ResourceOwner.
+  */
+ static void
+ cleanup_connection(ResourceReleasePhase phase,
+ 				   bool isCommit,
+ 				   bool isTopLevel,
+ 				   void *arg)
+ {
+ 	ConnCacheEntry *entry = (ConnCacheEntry *) arg;
+ 
+ 	/* If the transaction was committed, don't close connections. */
+ 	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(DEBUG1,
+ 			 "closing connection %u/%u",
+ 			 entry->serverid,
+ 			 entry->userid);
+ 		PQfinish(entry->conn);
+ 		entry->refs = 0;
+ 		entry->conn = NULL;
+ 	}
+ 	else
+ 		elog(DEBUG1,
+ 			 "connection %u/%u already closed",
+ 			 entry->serverid,
+ 			 entry->userid);
+ }
+ 
+ /*
+  * Get list of connections currently active.
+  */
+ Datum pgsql_fdw_get_connections(PG_FUNCTION_ARGS);
+ PG_FUNCTION_INFO_V1(pgsql_fdw_get_connections);
+ Datum
+ pgsql_fdw_get_connections(PG_FUNCTION_ARGS)
+ {
+ 	ReturnSetInfo	   *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+ 	HASH_SEQ_STATUS		scan;
+ 	ConnCacheEntry	   *entry;
+ 	MemoryContext		oldcontext = CurrentMemoryContext;
+ 	Tuplestorestate	   *tuplestore;
+ 	TupleDesc			tupdesc;
+ 
+ 	/* We return list of connection with storing them in a Tuplestore. */
+ 	rsinfo->returnMode = SFRM_Materialize;
+ 	rsinfo->setResult = NULL;
+ 	rsinfo->setDesc = NULL;
+ 
+ 	/* Create tuplestore and copy of TupleDesc in per-query context. */
+ 	MemoryContextSwitchTo(rsinfo->econtext->ecxt_per_query_memory);
+ 
+ 	tupdesc = CreateTemplateTupleDesc(2, false);
+ 	TupleDescInitEntry(tupdesc, 1, "srvid", OIDOID, -1, 0);
+ 	TupleDescInitEntry(tupdesc, 2, "usesysid", OIDOID, -1, 0);
+ 	rsinfo->setDesc = tupdesc;
+ 
+ 	tuplestore = tuplestore_begin_heap(false, false, work_mem);
+ 	rsinfo->setResult = tuplestore;
+ 
+ 	MemoryContextSwitchTo(oldcontext);
+ 
+ 	/*
+ 	 * We need to scan sequentially since we use the address to find
+ 	 * appropriate PGconn from the hash table.
+ 	 */ 
+ 	if (FSConnectionHash != NULL)
+ 	{
+ 		hash_seq_init(&scan, FSConnectionHash);
+ 		while ((entry = (ConnCacheEntry *) hash_seq_search(&scan)))
+ 		{
+ 			Datum		values[2];
+ 			bool		nulls[2];
+ 			HeapTuple	tuple;
+ 
+ 			elog(DEBUG1, "found: %u/%u", entry->serverid, entry->userid);
+ 
+ 			/* Ignore inactive connections */
+ 			if (PQstatus(entry->conn) != CONNECTION_OK)
+ 				continue;
+ 
+ 			/*
+ 			 * Ignore other users' connections if current user isn't a
+ 			 * superuser.
+ 			 */
+ 			if (!superuser() && entry->userid != GetUserId())
+ 				continue;
+ 
+ 			values[0] = ObjectIdGetDatum(entry->serverid);
+ 			values[1] = ObjectIdGetDatum(entry->userid);
+ 			nulls[0] = false;
+ 			nulls[1] = false;
+ 
+ 			tuple = heap_formtuple(tupdesc, values, nulls);
+ 			tuplestore_puttuple(tuplestore, tuple);
+ 		}
+ 	}
+ 	tuplestore_donestoring(tuplestore);
+ 
+ 	PG_RETURN_VOID();
+ }
+ 
+ /*
+  * Discard persistent connection designated by given connection name.
+  */
+ Datum pgsql_fdw_disconnect(PG_FUNCTION_ARGS);
+ PG_FUNCTION_INFO_V1(pgsql_fdw_disconnect);
+ Datum
+ pgsql_fdw_disconnect(PG_FUNCTION_ARGS)
+ {
+ 	Oid					serverid = PG_GETARG_OID(0);
+ 	Oid					userid = PG_GETARG_OID(1);
+ 	ConnCacheEntry		key;
+ 	ConnCacheEntry	   *entry = NULL;
+ 	bool				found;
+ 
+ 	/* Non-superuser can't discard other users' connection. */
+ 	if (!superuser() && userid != GetOuterUserId())
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INSUFFICIENT_RESOURCES),
+ 				 errmsg("only superuser can discard other user's connection")));
+ 
+ 	/*
+ 	 * If no connection has been established, or no such connections, just
+ 	 * return "NG" to indicate nothing has done.
+ 	 */
+ 	if (FSConnectionHash == NULL)
+ 		PG_RETURN_TEXT_P(cstring_to_text("NG"));
+ 
+ 	key.serverid = serverid;
+ 	key.userid = userid;
+ 	entry = hash_search(FSConnectionHash, &key, HASH_FIND, &found);
+ 	if (!found)
+ 		PG_RETURN_TEXT_P(cstring_to_text("NG"));
+ 
+ 	/* Discard cached connection, and clear reference counter. */
+ 	PQfinish(entry->conn);
+ 	entry->refs = 0;
+ 	entry->conn = NULL;
+ 	elog(DEBUG1, "closed connection %u/%u", serverid, userid);
+ 
+ 	PG_RETURN_TEXT_P(cstring_to_text("OK"));
+ }
diff --git a/contrib/pgsql_fdw/connection.h b/contrib/pgsql_fdw/connection.h
index ...80dd3e0 .
*** a/contrib/pgsql_fdw/connection.h
--- b/contrib/pgsql_fdw/connection.h
***************
*** 0 ****
--- 1,25 ----
+ /*-------------------------------------------------------------------------
+  *
+  * connection.h
+  *		  Connection management for pgsql_fdw
+  *
+  * Portions Copyright (c) 2011, PostgreSQL Global Development Group
+  *
+  * IDENTIFICATION
+  *		  pgsql_fdw/connection.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ #ifndef CONNECTION_H
+ #define CONNECTION_H
+ 
+ #include "foreign/foreign.h"
+ #include "libpq-fe.h"
+ 
+ /*
+  * Connection management
+  */
+ PGconn *GetConnection(ForeignServer *server, UserMapping *user);
+ void ReleaseConnection(PGconn *conn);
+ 
+ #endif /* CONNECTION_H */
diff --git a/contrib/pgsql_fdw/deparse.c b/contrib/pgsql_fdw/deparse.c
index ...4dab232 .
*** a/contrib/pgsql_fdw/deparse.c
--- b/contrib/pgsql_fdw/deparse.c
***************
*** 0 ****
--- 1,352 ----
+ /*-------------------------------------------------------------------------
+  *
+  * deparse.c
+  *		  query deparser for PostgreSQL
+  *
+  * Copyright (c) 2011, PostgreSQL Global Development Group
+  *
+  * IDENTIFICATION
+  *		  pgsql_fdw/deparse.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ #include "access/transam.h"
+ #include "foreign/foreign.h"
+ #include "lib/stringinfo.h"
+ #include "nodes/nodeFuncs.h"
+ #include "nodes/nodes.h"
+ #include "nodes/makefuncs.h"
+ #include "optimizer/clauses.h"
+ #include "optimizer/var.h"
+ #include "parser/parsetree.h"
+ #include "utils/builtins.h"
+ #include "utils/lsyscache.h"
+ 
+ #include "pgsql_fdw.h"
+ 
+ /*
+  * Context for walk-through the expression tree.
+  */
+ typedef struct foreign_executable_cxt
+ {
+ 	PlannerInfo	   *root;
+ 	RelOptInfo	   *foreignrel;
+ } foreign_executable_cxt;
+ 
+ static bool is_foreign_expr(PlannerInfo *root, RelOptInfo *baserel, Expr *expr);
+ static bool foreign_expr_walker(Node *node, foreign_executable_cxt *context);
+ static bool is_proc_remotely_executable(Oid procid);
+ 
+ /*
+  * Deparse query representation into SQL statement which suits for remote
+  * PostgreSQL server.  Also some of quals in WHERE clause will be pushed down
+  * If they are safe to be evaluated on the remote side.
+  */
+ char *
+ deparseSql(Oid relid, PlannerInfo *root, RelOptInfo *baserel)
+ {
+ 	StringInfoData	foreign_relname;
+ 	StringInfoData	sql;			/* builder for SQL statement */
+ 	bool		first;
+ 	AttrNumber	attr;
+ 	List	   *attr_used = NIL;	/* List of AttNumber used in the query */
+ 	const char *nspname = NULL;		/* plain namespace name */
+ 	const char *relname = NULL;		/* plain relation name */
+ 	const char *q_nspname;			/* quoted namespace name */
+ 	const char *q_relname;			/* quoted relation name */
+ 	List	   *foreign_expr = NIL;	/* list of Expr* evaluated on remote */
+ 	int			i;
+ 	List	   *rtable = NIL;
+ 	List	   *context = NIL;
+ 
+ 	initStringInfo(&sql);
+ 	initStringInfo(&foreign_relname);
+ 
+ 	/*
+ 	 * First of all, determine which qual can be pushed down.
+ 	 *
+ 	 * The expressions which satisfy is_foreign_expr() are deparsed into WHERE
+ 	 * clause of result SQL string, and they could be removed from PlanState
+ 	 * to avoid duplicate evaluation at ExecScan().
+ 	 *
+ 	 * We never change the quals in the Plan node, because this execution might
+ 	 * be for a PREPAREd statement, thus the quals in the Plan node might be
+ 	 * reused to construct another PlanState for subsequent EXECUTE statement.
+ 	 *
+ 	 * We do this before deparsing SELECT clause because attributes which are
+ 	 * not used in neither reltargetlist nor baserel->baserestrictinfo, quals
+ 	 * evaluated on local, can be replaced with literal "NULL" in the SELECT
+ 	 * clause to reduce overhead of tuple handling tuple and data transfer.
+ 	 */
+ 	if (baserel->baserestrictinfo != NIL)
+ 	{
+ 		ListCell   *lc;
+ 		List	   *local_qual = NIL;
+ 
+ 		foreach (lc, baserel->baserestrictinfo)
+ 		{
+ 			RestrictInfo   *ri = (RestrictInfo *) lfirst(lc);
+ 
+ 			/* Determine whether the qual can be pushed down or not. */
+ 			if (is_foreign_expr(root, baserel, ri->clause))
+ 				foreign_expr = lappend(foreign_expr, ri->clause);
+ 			else
+ 			{
+ 				List	   *attrs;
+ 
+ 				/*
+ 				 * We need to know which attributes are used in qual evaluated
+ 				 * on the local server, because they should be listed in the
+ 				 * SELECT clause of remote query.  We can ignore attributes
+ 				 * which are referenced only in ORDER BY/GROUP BY clause because
+ 				 * such attributes has already been kept in reltargetlist.
+ 				 */
+ 				attrs = pull_var_clause((Node *) ri->clause,
+ 										PVC_RECURSE_AGGREGATES,
+ 										PVC_RECURSE_PLACEHOLDERS);
+ 				attr_used = list_union(attr_used, attrs);
+ 
+ 				/*
+ 				 * Save the RestrictInfo to replace baserel->baserestrictinfo
+ 				 * afterward.
+ 				 */
+ 				local_qual = lappend(local_qual, ri);
+ 			}
+ 		}
+ 
+ 		/*
+ 		 * Remove quals which are going to evaluated on the foreign server to
+ 		 * avoid overhead of duplicated evaluation.
+ 		 */
+ 		baserel->baserestrictinfo = local_qual;
+ 	}
+ 
+ 	/*
+ 	 * Determine foreign relation's qualified name.  This is necessary for
+ 	 * FROM clause and SELECT clause.
+ 	 */
+ 	nspname = GetFdwOptionValue(relid, InvalidAttrNumber, "nspname");
+ 	if (nspname == NULL)
+ 		nspname = get_namespace_name(get_rel_namespace(relid));
+ 	q_nspname = quote_identifier(nspname);
+ 
+ 	relname = GetFdwOptionValue(relid, InvalidAttrNumber, "relname");
+ 	if (relname == NULL)
+ 		relname = get_rel_name(relid);
+ 	q_relname = quote_identifier(relname);
+ 
+ 	appendStringInfo(&foreign_relname, "%s.%s", q_nspname, q_relname);
+ 
+ 	/*
+ 	 * Create context for the deparse.
+ 	 * We need multi-relation context without PlanState, and alias of each
+ 	 * RangeTblEntry should be modified to be valid on remote side.
+ 	 * 
+ 	 * We skip first element of simple_rel_array.
+ 	 */
+ 	for (i = 1; i < root->simple_rel_array_size; i++)
+ 	{
+ 		RangeTblEntry *rte = copyObject(root->simple_rte_array[i]);
+ 		rtable = lappend(rtable, rte);
+ 	}
+ 	context = deparse_context_for_rtelist(rtable);
+ 
+ 	/*
+ 	 * deparse SELECT clause
+ 	 *
+ 	 * List attributes which are in either target list or local restriction.
+ 	 * Unused attributes are replace with literal "NULL" for optimization.
+ 	 */
+ 	appendStringInfo(&sql, "SELECT ");
+ 	attr_used = list_union(attr_used, baserel->reltargetlist);
+ 	first = true;
+ 	for (attr = 1; attr <= baserel->max_attr; attr++)
+ 	{
+ 		RangeTblEntry *rte = root->simple_rte_array[baserel->relid];
+ 		Var		   *var = NULL;
+ 		ListCell   *lc;
+ 
+ 		/* Ignore droppped attributes. */
+ 		if (get_rte_attribute_is_dropped(rte, attr))
+ 			continue;
+ 
+ 		if (!first)
+ 			appendStringInfo(&sql, ", ");
+ 		first = false;
+ 
+ 		/*
+ 		 * We use linear search here, but it wouldn't be problem since
+ 		 * attr_used seems to not become so large.
+ 		 */
+ 		foreach (lc, attr_used)
+ 		{
+ 			var = lfirst(lc);
+ 			if (var->varattno == attr)
+ 				break;
+ 			var = NULL;
+ 		}
+ 		if (var != NULL)
+ 			appendStringInfo(&sql, "%s",
+ 				deparse_expression((Node *) var, context, false, false));
+ 		else
+ 			appendStringInfo(&sql, "NULL");
+ 	}
+ 	appendStringInfoChar(&sql, ' ');
+ 
+ 	/*
+ 	 * deparse FROM clause
+ 	 */
+ 	appendStringInfo(&sql, "FROM %s", foreign_relname.data);
+ 
+ 	/*
+ 	 * deparse WHERE clause
+ 	 */
+ 	if (foreign_expr != NIL)
+ 	{
+ 		Node	   *node;
+ 
+ 		node = (Node *) make_ands_explicit(foreign_expr);
+ 		appendStringInfo(&sql, " WHERE %s ",
+ 			deparse_expression(node, context, false, false));
+ 		list_free(foreign_expr);
+ 		foreign_expr = NIL;
+ 	}
+ 
+ 	return sql.data;
+ }
+ 
+ /*
+  * Returns true if expr is safe to be evaluated on the foreign server.
+  */
+ static bool
+ is_foreign_expr(PlannerInfo *root, RelOptInfo *baserel, Expr *expr)
+ {
+ 	foreign_executable_cxt	context;
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 
+ 	/*
+ 	 * An expression which includes any mutable function can't be pushed down
+ 	 * because it's result is not stable.  For example, pushing now() down to
+ 	 * remote side would cause confusion from the clock offset.
+ 	 * If we have routine mapping infrastructure in future release, we will be
+ 	 * able to choose function to be pushed down in finer granularity.
+ 	 */
+ 	if (contain_mutable_functions((Node *) expr))
+ 		return false;
+ 
+ 	/*
+ 	 * Check that the expression consists of nodes which are known as safe to
+ 	 * be pushed down.
+ 	 */
+ 	if (foreign_expr_walker((Node *) expr, &context))
+ 		return false;
+ 
+ 	return true;
+ }
+ 
+ /*
+  * Return true if node includes any node which is not known as safe to be
+  * pushed down.
+  */
+ static bool
+ foreign_expr_walker(Node *node, foreign_executable_cxt *context)
+ {
+ 	if (node == NULL)
+ 		return false;
+ 
+ 	switch (nodeTag(node))
+ 	{
+ 		case T_Const:
+ 		case T_ArrayExpr:
+ 		case T_BoolExpr:
+ 		case T_NullTest:
+ 		case T_DistinctExpr:
+ 		case T_ScalarArrayOpExpr:
+ 			/*
+ 			 * These type of nodes are known as safe to be pushed down.
+ 			 * Of course the subtre of the node, if any, should be checked
+ 			 * continuously at the tail of this function.
+ 			 */
+ 			break;
+ 		case T_Param:
+ 			/*
+ 			 * Only external parameters can be pushed down.:
+ 			 */
+ 			{
+ 				if (((Param *) node)->paramkind != PARAM_EXTERN)
+ 					return true;
+ 			}
+ 			break;
+ 		case T_OpExpr:
+ 			/*
+ 			 * Operators which use non-immutable function can't be pushed down.
+ 			 */
+ 			{
+ 				OpExpr	   *oe = (OpExpr *) node;
+ 
+ 				if (!is_proc_remotely_executable(oe->opfuncid))
+ 					return true;
+ 
+ 				/* operands are checked later */
+ 			}
+ 			break;
+ 		case T_FuncExpr:
+ 			/*
+ 			 * Non-immutable functions can't be pushed down.
+ 			 */
+ 			{
+ 				FuncExpr   *fe = (FuncExpr *) node;
+ 
+ 				if (!is_proc_remotely_executable(fe->funcid))
+ 					return true;
+ 
+ 				/* operands are checked later */
+ 			}
+ 			break;
+ 		case T_Var:
+ 			/*
+ 			 * Var can be pushed down if it is in the foreign table.
+ 			 * XXX Var of other relation can be here?
+ 			 */
+ 			{
+ 				Var	   *var = (Var *) node;
+ 				foreign_executable_cxt *f_context;
+ 
+ 				f_context = (foreign_executable_cxt *) context;
+ 				if (var->varno != f_context->foreignrel->relid ||
+ 					var->varlevelsup != 0)
+ 					return true;
+ 			}
+ 			break;
+ 		default:
+ 			{
+ 				ereport(DEBUG3,
+ 						(errmsg("expression is too complex"),
+ 						 errdetail("%s", nodeToString(node))));
+ 				return true;
+ 			}
+ 			break;
+ 	}
+ 
+ 	return expression_tree_walker(node, foreign_expr_walker, context);
+ }
+ 
+ /*
+  * Return true if func is known as safe to be pushed down if all of the
+  * arguments are also known as safe.
+  */
+ static bool
+ is_proc_remotely_executable(Oid procid)
+ {
+ 	/*
+ 	 * User-defined procedures can't be pushed down.
+ 	 */
+ 	if (procid >= FirstNormalObjectId)
+ 		return false;
+ 
+ 	return true;
+ }
+ 
diff --git a/contrib/pgsql_fdw/expected/pgsql_fdw.out b/contrib/pgsql_fdw/expected/pgsql_fdw.out
index ...af72154 .
*** a/contrib/pgsql_fdw/expected/pgsql_fdw.out
--- b/contrib/pgsql_fdw/expected/pgsql_fdw.out
***************
*** 0 ****
--- 1,406 ----
+ -- ===================================================================
+ -- create FDW objects
+ -- ===================================================================
+ CREATE EXTENSION pgsql_fdw;
+ CREATE SERVER loopback1 FOREIGN DATA WRAPPER pgsql_fdw;
+ CREATE SERVER loopback2 FOREIGN DATA WRAPPER pgsql_fdw
+   OPTIONS (dbname 'contrib_regression');
+ CREATE USER MAPPING FOR public SERVER loopback1
+ 	OPTIONS (user 'value', password 'value');
+ CREATE USER MAPPING FOR public SERVER loopback2;
+ CREATE FOREIGN TABLE ft1 (
+ 	c1 int NOT NULL,
+ 	c2 int NOT NULL,
+ 	c3 text,
+ 	c4 timestamptz,
+ 	c5 timestamp
+ ) SERVER loopback2;
+ CREATE FOREIGN TABLE ft2 (
+ 	c1 int NOT NULL,
+ 	c2 int NOT NULL,
+ 	c3 text,
+ 	c4 timestamptz,
+ 	c5 timestamp
+ ) SERVER loopback2;
+ -- ===================================================================
+ -- create objects used through FDW
+ -- ===================================================================
+ CREATE SCHEMA "S 1";
+ CREATE TABLE "S 1"."T 1" (
+ 	c1 int NOT NULL,
+ 	c2 int NOT NULL,
+ 	c3 text,
+ 	c4 timestamptz,
+ 	c5 timestamp,
+ 	CONSTRAINT t1_pkey PRIMARY KEY (c1)
+ );
+ NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t1_pkey" for table "T 1"
+ CREATE TABLE "S 1"."T 2" (
+ 	c1 int NOT NULL,
+ 	c2 text,
+ 	CONSTRAINT t2_pkey PRIMARY KEY (c1)
+ );
+ NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t2_pkey" for table "T 2"
+ BEGIN;
+ TRUNCATE "S 1"."T 1";
+ INSERT INTO "S 1"."T 1"
+ 	SELECT id,
+ 	       id % 10,
+ 	       to_char(id, 'FM00000'),
+ 	       '1970-01-01'::timestamptz + ((id % 100) || ' days')::interval,
+ 	       '1970-01-01'::timestamp + ((id % 100) || ' days')::interval
+ 	FROM generate_series(1, 1000) id;
+ TRUNCATE "S 1"."T 2";
+ INSERT INTO "S 1"."T 2"
+ 	SELECT id,
+ 	       'AAA' || to_char(id, 'FM000')
+ 	FROM generate_series(1, 100) id;
+ COMMIT;
+ -- ===================================================================
+ -- tests for pgsql_fdw_validator
+ -- ===================================================================
+ ALTER FOREIGN DATA WRAPPER pgsql_fdw OPTIONS (host 'value');    -- ERRROR
+ ERROR:  invalid option "host"
+ HINT:  Valid options in this context are: 
+ -- requiressl, krbsrvname and gsslib are omitted because they depend on
+ -- configure option
+ ALTER SERVER loopback1 OPTIONS (
+ 	--authtype 'value',
+ 	service 'value',
+ 	connect_timeout 'value',
+ 	dbname 'value',
+ 	host 'value',
+ 	hostaddr 'value',
+ 	port 'value',
+ 	--client_encoding 'value',
+ 	--tty 'value',
+ 	options 'value',
+ 	application_name 'value',
+ 	--fallback_application_name 'value',
+ 	keepalives 'value',
+ 	keepalives_idle 'value',
+ 	keepalives_interval 'value',
+ 	-- requiressl 'value',
+ 	sslmode 'value',
+ 	sslcert 'value',
+ 	sslkey 'value',
+ 	sslrootcert 'value',
+ 	sslcrl 'value'
+ 	--requirepeer 'value',
+ 	-- krbsrvname 'value',
+ 	-- gsslib 'value',
+ 	--replication 'value'
+ );
+ ALTER SERVER loopback1 OPTIONS (user 'value');                  -- ERROR
+ ERROR:  invalid option "user"
+ HINT:  Valid options in this context are: service, connect_timeout, dbname, host, hostaddr, port, options, application_name, keepalives, keepalives_idle, keepalives_interval, keepalives_count, sslmode, sslcert, sslkey, sslrootcert, sslcrl, requirepeer, min_cursor_rows, fetch_count
+ ALTER SERVER loopback2 OPTIONS (ADD min_cursor_rows '0');
+ ALTER SERVER loopback2 OPTIONS (ADD fetch_count '2');
+ ALTER USER MAPPING FOR public SERVER loopback1
+ 	OPTIONS (DROP user, DROP password);
+ ALTER USER MAPPING FOR public SERVER loopback1
+ 	OPTIONS (host 'value');                                     -- ERROR
+ ERROR:  invalid option "host"
+ HINT:  Valid options in this context are: user, password
+ ALTER FOREIGN TABLE ft1 OPTIONS (nspname 'S 1', relname 'T 1');
+ ALTER FOREIGN TABLE ft2 OPTIONS (nspname 'S 1', relname 'T 1', min_cursor_rows '10', fetch_count '100');
+ ALTER FOREIGN TABLE ft1 OPTIONS (invalid 'value');              -- ERROR
+ ERROR:  invalid option "invalid"
+ HINT:  Valid options in this context are: nspname, relname, min_cursor_rows, fetch_count
+ ALTER FOREIGN TABLE ft1 OPTIONS (min_cursor_rows 'a');          -- ERROR
+ ERROR:  invalid value for min_cursor_rows: "a"
+ ALTER FOREIGN TABLE ft1 OPTIONS (min_cursor_rows '-1');         -- ERROR
+ ERROR:  invalid value for min_cursor_rows: "-1"
+ ALTER FOREIGN TABLE ft1 OPTIONS (fetch_count 'a');              -- ERROR
+ ERROR:  invalid value for fetch_count: "a"
+ ALTER FOREIGN TABLE ft1 OPTIONS (fetch_count '0');              -- ERROR
+ ERROR:  invalid value for fetch_count: "0"
+ ALTER FOREIGN TABLE ft1 OPTIONS (fetch_count '-1');             -- ERROR
+ ERROR:  invalid value for fetch_count: "-1"
+ \dew+
+                                          List of foreign-data wrappers
+    Name    |  Owner   |      Handler      |      Validator      | Access privileges | FDW Options | Description 
+ -----------+----------+-------------------+---------------------+-------------------+-------------+-------------
+  pgsql_fdw | postgres | pgsql_fdw_handler | pgsql_fdw_validator |                   |             | 
+ (1 row)
+ 
+ \des+
+                                                                                                                                                                                                 List of foreign servers
+    Name    |  Owner   | Foreign-data wrapper | Access privileges | Type | Version |                                                                                                                                                     FDW Options                                                                                                                                                      | Description 
+ -----------+----------+----------------------+-------------------+------+---------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------
+  loopback1 | postgres | pgsql_fdw            |                   |      |         | (service 'value', connect_timeout 'value', dbname 'value', host 'value', hostaddr 'value', port 'value', options 'value', application_name 'value', keepalives 'value', keepalives_idle 'value', keepalives_interval 'value', sslmode 'value', sslcert 'value', sslkey 'value', sslrootcert 'value', sslcrl 'value') | 
+  loopback2 | postgres | pgsql_fdw            |                   |      |         | (dbname 'contrib_regression', min_cursor_rows '0', fetch_count '2')                                                                                                                                                                                                                                                  | 
+ (2 rows)
+ 
+ \deu+
+         List of user mappings
+   Server   | User name | FDW Options 
+ -----------+-----------+-------------
+  loopback1 | public    | 
+  loopback2 | public    | 
+ (2 rows)
+ 
+ \det+
+                                                List of foreign tables
+  Schema | Table |  Server   |                               FDW Options                               | Description 
+ --------+-------+-----------+-------------------------------------------------------------------------+-------------
+  public | ft1   | loopback2 | (nspname 'S 1', relname 'T 1')                                          | 
+  public | ft2   | loopback2 | (nspname 'S 1', relname 'T 1', min_cursor_rows '10', fetch_count '100') | 
+ (2 rows)
+ 
+ -- ===================================================================
+ -- simple queries
+ -- ===================================================================
+ -- single table, with/without alias
+ EXPLAIN (VERBOSE, COSTS false) SELECT * FROM ft1 ORDER BY c3, c1 OFFSET 100 LIMIT 10;
+                               QUERY PLAN                              
+ ----------------------------------------------------------------------
+  Limit
+    Output: c1, c2, c3, c4, c5
+    ->  Sort
+          Output: c1, c2, c3, c4, c5
+          Sort Key: ft1.c3, ft1.c1
+          ->  Foreign Scan on public.ft1
+                Output: c1, c2, c3, c4, c5
+                Remote SQL: SELECT c1, c2, c3, c4, c5 FROM "S 1"."T 1"
+ (8 rows)
+ 
+ SELECT * FROM ft1 ORDER BY c3, c1 OFFSET 100 LIMIT 10;
+  c1  | c2 |  c3   |              c4              |            c5            
+ -----+----+-------+------------------------------+--------------------------
+  101 |  1 | 00101 | Fri Jan 02 00:00:00 1970 PST | Fri Jan 02 00:00:00 1970
+  102 |  2 | 00102 | Sat Jan 03 00:00:00 1970 PST | Sat Jan 03 00:00:00 1970
+  103 |  3 | 00103 | Sun Jan 04 00:00:00 1970 PST | Sun Jan 04 00:00:00 1970
+  104 |  4 | 00104 | Mon Jan 05 00:00:00 1970 PST | Mon Jan 05 00:00:00 1970
+  105 |  5 | 00105 | Tue Jan 06 00:00:00 1970 PST | Tue Jan 06 00:00:00 1970
+  106 |  6 | 00106 | Wed Jan 07 00:00:00 1970 PST | Wed Jan 07 00:00:00 1970
+  107 |  7 | 00107 | Thu Jan 08 00:00:00 1970 PST | Thu Jan 08 00:00:00 1970
+  108 |  8 | 00108 | Fri Jan 09 00:00:00 1970 PST | Fri Jan 09 00:00:00 1970
+  109 |  9 | 00109 | Sat Jan 10 00:00:00 1970 PST | Sat Jan 10 00:00:00 1970
+  110 |  0 | 00110 | Sun Jan 11 00:00:00 1970 PST | Sun Jan 11 00:00:00 1970
+ (10 rows)
+ 
+ EXPLAIN (VERBOSE, COSTS false) SELECT * FROM ft1 t1 ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
+                               QUERY PLAN                              
+ ----------------------------------------------------------------------
+  Limit
+    Output: c1, c2, c3, c4, c5
+    ->  Sort
+          Output: c1, c2, c3, c4, c5
+          Sort Key: t1.c3, t1.c1
+          ->  Foreign Scan on public.ft1 t1
+                Output: c1, c2, c3, c4, c5
+                Remote SQL: SELECT c1, c2, c3, c4, c5 FROM "S 1"."T 1"
+ (8 rows)
+ 
+ SELECT * FROM ft1 t1 ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
+  c1  | c2 |  c3   |              c4              |            c5            
+ -----+----+-------+------------------------------+--------------------------
+  101 |  1 | 00101 | Fri Jan 02 00:00:00 1970 PST | Fri Jan 02 00:00:00 1970
+  102 |  2 | 00102 | Sat Jan 03 00:00:00 1970 PST | Sat Jan 03 00:00:00 1970
+  103 |  3 | 00103 | Sun Jan 04 00:00:00 1970 PST | Sun Jan 04 00:00:00 1970
+  104 |  4 | 00104 | Mon Jan 05 00:00:00 1970 PST | Mon Jan 05 00:00:00 1970
+  105 |  5 | 00105 | Tue Jan 06 00:00:00 1970 PST | Tue Jan 06 00:00:00 1970
+  106 |  6 | 00106 | Wed Jan 07 00:00:00 1970 PST | Wed Jan 07 00:00:00 1970
+  107 |  7 | 00107 | Thu Jan 08 00:00:00 1970 PST | Thu Jan 08 00:00:00 1970
+  108 |  8 | 00108 | Fri Jan 09 00:00:00 1970 PST | Fri Jan 09 00:00:00 1970
+  109 |  9 | 00109 | Sat Jan 10 00:00:00 1970 PST | Sat Jan 10 00:00:00 1970
+  110 |  0 | 00110 | Sun Jan 11 00:00:00 1970 PST | Sun Jan 11 00:00:00 1970
+ (10 rows)
+ 
+ -- with WHERE clause
+ SELECT * FROM ft1 t1 WHERE t1.c1 = 101;
+  c1  | c2 |  c3   |              c4              |            c5            
+ -----+----+-------+------------------------------+--------------------------
+  101 |  1 | 00101 | Fri Jan 02 00:00:00 1970 PST | Fri Jan 02 00:00:00 1970
+ (1 row)
+ 
+ -- aggregate
+ SELECT COUNT(*) FROM ft1 t1;
+  count 
+ -------
+   1000
+ (1 row)
+ 
+ -- join two tables
+ SELECT t1.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
+  c1  
+ -----
+  101
+  102
+  103
+  104
+  105
+  106
+  107
+  108
+  109
+  110
+ (10 rows)
+ 
+ -- subquery
+ SELECT * FROM ft1 t1 WHERE t1.c3 IN (SELECT c3 FROM ft2 t2 WHERE c1 <= 10) ORDER BY c1;
+  c1 | c2 |  c3   |              c4              |            c5            
+ ----+----+-------+------------------------------+--------------------------
+   1 |  1 | 00001 | Fri Jan 02 00:00:00 1970 PST | Fri Jan 02 00:00:00 1970
+   2 |  2 | 00002 | Sat Jan 03 00:00:00 1970 PST | Sat Jan 03 00:00:00 1970
+   3 |  3 | 00003 | Sun Jan 04 00:00:00 1970 PST | Sun Jan 04 00:00:00 1970
+   4 |  4 | 00004 | Mon Jan 05 00:00:00 1970 PST | Mon Jan 05 00:00:00 1970
+   5 |  5 | 00005 | Tue Jan 06 00:00:00 1970 PST | Tue Jan 06 00:00:00 1970
+   6 |  6 | 00006 | Wed Jan 07 00:00:00 1970 PST | Wed Jan 07 00:00:00 1970
+   7 |  7 | 00007 | Thu Jan 08 00:00:00 1970 PST | Thu Jan 08 00:00:00 1970
+   8 |  8 | 00008 | Fri Jan 09 00:00:00 1970 PST | Fri Jan 09 00:00:00 1970
+   9 |  9 | 00009 | Sat Jan 10 00:00:00 1970 PST | Sat Jan 10 00:00:00 1970
+  10 |  0 | 00010 | Sun Jan 11 00:00:00 1970 PST | Sun Jan 11 00:00:00 1970
+ (10 rows)
+ 
+ -- subquery+MAX
+ SELECT * FROM ft1 t1 WHERE t1.c3 = (SELECT MAX(c3) FROM ft2 t2) ORDER BY c1;
+   c1  | c2 |  c3   |              c4              |            c5            
+ ------+----+-------+------------------------------+--------------------------
+  1000 |  0 | 01000 | Thu Jan 01 00:00:00 1970 PST | Thu Jan 01 00:00:00 1970
+ (1 row)
+ 
+ -- used in CTE
+ WITH t1 AS (SELECT * FROM ft1 WHERE c1 <= 10) SELECT t2.c1, t2.c2, t2.c3, t2.c4 FROM t1, ft2 t2 WHERE t1.c1 = t2.c1 ORDER BY t1.c1;
+  c1 | c2 |  c3   |              c4              
+ ----+----+-------+------------------------------
+   1 |  1 | 00001 | Fri Jan 02 00:00:00 1970 PST
+   2 |  2 | 00002 | Sat Jan 03 00:00:00 1970 PST
+   3 |  3 | 00003 | Sun Jan 04 00:00:00 1970 PST
+   4 |  4 | 00004 | Mon Jan 05 00:00:00 1970 PST
+   5 |  5 | 00005 | Tue Jan 06 00:00:00 1970 PST
+   6 |  6 | 00006 | Wed Jan 07 00:00:00 1970 PST
+   7 |  7 | 00007 | Thu Jan 08 00:00:00 1970 PST
+   8 |  8 | 00008 | Fri Jan 09 00:00:00 1970 PST
+   9 |  9 | 00009 | Sat Jan 10 00:00:00 1970 PST
+  10 |  0 | 00010 | Sun Jan 11 00:00:00 1970 PST
+ (10 rows)
+ 
+ -- fixed values
+ SELECT 'fixed', NULL FROM ft1 t1 WHERE c1 = 1;
+  ?column? | ?column? 
+ ----------+----------
+  fixed    | 
+ (1 row)
+ 
+ -- ===================================================================
+ -- parameterized queries
+ -- ===================================================================
+ -- simple join
+ PREPARE st1(int, int) AS SELECT t1.c3, t2.c3 FROM ft1 t1, ft2 t2 WHERE t1.c1 = $1 AND t2.c1 = $2;
+ EXPLAIN (COSTS false) EXECUTE st1(1, 2);
+                                        QUERY PLAN                                       
+ ----------------------------------------------------------------------------------------
+  Nested Loop
+    ->  Foreign Scan on ft1 t1
+          Remote SQL: SELECT NULL, NULL, c3, NULL, NULL FROM "S 1"."T 1" WHERE (c1 = 1) 
+    ->  Foreign Scan on ft2 t2
+          Remote SQL: SELECT NULL, NULL, c3, NULL, NULL FROM "S 1"."T 1" WHERE (c1 = 2) 
+ (5 rows)
+ 
+ EXECUTE st1(1, 1);
+   c3   |  c3   
+ -------+-------
+  00001 | 00001
+ (1 row)
+ 
+ EXECUTE st1(101, 101);
+   c3   |  c3   
+ -------+-------
+  00101 | 00101
+ (1 row)
+ 
+ -- subquery using stable function (can't be pushed down)
+ PREPARE st2(int) AS SELECT * FROM ft1 t1 WHERE t1.c1 < $2 AND t1.c3 IN (SELECT c3 FROM ft2 t2 WHERE c1 > $1 AND EXTRACT(dow FROM c4) = 6) ORDER BY c1;
+ EXPLAIN (COSTS false) EXECUTE st2(10, 20);
+                                                                    QUERY PLAN                                                                   
+ ------------------------------------------------------------------------------------------------------------------------------------------------
+  Sort
+    Sort Key: t1.c1
+    ->  Nested Loop
+          Join Filter: (t1.c3 = t2.c3)
+          ->  HashAggregate
+                ->  Foreign Scan on ft2 t2
+                      Filter: (date_part('dow'::text, c4) = 6::double precision)
+                      Remote SQL: DECLARE pgsql_fdw_cursor_6 SCROLL CURSOR FOR SELECT NULL, NULL, c3, c4, NULL FROM "S 1"."T 1" WHERE (c1 > 10) 
+          ->  Foreign Scan on ft1 t1
+                Remote SQL: SELECT c1, c2, c3, c4, c5 FROM "S 1"."T 1" WHERE (c1 < 20) 
+ (10 rows)
+ 
+ EXECUTE st2(10, 20);
+  c1 | c2 |  c3   |              c4              |            c5            
+ ----+----+-------+------------------------------+--------------------------
+  16 |  6 | 00016 | Sat Jan 17 00:00:00 1970 PST | Sat Jan 17 00:00:00 1970
+ (1 row)
+ 
+ EXECUTE st1(101, 101);
+   c3   |  c3   
+ -------+-------
+  00101 | 00101
+ (1 row)
+ 
+ -- subquery using immutable function (can be pushed down)
+ PREPARE st3(int) AS SELECT * FROM ft1 t1 WHERE t1.c1 < $2 AND t1.c3 IN (SELECT c3 FROM ft2 t2 WHERE c1 > $1 AND EXTRACT(dow FROM c5) = 6) ORDER BY c1;
+ EXPLAIN (COSTS false) EXECUTE st3(10, 20);
+                                                                              QUERY PLAN                                                                             
+ --------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Sort
+    Sort Key: t1.c1
+    ->  Hash Join
+          Hash Cond: (t1.c3 = t2.c3)
+          ->  Foreign Scan on ft1 t1
+                Remote SQL: SELECT c1, c2, c3, c4, c5 FROM "S 1"."T 1" WHERE (c1 < 20) 
+          ->  Hash
+                ->  HashAggregate
+                      ->  Foreign Scan on ft2 t2
+                            Remote SQL: SELECT NULL, NULL, c3, NULL, NULL FROM "S 1"."T 1" WHERE ((c1 > 10) AND (date_part('dow'::text, c5) = 6::double precision)) 
+ (10 rows)
+ 
+ EXECUTE st3(10, 20);
+  c1 | c2 |  c3   |              c4              |            c5            
+ ----+----+-------+------------------------------+--------------------------
+  16 |  6 | 00016 | Sat Jan 17 00:00:00 1970 PST | Sat Jan 17 00:00:00 1970
+ (1 row)
+ 
+ EXECUTE st3(20, 30);
+  c1 | c2 |  c3   |              c4              |            c5            
+ ----+----+-------+------------------------------+--------------------------
+  23 |  3 | 00023 | Sat Jan 24 00:00:00 1970 PST | Sat Jan 24 00:00:00 1970
+ (1 row)
+ 
+ -- cleanup
+ DEALLOCATE st1;
+ DEALLOCATE st2;
+ DEALLOCATE st3;
+ -- ===================================================================
+ -- connection management
+ -- ===================================================================
+ SELECT srvname, usename FROM pgsql_fdw_connections;
+   srvname  | usename  
+ -----------+----------
+  loopback2 | postgres
+ (1 row)
+ 
+ SELECT pgsql_fdw_disconnect(srvid, usesysid) FROM pgsql_fdw_get_connections();
+  pgsql_fdw_disconnect 
+ ----------------------
+  OK
+ (1 row)
+ 
+ SELECT srvname, usename FROM pgsql_fdw_connections;
+  srvname | usename 
+ ---------+---------
+ (0 rows)
+ 
+ -- ===================================================================
+ -- cleanup
+ -- ===================================================================
+ DROP EXTENSION pgsql_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 server loopback2
+ drop cascades to user mapping for public
+ drop cascades to foreign table ft1
+ drop cascades to foreign table ft2
diff --git a/contrib/pgsql_fdw/option.c b/contrib/pgsql_fdw/option.c
index ...610daad .
*** a/contrib/pgsql_fdw/option.c
--- b/contrib/pgsql_fdw/option.c
***************
*** 0 ****
--- 1,262 ----
+ /*-------------------------------------------------------------------------
+  *
+  * option.c
+  *		  FDW option handling
+  *
+  * Copyright (c) 2011, PostgreSQL Global Development Group
+  *
+  * IDENTIFICATION
+  *		  pgsql_fdw/option.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ #include "access/reloptions.h"
+ #include "catalog/pg_foreign_data_wrapper.h"
+ #include "catalog/pg_foreign_server.h"
+ #include "catalog/pg_foreign_table.h"
+ #include "catalog/pg_user_mapping.h"
+ #include "fmgr.h"
+ #include "foreign/foreign.h"
+ #include "lib/stringinfo.h"
+ #include "miscadmin.h"
+ 
+ #include "pgsql_fdw.h"
+ 
+ /*
+  * SQL functions
+  */
+ extern Datum pgsql_fdw_validator(PG_FUNCTION_ARGS);
+ PG_FUNCTION_INFO_V1(pgsql_fdw_validator);
+ 
+ /*
+  * Describes the valid options for objects that use this wrapper.
+  */
+ typedef struct PgsqlFdwOption
+ {
+ 	const char *optname;
+ 	Oid			optcontext;		/* Oid of catalog in which options may appear */
+ 	bool		is_libpq_opt;	/* true if it's used in libpq */
+ } PgsqlFdwOption;
+ 
+ /*
+  * Valid options for pgsql_fdw.
+  */
+ static PgsqlFdwOption valid_options[] = {
+ 
+ 	/*
+ 	 * Options for libpq connection.
+ 	 * Note: This list should be updated along with PQconninfoOptions in
+ 	 * interfaces/libpq/fe-connect.c, so the order is kept as is.
+ 	 *
+ 	 * Some useless libpq connection options are not accepted by pgsql_fdw:
+ 	 *   authtype: no longer used
+ 	 *   client_encoding: set to local database encoding automatically
+ 	 *   tty: no longer used
+ 	 *   fallback_application_name: fixed to "pgsql_fdw"
+ 	 *   replication: pgsql_fdw never be replication client
+ 	 */
+ 	{"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},
+ 	{"options", ForeignServerRelationId, true},
+ 	{"application_name", ForeignServerRelationId, true},
+ 	{"keepalives", ForeignServerRelationId, true},
+ 	{"keepalives_idle", ForeignServerRelationId, true},
+ 	{"keepalives_interval", ForeignServerRelationId, true},
+ 	{"keepalives_count", ForeignServerRelationId, true},
+ #ifdef USE_SSL
+ 	{"requiressl", ForeignServerRelationId, true},
+ #endif
+ 	{"sslmode", ForeignServerRelationId, true},
+ 	{"sslcert", ForeignServerRelationId, true},
+ 	{"sslkey", ForeignServerRelationId, true},
+ 	{"sslrootcert", ForeignServerRelationId, true},
+ 	{"sslcrl", ForeignServerRelationId, true},
+ 	{"requirepeer", ForeignServerRelationId, true},
+ #if defined(KRB5) || defined(ENABLE_GSS) || defined(ENABLE_SSPI)
+ 	{"krbsrvname", ForeignServerRelationId, true},
+ #endif
+ #if defined(ENABLE_GSS) && defined(ENABLE_SSPI)
+ 	{"gsslib", ForeignServerRelationId, true},
+ #endif
+ 
+ 	/*
+ 	 * Options for translation of object names.
+ 	 * Note: Per-column options are not supported in 9.1, so we can't translate
+ 	 * column name.
+ 	 */
+ 	{"nspname", ForeignTableRelationId, false},
+ 	{"relname", ForeignTableRelationId, false},
+ 
+ 	/*
+ 	 * Options for cursor behavior.
+ 	 * These options can be overridden by smaller objects.
+ 	 */
+ 	{"min_cursor_rows", ForeignTableRelationId, false},
+ 	{"min_cursor_rows", ForeignServerRelationId, false},
+ 	{"fetch_count", ForeignTableRelationId, false},
+ 	{"fetch_count", ForeignServerRelationId, false},
+ 
+ 	/* Sentinel */
+ 	{NULL, InvalidOid, false}
+ };
+ 
+ /*
+  * Helper functions
+  */
+ static bool is_valid_option(const char *optname, Oid context);
+ 
+ /*
+  * Validate the generic options given to a FOREIGN DATA WRAPPER, SERVER,
+  * USER MAPPING or FOREIGN TABLE that uses pgsql_fdw.
+  *
+  * Raise an ERROR if the option or its value is considered invalid.
+  */
+ Datum
+ pgsql_fdw_validator(PG_FUNCTION_ARGS)
+ {
+ 	List	   *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
+ 	Oid			catalog = PG_GETARG_OID(1);
+ 	ListCell   *cell;
+ 
+ 	/*
+ 	 * Check that only options supported by pgsql_fdw, and allowed for the
+ 	 * current object type, are given.
+ 	 */
+ 	foreach(cell, options_list)
+ 	{
+ 		DefElem    *def = (DefElem *) lfirst(cell);
+ 
+ 		if (!is_valid_option(def->defname, catalog))
+ 		{
+ 			PgsqlFdwOption *opt;
+ 			StringInfoData buf;
+ 
+ 			/*
+ 			 * Unknown option specified, complain about it. Provide a hint
+ 			 * with list of valid options for the object.
+ 			 */
+ 			initStringInfo(&buf);
+ 			for (opt = valid_options; opt->optname; opt++)
+ 			{
+ 				if (catalog == opt->optcontext)
+ 					appendStringInfo(&buf, "%s%s", (buf.len > 0) ? ", " : "",
+ 									 opt->optname);
+ 			}
+ 
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+ 					 errmsg("invalid option \"%s\"", def->defname),
+ 					 errhint("Valid options in this context are: %s",
+ 							 buf.data)));
+ 		}
+ 
+ 		/* min_cursor_rows be zero or positive digit number. */
+ 		if (strcmp(def->defname, "min_cursor_rows") == 0)
+ 		{
+ 			long value;
+ 			char *p = NULL;
+ 
+ 			value = strtol(strVal(def->arg), &p, 10);
+ 			if (*p != '\0' || value < 0)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_FDW_INVALID_ATTRIBUTE_VALUE),
+ 						 errmsg("invalid value for %s: \"%s\"",
+ 								def->defname, strVal(def->arg))));
+ 		}
+ 
+ 		/* fetch_count be positive digit number. */
+ 		if (strcmp(def->defname, "fetch_count") == 0)
+ 		{
+ 			long value;
+ 			char *p = NULL;
+ 
+ 			value = strtol(strVal(def->arg), &p, 10);
+ 			if (*p != '\0' || value < 1)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_FDW_INVALID_ATTRIBUTE_VALUE),
+ 						 errmsg("invalid value for %s: \"%s\"",
+ 								def->defname, strVal(def->arg))));
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * We don't care option-specific limitation here; they will be validated at
+ 	 * the execution time. 
+ 	 */
+ 
+ 	PG_RETURN_VOID();
+ }
+ 
+ /*
+  * Check if the provided option is one of the valid options.
+  * context is the Oid of the catalog holding the object the option is for.
+  */
+ static bool
+ is_valid_option(const char *optname, Oid context)
+ {
+ 	PgsqlFdwOption *opt;
+ 
+ 	/*
+ 	 * If the option was other than libpq option, look up option table and
+ 	 * determine valid context.
+ 	 */
+ 	for (opt = valid_options; opt->optname; opt++)
+ 	{
+ 		if (context == opt->optcontext && strcmp(opt->optname, optname) == 0)
+ 			return true;
+ 	}
+ 	return false;
+ }
+ 
+ /*
+  * Check if the provided option is one of the valid options.
+  * context is the Oid of the catalog holding the object the option is for.
+  */
+ static bool
+ is_libpq_option(const char *optname)
+ {
+ 	PgsqlFdwOption *opt;
+ 
+ 	/*
+ 	 * If the option was other than libpq option, look up option table and
+ 	 * determine valid context.
+ 	 */
+ 	for (opt = valid_options; opt->optname; opt++)
+ 	{
+ 		if (strcmp(opt->optname, optname) == 0 && opt->is_libpq_opt)
+ 			return true;
+ 	}
+ 	return false;
+ }
+ 
+ /*
+  * Generate key-value arrays which includes only libpq options from the list
+  * which contains any kind of options.
+  */
+ int
+ ExtractConnectionOptions(List *defelems, const char **keywords, const char **values)
+ {
+ 	ListCell *lc;
+ 	int i;
+ 
+ 	i = 0;
+ 	foreach(lc, defelems)
+ 	{
+ 		DefElem *d = (DefElem *) lfirst(lc);
+ 		if (is_libpq_option(d->defname))
+ 		{
+ 			keywords[i] = d->defname;
+ 			values[i] = strVal(d->arg);
+ 			i++;
+ 		}
+ 	}
+ 	return i;
+ }
diff --git a/contrib/pgsql_fdw/pgsql_fdw--1.0.sql b/contrib/pgsql_fdw/pgsql_fdw--1.0.sql
index ...87dfa29 .
*** a/contrib/pgsql_fdw/pgsql_fdw--1.0.sql
--- b/contrib/pgsql_fdw/pgsql_fdw--1.0.sql
***************
*** 0 ****
--- 1,36 ----
+ /* contrib/pgsql_fdw/pgsql_fdw--1.0.sql */
+ 
+ CREATE FUNCTION pgsql_fdw_handler()
+ RETURNS fdw_handler
+ AS 'MODULE_PATHNAME'
+ LANGUAGE C STRICT;
+ 
+ CREATE FUNCTION pgsql_fdw_validator(text[], oid)
+ RETURNS void
+ AS 'MODULE_PATHNAME'
+ LANGUAGE C STRICT;
+ 
+ CREATE FOREIGN DATA WRAPPER pgsql_fdw
+   HANDLER pgsql_fdw_handler
+   VALIDATOR pgsql_fdw_validator;
+ 
+ /* connection management functions and view */
+ CREATE FUNCTION pgsql_fdw_get_connections(out srvid oid, out usesysid oid)
+ RETURNS SETOF record
+ AS 'MODULE_PATHNAME'
+ LANGUAGE C STRICT;
+ 
+ CREATE FUNCTION pgsql_fdw_disconnect(oid, oid)
+ RETURNS text
+ AS 'MODULE_PATHNAME'
+ LANGUAGE C STRICT;
+ 
+ CREATE VIEW pgsql_fdw_connections AS
+ SELECT c.srvid srvid,
+        s.srvname srvname,
+        c.usesysid usesysid,
+        pg_get_userbyid(c.usesysid) usename
+   FROM pgsql_fdw_get_connections() c
+            JOIN pg_catalog.pg_foreign_server s ON (s.oid = c.srvid);
+ GRANT SELECT ON pgsql_fdw_connections TO public;
+ 
diff --git a/contrib/pgsql_fdw/pgsql_fdw.c b/contrib/pgsql_fdw/pgsql_fdw.c
index ...614916c .
*** a/contrib/pgsql_fdw/pgsql_fdw.c
--- b/contrib/pgsql_fdw/pgsql_fdw.c
***************
*** 0 ****
--- 1,882 ----
+ /*-------------------------------------------------------------------------
+  *
+  * pgsql_fdw.c
+  *		  foreign-data wrapper for remote PostgreSQL servers.
+  *
+  * Copyright (c) 2011, PostgreSQL Global Development Group
+  *
+  * IDENTIFICATION
+  *		  pgsql_fdw/pgsql_fdw.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ #include "fmgr.h"
+ 
+ #include "catalog/pg_foreign_server.h"
+ #include "catalog/pg_foreign_table.h"
+ #include "commands/explain.h"
+ #include "foreign/fdwapi.h"
+ #include "funcapi.h"
+ #include "miscadmin.h"
+ #include "optimizer/cost.h"
+ #include "utils/lsyscache.h"
+ #include "utils/memutils.h"
+ #include "utils/rel.h"
+ 
+ #include "pgsql_fdw.h"
+ #include "connection.h"
+ 
+ PG_MODULE_MAGIC;
+ 
+ /*
+  * Default fetch count for cursor mode.  This can be override by fetch_count
+  * FDW option.
+  */
+ #define DEFAULT_FETCH_COUNT			1000
+ 
+ /*
+  * Default minimum estimated row count for cursor mode.  This can be override
+  * by min_cursor_rows FDW option.
+  * */
+ #define DEFAULT_MIN_CURSOR_ROWS		1000
+ 
+ /*
+  * Cost to establish a connection.
+  * XXX: should be configurable per server?
+  */
+ #define CONNECTION_COSTS			100.0
+ 
+ /*
+  * Cost to transfer 1 byte from remote server.
+  * XXX: should be configurable per server?
+  */
+ #define TRANSFER_COSTS_PER_BYTE		0.001
+ 
+ /*
+  * Cursors which are used together in a local query require different name, so
+  * we use simple incremental name for that purpose.  We don't care wrap around
+  * of cursor_id because it's hard to imagine that 2^32 cursors are used in a
+  * query.
+  */
+ #define	CURSOR_NAME_FORMAT		"pgsql_fdw_cursor_%u"
+ static uint32 cursor_id = 0;
+ 
+ /*
+  * Index of FDW-private items stored in FdwPlan.
+  */
+ enum FdwPrivateIndex {
+ 	FdwPrivateSelectSql,
+ 
+ 	/* Items for cursor mode */
+ 	FdwPrivateDeclareSql,
+ 	FdwPrivateFetchSql,
+ 	FdwPrivateResetSql,
+ 	FdwPrivateCloseSql,
+ 
+ 	/* # of elements stored in the list fdw_private */
+ 	FdwPrivateNum,
+ };
+ 
+ /*
+  * This macro can be used in the executor to determine whether the scan is
+  * using CURSOR or not.
+  */
+ #define USE_CURSOR(fdwplan)	\
+ 	(list_length((fdwplan)->fdw_private) > FdwPrivateDeclareSql)
+ 
+ /*
+  * Describes an execution state of a foreign scan against a foreign table
+  * using pgsql_fdw. 
+  */
+ typedef struct PgsqlFdwExecutionState
+ {
+ 	FdwPlan	   *fdwplan;		/* FDW-specific planning information */
+ 	PGconn	   *conn;			/* connection for the scan */
+ 
+ 	Oid		   *param_types;	/* type array of external parameter */
+ 	const char **param_values;	/* value array of external parameter */
+ 
+ 	int			attnum;			/* # of non-dropped attribute */
+ 	char	  **col_values;		/* column value buffer */
+ 	AttInMetadata *attinmeta;	/* attribute metadata */
+ 
+ 	Tuplestorestate *tuples;	/* result of the scan, partial in cursor mode */
+ 	bool		cursor_opened;	/* true if cursor is opened */
+ } PgsqlFdwExecutionState;
+ 
+ /*
+  * SQL functions
+  */
+ extern Datum pgsql_fdw_handler(PG_FUNCTION_ARGS);
+ PG_FUNCTION_INFO_V1(pgsql_fdw_handler);
+ 
+ /*
+  * FDW callback routines
+  */
+ static FdwPlan *pgsqlPlanForeignScan(Oid foreigntableid,
+ 									 PlannerInfo *root,
+ 									 RelOptInfo *baserel);
+ static void pgsqlExplainForeignScan(ForeignScanState *node, ExplainState *es);
+ static void pgsqlBeginForeignScan(ForeignScanState *node, int eflags);
+ static TupleTableSlot *pgsqlIterateForeignScan(ForeignScanState *node);
+ static void pgsqlReScanForeignScan(ForeignScanState *node);
+ static void pgsqlEndForeignScan(ForeignScanState *node);
+ 
+ /*
+  * Helper functions
+  */
+ static void estimate_costs(PlannerInfo *root,
+ 						   RelOptInfo *baserel,
+ 						   const char *sql,
+ 						   Oid serverid,
+ 						   Cost *startup_cost,
+ 						   Cost *total_cost);
+ static void execute_query(ForeignScanState *node);
+ static PGresult *fetch_result(ForeignScanState *node);
+ static void store_result(ForeignScanState *node, PGresult *res);
+ 
+ /*
+  * Foreign-data wrapper handler function: return a struct with pointers
+  * to my callback routines.
+  */
+ Datum
+ pgsql_fdw_handler(PG_FUNCTION_ARGS)
+ {
+ 	FdwRoutine *fdwroutine = makeNode(FdwRoutine);
+ 
+ 	fdwroutine->PlanForeignScan = pgsqlPlanForeignScan;
+ 	fdwroutine->ExplainForeignScan = pgsqlExplainForeignScan;
+ 	fdwroutine->BeginForeignScan = pgsqlBeginForeignScan;
+ 	fdwroutine->IterateForeignScan = pgsqlIterateForeignScan;
+ 	fdwroutine->ReScanForeignScan = pgsqlReScanForeignScan;
+ 	fdwroutine->EndForeignScan = pgsqlEndForeignScan;
+ 
+ 	PG_RETURN_POINTER(fdwroutine);
+ }
+ 
+ /*
+  * pgsqlPlanForeignScan
+  *		Create a FdwPlan for a scan on the foreign table
+  */
+ static FdwPlan *
+ pgsqlPlanForeignScan(Oid foreigntableid,
+ 					PlannerInfo *root,
+ 					RelOptInfo *baserel)
+ {
+ 	char	   *sql;
+ 	FdwPlan	   *fdwplan;
+ 	List	   *fdw_private = NIL;
+ 	const char *min_cursor_rows_str;
+ 	int	min_cursor_rows = DEFAULT_MIN_CURSOR_ROWS;
+ 	ForeignTable   *table;
+ 	ForeignServer  *server;
+ 
+ 	/* Construct FdwPlan with cost estimates */
+ 	fdwplan = makeNode(FdwPlan);
+ 	sql = deparseSql(foreigntableid, root, baserel);
+ 	table = GetForeignTable(foreigntableid);
+ 	server = GetForeignServer(table->serverid);
+ 	estimate_costs(root, baserel, sql, server->serverid,
+ 				   &fdwplan->startup_cost, &fdwplan->total_cost);
+ 
+ 	/*
+ 	 * Store plain SELECT statement in private area of FdwPlan.  This will be
+ 	 * used for executing remote query and explaining scan.
+ 	 */
+ 	fdw_private = list_make1(makeString(sql));
+ 
+ 	/*
+ 	 * We use SQL-level cursor when the result seems to be large, to limit
+ 	 * memory usage for the result set. Exceptionally we use simple SELECT if
+ 	 * min_cursor_rows is set to 0.
+ 	 */
+ 	min_cursor_rows_str = GetFdwOptionValue(foreigntableid,
+ 											InvalidAttrNumber,
+ 											"min_cursor_rows");
+ 	if (min_cursor_rows_str != NULL)
+ 		min_cursor_rows = strtol(min_cursor_rows_str, NULL, 10);
+ 
+ 	if (min_cursor_rows != 0 && baserel->rows >= min_cursor_rows)
+ 	{
+ 		char			name[128];	/* must be larger than format + 10 */
+ 		StringInfoData	cursor;
+ 		const char	   *fetch_count_str;
+ 		int				fetch_count = DEFAULT_FETCH_COUNT;
+ 
+ 		/* Use specified fetch_count instead of default value, if any. */
+ 		fetch_count_str = GetFdwOptionValue(foreigntableid,
+ 											InvalidAttrNumber,
+ 											"fetch_count");
+ 		if (fetch_count_str != NULL)
+ 			fetch_count = strtol(fetch_count_str, NULL, 10);
+ 		elog(DEBUG1,
+ 			 "relid=%u fetch_count=%d",
+ 			 foreigntableid,
+ 			 fetch_count);
+ 
+ 		/* We store some more information in FdwPlan to pass them beyond the
+ 		 * boundary between planner and executor.  Finally FdwPlan using cursor
+ 		 * would hold items below:
+ 		 *
+ 		 * 1) plain SELECT statement (already added above)
+ 		 * 2) SQL statement used to declare cursor
+ 		 * 3) SQL statement used to fetch rows from cursor
+ 		 * 4) SQL statement used to reset cursor 
+ 		 * 5) SQL statement used to close cursor
+ 		 *
+ 		 * These items are indexed with the enum FdwPrivateIndex, so an item
+ 		 * can be accessed directly via list_nth().  For example of FETCH
+ 		 * statement:
+ 		 *      list_nth(fdw_private, FdwPrivateFetchSql)
+ 		 */
+ 
+ 		/* Construct cursor name from sequential value */
+ 		sprintf(name, CURSOR_NAME_FORMAT, cursor_id++);
+ 
+ 		/* Construct statement to declare cursor */
+ 		initStringInfo(&cursor);
+ 		appendStringInfo(&cursor, "DECLARE %s SCROLL CURSOR FOR %s", name, sql);
+ 		fdw_private = lappend(fdw_private, makeString(cursor.data));
+ 
+ 		/* Construct statement to fetch rows from cursor */
+ 		initStringInfo(&cursor);
+ 		appendStringInfo(&cursor, "FETCH %d FROM %s", fetch_count, name);
+ 		fdw_private = lappend(fdw_private, makeString(cursor.data));
+ 
+ 		/* Construct statement to reset cursor */
+ 		initStringInfo(&cursor);
+ 		appendStringInfo(&cursor, "MOVE ABSOLUTE 0 FROM %s", name);
+ 		fdw_private = lappend(fdw_private, makeString(cursor.data));
+ 
+ 		/* Construct statement to close cursor */
+ 		initStringInfo(&cursor);
+ 		appendStringInfo(&cursor, "CLOSE %s", name);
+ 		fdw_private = lappend(fdw_private, makeString(cursor.data));
+ 	}
+ 
+ 	/* Store FDW private information into FdwPlan */
+ 	fdwplan->fdw_private = fdw_private;
+ 
+ 	return fdwplan;
+ }
+ 
+ /*
+  * pgsqlExplainForeignScan
+  *		Produce extra output for EXPLAIN
+  */
+ static void
+ pgsqlExplainForeignScan(ForeignScanState *node, ExplainState *es)
+ {
+ 	FdwPlan	   *fdwplan;
+ 	char	   *sql;
+ 
+ 	fdwplan = ((ForeignScan *) node->ss.ps.plan)->fdwplan;
+ 	if (USE_CURSOR(fdwplan))
+ 		sql = strVal(list_nth(fdwplan->fdw_private, FdwPrivateDeclareSql));
+ 	else
+ 		sql = strVal(list_nth(fdwplan->fdw_private, FdwPrivateSelectSql));
+ 	ExplainPropertyText("Remote SQL", sql, es);
+ }
+ 
+ /*
+  * pgsqlBeginForeignScan
+  *		Initiate access to a foreign PostgreSQL table.
+  */
+ static void
+ pgsqlBeginForeignScan(ForeignScanState *node, int eflags)
+ {
+ 	PgsqlFdwExecutionState *festate;
+ 	PGconn		   *conn;
+ 	Oid				relid;
+ 	ForeignTable   *table;
+ 	ForeignServer  *server;
+ 	UserMapping	   *user;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 
+ 	/*
+ 	 * Do nothing in EXPLAIN (no ANALYZE) case.  node->fdw_state stays NULL.
+ 	 */
+ 	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
+ 		return;
+ 
+ 	/*
+ 	 * Save state in node->fdw_state.
+ 	 */
+ 	festate = (PgsqlFdwExecutionState *) palloc(sizeof(PgsqlFdwExecutionState));
+ 	festate->fdwplan = ((ForeignScan *) node->ss.ps.plan)->fdwplan;
+ 
+ 	/*
+ 	 * Get connection to the foreign server.  Connection manager would
+ 	 * establish new connection if necessary.
+ 	 */
+ 	relid = RelationGetRelid(node->ss.ss_currentRelation);
+ 	table = GetForeignTable(relid);
+ 	server = GetForeignServer(table->serverid);
+ 	user = GetUserMapping(GetOuterUserId(), server->serverid);
+ 	conn = GetConnection(server, user);
+ 	festate->conn = conn;
+ 
+ 	/* Result will be filled in first Iterate call. */
+ 	festate->tuples = NULL;
+ 	festate->cursor_opened = false;
+ 
+ 	/* Allocate buffers for column values. */
+ 	{
+ 		TupleDesc	tupdesc = slot->tts_tupleDescriptor;
+ 		festate->col_values = palloc(sizeof(char *) * tupdesc->natts);
+ 		festate->attinmeta = TupleDescGetAttInMetadata(tupdesc);
+ 	}
+ 
+ 	/* Allocate buffers for query parameters. */
+ 	{
+ 		ParamListInfo	params = node->ss.ps.state->es_param_list_info;
+ 		int				numParams = params ? params->numParams : 0;
+ 
+ 		if (numParams > 0)
+ 		{
+ 			festate->param_types = palloc0(sizeof(Oid) * numParams);
+ 			festate->param_values = palloc0(sizeof(char *) * numParams);
+ 		}
+ 		else
+ 		{
+ 			festate->param_types = NULL;
+ 			festate->param_values = NULL;
+ 		}
+ 	}
+ 
+ 
+ 	/* Store FDW-specific state into ForeignScanState */
+ 	node->fdw_state = (void *) festate;
+ 
+ 	return;
+ }
+ 
+ /*
+  * pgsqlIterateForeignScan
+  *		Retrieve next row from the result set, or clear tuple slot to indicate
+  *		EOF.
+  *
+  *		Note that using per-query context when retrieving tuples from
+  *		tuplestore to ensure that returned tuples can survive until next
+  *		iteration because the tuple is released implicitly via ExecClearTuple.
+  *		Retrieving a tuple from tuplestore in CurrentMemoryContext (it's a
+  *		per-tuple context), ExecClearTuple will free dangling pointer.
+  */
+ static TupleTableSlot *
+ pgsqlIterateForeignScan(ForeignScanState *node)
+ {
+ 	PgsqlFdwExecutionState *festate;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 	PGresult	   *res;
+ 	MemoryContext	oldcontext = CurrentMemoryContext;
+ 
+ 	festate = (PgsqlFdwExecutionState *) node->fdw_state;
+ 
+ 
+ 	/*
+ 	 * If this is the first call after Begin, we need to execute remote query.
+ 	 * If the query needs cursor, we declare a cursor at first call and fetch
+ 	 * from it in later calls.
+ 	 */
+ 	if (festate->tuples == NULL && !festate->cursor_opened)
+ 		execute_query(node);
+ 
+ 	/*
+ 	 * If enough tuples are left in tuplestore, just return next tuple from it.
+ 	 */
+ 	MemoryContextSwitchTo(node->ss.ps.state->es_query_cxt);
+ 	if (tuplestore_gettupleslot(festate->tuples, true, false, slot))
+ 	{
+ 		MemoryContextSwitchTo(oldcontext);
+ 		return slot;
+ 	}
+ 	MemoryContextSwitchTo(oldcontext);
+ 
+ 	/* If the scan doesn't use cursor, the scan has been done. */
+ 	if (!USE_CURSOR(festate->fdwplan))
+ 	{
+ 		ExecClearTuple(slot);
+ 		return slot;
+ 	}
+ 
+ 	/*
+ 	 * Here we need to clear partial result and fetch next bunch of tuples from
+ 	 * from the cursor for the scan.  If the fetch returns no tuple, the scan
+ 	 * has reached the end.
+ 	 */
+ 	res = fetch_result(node);
+ 	PG_TRY();
+ 	{
+ 		store_result(node, res);
+ 		PQclear(res);
+ 		res = NULL;
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		PQclear(res);
+ 		PG_RE_THROW();
+ 	}
+ 	PG_END_TRY();
+ 
+ 	/*
+ 	 * If we got more tuples from the server cursor, return next tuple from
+ 	 * tuplestore.
+ 	 */
+ 	MemoryContextSwitchTo(node->ss.ps.state->es_query_cxt);
+ 	if (tuplestore_gettupleslot(festate->tuples, true, false, slot))
+ 	{
+ 		MemoryContextSwitchTo(oldcontext);
+ 		return slot;
+ 	}
+ 	MemoryContextSwitchTo(oldcontext);
+ 
+ 	/* We don't have any result even in remote server cursor. */
+ 	ExecClearTuple(slot);
+ 	return slot;
+ }
+ 
+ /*
+  * pgsqlReScanForeignScan
+  *   - Restart this scan by resetting fetch location.
+  */
+ static void
+ pgsqlReScanForeignScan(ForeignScanState *node)
+ {
+ 	List	   *fdw_private;
+ 	char	   *sql;
+ 	PGconn	   *conn;
+ 	PGresult   *res;
+ 	PgsqlFdwExecutionState *festate;
+ 
+ 	festate = (PgsqlFdwExecutionState *) node->fdw_state;
+ 
+ 	/* Discard fetch results if any. */
+ 	if (festate->tuples != NULL)
+ 	{
+ 		tuplestore_end(festate->tuples);
+ 		festate->tuples = NULL;
+ 	}
+ 
+ 	/* Reset cursor */
+ 	if (USE_CURSOR(festate->fdwplan))
+ 	{
+ 		fdw_private = festate->fdwplan->fdw_private;
+ 		conn = festate->conn;
+ 		sql = strVal(list_nth(fdw_private, FdwPrivateResetSql));
+ 		res = PQexec(conn, sql);
+ 		PG_TRY();
+ 		{
+ 			if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+ 			{
+ 				ereport(ERROR,
+ 						(errmsg("could not rewind cursor"),
+ 						 errdetail("%s", PQerrorMessage(conn)),
+ 						 errhint("%s", sql)));
+ 			}
+ 			PQclear(res);
+ 			res = NULL;
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			PQclear(res);
+ 			PG_RE_THROW();
+ 		}
+ 		PG_END_TRY();
+ 	}
+ }
+ 
+ /*
+  * pgsqlEndForeignScan
+  *		Finish scanning foreign table and dispose objects used for this scan
+  */
+ static void
+ pgsqlEndForeignScan(ForeignScanState *node)
+ {
+ 	List	   *fdw_private;
+ 	char	   *sql;
+ 	PGconn	   *conn;
+ 	PGresult   *res;
+ 	PgsqlFdwExecutionState *festate;
+ 
+ 	festate = (PgsqlFdwExecutionState *) node->fdw_state;
+ 
+ 	/* if festate is NULL, we are in EXPLAIN; nothing to do */
+ 	if (festate == NULL)
+ 		return;
+ 
+ 	/* Discard fetch results */
+ 	if (festate->tuples != NULL)
+ 	{
+ 		tuplestore_end(festate->tuples);
+ 		festate->tuples = NULL;
+ 	}
+ 
+ 	/* Close cursor */
+ 	if (USE_CURSOR(festate->fdwplan) && festate->cursor_opened)
+ 	{
+ 		fdw_private = festate->fdwplan->fdw_private;
+ 		conn = festate->conn;
+ 		sql = strVal(list_nth(fdw_private, FdwPrivateCloseSql));
+ 		res = PQexec(conn, sql);
+ 		PG_TRY();
+ 		{
+ 			if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
+ 			{
+ 				ereport(ERROR,
+ 						(errmsg("could not close cursor"),
+ 						 errdetail("%s", PQerrorMessage(conn)),
+ 						 errhint("%s", sql)));
+ 			}
+ 			PQclear(res);
+ 			res = NULL;
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			PQclear(res);
+ 			PG_RE_THROW();
+ 		}
+ 		PG_END_TRY();
+ 	}
+ 
+ 	ReleaseConnection(festate->conn);
+ }
+ 
+ /*
+  * Estimate costs of scanning a foreign table.
+  */
+ static void
+ estimate_costs(PlannerInfo *root, RelOptInfo *baserel,
+ 			   const char *sql, Oid serverid,
+ 			   Cost *startup_cost, Cost *total_cost)
+ {
+ 	ForeignServer  *server;
+ 	UserMapping	   *user;
+ 	PGconn		   *conn = NULL;
+ 	PGresult	   *res = NULL;
+ 	StringInfoData  buf;
+ 	char		   *plan;
+ 	char		   *p;
+ 	char		   *endp;
+ 
+ 	/*
+ 	 * Get connection to the foreign server.  Connection manager would
+ 	 * establish new connection if necessary.
+ 	 */
+ 	server = GetForeignServer(serverid);
+ 	user = GetUserMapping(GetOuterUserId(), server->serverid);
+ 	conn = GetConnection(server, user);
+ 	initStringInfo(&buf);
+ 	appendStringInfo(&buf, "EXPLAIN (FORMAT YAML) %s", sql);
+ 
+ 	/* remove WHERE clause if the query uses parameter */
+ 	p = strchr(buf.data, '$');
+ 	if (p != NULL)
+ 	{
+ 		p = strstr(buf.data, "WHERE");
+ 		if (p != NULL)
+ 			*p = '\0';
+ 	}
+ 
+ 	PG_TRY();
+ 	{
+ 		res = PQexec(conn, buf.data);
+ 		if (res == NULL || PQresultStatus(res) != PGRES_TUPLES_OK)
+ 		{
+ 			char *msg;
+ 
+ 			msg = pstrdup(PQerrorMessage(conn));
+ 			PQclear(res);
+ 			res = NULL;
+ 			ereport(ERROR,
+ 					(errmsg("could not execute EXPLAIN for cost estimation"),
+ 					 errdetail("%s", msg),
+ 					 errhint("%s", sql)));
+ 		}
+ 		plan = pstrdup(PQgetvalue(res, 0, 0));
+ 		PQclear(res);
+ 		res = NULL;
+ 		ReleaseConnection(conn);
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		PQclear(res);
+ 		PG_RE_THROW();
+ 	}
+ 	PG_END_TRY();
+ 
+ 	/* extract startup cost from remote plan */
+ 	p = strstr(plan, "Startup Cost: ");
+ 	if (p != NULL)
+ 	{
+ 		p += strlen("Startup Cost: ");
+ 		*startup_cost = strtod(p, &endp);
+ 		if (*endp != '\n' && *endp != '\0')
+ 			elog(ERROR, "invalid plan format for startup cost%c", *endp);
+ 	}
+ 
+ 	/* extract total cost from remote plan */
+ 	p = strstr(plan, "Total Cost: ");
+ 	if (p != NULL)
+ 	{
+ 		p += strlen("Total Cost: ");
+ 		*total_cost = strtod(p, &endp);
+ 		if (*endp != '\n' && *endp != '\0')
+ 			elog(ERROR, "invalid plan format for total cost");
+ 	}
+ 
+ 	/* extract # of rows from remote plan */
+ 	p = strstr(plan, "Plan Rows: ");
+ 	if (p != NULL)
+ 	{
+ 		p += strlen("Plan Rows: ");
+ 		baserel->rows = strtod(p, &endp);
+ 		if (*endp != '\n' && *endp != '\0')
+ 			elog(ERROR, "invalid plan format for plan rows");
+ 	}
+ 
+ 	/* extract average width from remote plan */
+ 	p = strstr(plan, "Plan Width: ");
+ 	if (p != NULL)
+ 	{
+ 		p += strlen("Plan Width: ");
+ 		baserel->width = strtol(p, &endp, 10);
+ 		if (*endp != '\n' && *endp != '\0')
+ 			elog(ERROR, "invalid plan format for plan width");
+ 	}
+ 
+ 	/* TODO Selectivity of quals pushed down should be considered. */
+ 
+ 	/* add cost to establish connection. */
+ 	*startup_cost += CONNECTION_COSTS;
+ 	*total_cost += CONNECTION_COSTS;
+ 
+ 	/* add cost to transfer result. */
+ 	*total_cost += TRANSFER_COSTS_PER_BYTE * baserel->width * baserel->tuples;
+ 	*total_cost += cpu_tuple_cost * baserel->tuples;
+ }
+ 
+ /*
+  * Execute remote query with current parameters.
+  */
+ static void
+ execute_query(ForeignScanState *node)
+ {
+ 	FdwPlan		   *fdwplan;
+ 	PgsqlFdwExecutionState *festate;
+ 	ParamListInfo	params = node->ss.ps.state->es_param_list_info;
+ 	int				numParams = params ? params->numParams : 0;
+ 	Oid			   *types = NULL;
+ 	const char	  **values = NULL;
+ 	char		   *sql;
+ 	int				required_result;
+ 	PGconn		   *conn;
+ 	PGresult	   *res;
+ 
+ 	festate = (PgsqlFdwExecutionState *) node->fdw_state;
+ 	types = festate->param_types;
+ 	values = festate->param_values;
+ 
+ 	/*
+ 	 * Construct parameter array in text format.  We don't release memory for
+ 	 * the arrays explicitly, because the memory usage would not be very large,
+ 	 * and anyway they will be released in context cleanup.
+ 	 */
+ 	if (numParams > 0)
+ 	{
+ 		int i;
+ 
+ 		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;
+ 
+ 				getTypeOutputInfo(types[i], &out_func_oid, &isvarlena);
+ 				fmgr_info(out_func_oid, &func);
+ 				values[i] = OutputFunctionCall(&func, params->params[i].value);
+ 			}
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Execute remote query with parameters.
+ 	 */
+ 	conn = festate->conn;
+ 	fdwplan = ((ForeignScan *) node->ss.ps.plan)->fdwplan;
+ 	if (USE_CURSOR(fdwplan))
+ 	{
+ 		sql = strVal(list_nth(fdwplan->fdw_private, FdwPrivateDeclareSql));
+ 		required_result = PGRES_COMMAND_OK;
+ 	}
+ 	else
+ 	{
+ 		sql = strVal(list_nth(fdwplan->fdw_private, FdwPrivateSelectSql));
+ 		required_result = PGRES_TUPLES_OK;
+ 	}
+ 	res = PQexecParams(conn, sql, numParams, types, values, NULL, NULL, 0);
+ 	PG_TRY();
+ 	{
+ 		/*
+ 		 * If the query has failed, reporting details is enough here.
+ 		 * Connection(s) which are used by this query (at least used by
+ 		 * pgsql_fdw) will be cleaned up by the foreign connection manager.
+ 		 */
+ 		if (res == NULL || PQresultStatus(res) != required_result)
+ 		{
+ 			ereport(ERROR,
+ 					(errmsg("could not execute foreign query"),
+ 					 errdetail("%s", PQerrorMessage(conn)),
+ 					 errhint("%s", sql)));
+ 		}
+ 
+ 		/* Fetch first bunch of result if we using cursor. */
+ 		if (USE_CURSOR(fdwplan))
+ 		{
+ 			/* Mark that this scan has opened a cursor. */
+ 			festate->cursor_opened = true;
+ 
+ 			/* Discard result of CURSOR statement and fetch first bunch. */
+ 			PQclear(res);
+ 			res = fetch_result(node);
+ 		}
+ 
+ 		/*
+ 		 * Store the result of the query into tuplestore.
+ 		 * We must release PGresult here to avoid memory leak.
+ 		 */
+ 		store_result(node, res);
+ 		PQclear(res);
+ 		res = NULL;
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		PQclear(res);
+ 		PG_RE_THROW();
+ 	}
+ 	PG_END_TRY();
+ }
+ 
+ /*
+  * Fetch next partial result from remote server.
+  */
+ static PGresult *
+ fetch_result(ForeignScanState *node)
+ {
+ 	PgsqlFdwExecutionState *festate;
+ 	List		   *fdw_private;
+ 	char		   *sql;
+ 	PGconn		   *conn;
+ 	PGresult	   *res;
+ 
+ 	festate = (PgsqlFdwExecutionState *) node->fdw_state;
+ 
+ 	/* retrieve information for fetching result. */
+ 	fdw_private = festate->fdwplan->fdw_private;
+ 	sql = strVal(list_nth(fdw_private, FdwPrivateFetchSql));
+ 	conn = festate->conn;
+ 	res = PQexec(conn, sql);
+ 	if (res == NULL || PQresultStatus(res) != PGRES_TUPLES_OK)
+ 	{
+ 		ereport(ERROR,
+ 				(errmsg("could not fetch rows from foreign server"),
+ 				 errdetail("%s", PQerrorMessage(conn)),
+ 				 errhint("%s", sql)));
+ 	}
+ 
+ 	return res;
+ }
+ 
+ /*
+  * Create tuples from PGresult and store them into tuplestore.
+  */
+ static void
+ store_result(ForeignScanState *node, PGresult *res)
+ {
+ 	int					rows;
+ 	int					row;
+ 	int					i;
+ 	int					nfields;
+ 	int					attnum;		/* number of non-dropped columns */
+ 	Form_pg_attribute  *attrs;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 	TupleDesc	tupdesc = slot->tts_tupleDescriptor;
+ 	PgsqlFdwExecutionState *festate;
+ 
+ 	festate = (PgsqlFdwExecutionState *) node->fdw_state;
+ 	rows = PQntuples(res);
+ 	nfields = PQnfields(res);
+ 	attrs = tupdesc->attrs;
+ 
+ 	/* First, ensure that the tuplestore is empty. */
+ 	if (festate->tuples == NULL)
+ 	{
+ 		MemoryContext	oldcontext = CurrentMemoryContext;
+ 
+ 		/*
+ 		 * Create tuplestore to store result of the query in per-query context.
+ 		 * Note that we use this memory context to avoid memory leak in error
+ 		 * cases.
+ 		 */
+ 		MemoryContextSwitchTo(MessageContext);
+ 		festate->tuples = tuplestore_begin_heap(false, false, work_mem);
+ 		MemoryContextSwitchTo(oldcontext);
+ 	}
+ 	else
+ 	{
+ 		/* We already have tuplestore, just need to clear contents of it. */
+ 		tuplestore_clear(festate->tuples);
+ 	}
+ 	
+ 
+ 	/* count non-dropped columns */
+ 	for (attnum = 0, i = 0; i < tupdesc->natts; i++)
+ 		if (!attrs[i]->attisdropped)
+ 			attnum++;
+ 
+ 	/* check result and tuple descriptor have the same number of columns */
+ 	if (attnum > 0 && attnum != nfields)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 				 errmsg("remote query result rowtype does not match "
+ 						"the specified FROM clause rowtype"),
+ 				 errdetail("expected %d, actual %d", attnum, nfields)));
+ 
+ 	/* put a tuples into the slot */
+ 	for (row = 0; row < rows; row++)
+ 	{
+ 		int			j;
+ 		HeapTuple	tuple;
+ 
+ 		for (i = 0, j = 0; i < tupdesc->natts; i++)
+ 		{
+ 			/* skip dropped columns. */
+ 			if (attrs[i]->attisdropped)
+ 			{
+ 				festate->col_values[i] = NULL;
+ 				continue;
+ 			}
+ 
+ 			if (PQgetisnull(res, row, j))
+ 				festate->col_values[i] = NULL;
+ 			else
+ 				festate->col_values[i] = PQgetvalue(res, row, j);
+ 			j++;
+ 		}
+ 
+ 		/*
+ 		 * Build the tuple and put it into the slot.
+ 		 * We don't have to free the tuple explicitly because it's been
+ 		 * allocated in the per-tuple context.
+ 		 */
+ 		tuple = BuildTupleFromCStrings(festate->attinmeta, festate->col_values);
+ 		tuplestore_puttuple(festate->tuples, tuple);
+ 	}
+ 
+ 	tuplestore_donestoring(festate->tuples);
+ }
diff --git a/contrib/pgsql_fdw/pgsql_fdw.control b/contrib/pgsql_fdw/pgsql_fdw.control
index ...0a9c8f4 .
*** a/contrib/pgsql_fdw/pgsql_fdw.control
--- b/contrib/pgsql_fdw/pgsql_fdw.control
***************
*** 0 ****
--- 1,5 ----
+ # pgsql_fdw extension
+ comment = 'foreign-data wrapper for remote PostgreSQL servers'
+ default_version = '1.0'
+ module_pathname = '$libdir/pgsql_fdw'
+ relocatable = true
diff --git a/contrib/pgsql_fdw/pgsql_fdw.h b/contrib/pgsql_fdw/pgsql_fdw.h
index ...d5e5d4b .
*** a/contrib/pgsql_fdw/pgsql_fdw.h
--- b/contrib/pgsql_fdw/pgsql_fdw.h
***************
*** 0 ****
--- 1,28 ----
+ /*-------------------------------------------------------------------------
+  *
+  * pgsql_fdw.h
+  *		  foreign-data wrapper for remote PostgreSQL servers.
+  *
+  * Copyright (c) 2011, PostgreSQL Global Development Group
+  *
+  * IDENTIFICATION
+  *		  pgsql_fdw/pgsql_fdw.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef PGSQL_FDW_H
+ #define PGSQL_FDW_H
+ 
+ #include "postgres.h"
+ #include "nodes/relation.h"
+ 
+ /* in option.c */
+ int ExtractConnectionOptions(List *defelems,
+ 							 const char **keywords,
+ 							 const char **values);
+ 
+ /* in deparse.c */
+ char *deparseSql(Oid relid, PlannerInfo *root, RelOptInfo *baserel);
+ 
+ #endif /* PGSQL_FDW_H */
diff --git a/contrib/pgsql_fdw/sql/pgsql_fdw.sql b/contrib/pgsql_fdw/sql/pgsql_fdw.sql
index ...b6b99ab .
*** a/contrib/pgsql_fdw/sql/pgsql_fdw.sql
--- b/contrib/pgsql_fdw/sql/pgsql_fdw.sql
***************
*** 0 ****
--- 1,175 ----
+ -- ===================================================================
+ -- create FDW objects
+ -- ===================================================================
+ 
+ CREATE EXTENSION pgsql_fdw;
+ 
+ CREATE SERVER loopback1 FOREIGN DATA WRAPPER pgsql_fdw;
+ CREATE SERVER loopback2 FOREIGN DATA WRAPPER pgsql_fdw
+   OPTIONS (dbname 'contrib_regression');
+ 
+ CREATE USER MAPPING FOR public SERVER loopback1
+ 	OPTIONS (user 'value', password 'value');
+ CREATE USER MAPPING FOR public SERVER loopback2;
+ 
+ CREATE FOREIGN TABLE ft1 (
+ 	c1 int NOT NULL,
+ 	c2 int NOT NULL,
+ 	c3 text,
+ 	c4 timestamptz,
+ 	c5 timestamp
+ ) SERVER loopback2;
+ 
+ CREATE FOREIGN TABLE ft2 (
+ 	c1 int NOT NULL,
+ 	c2 int NOT NULL,
+ 	c3 text,
+ 	c4 timestamptz,
+ 	c5 timestamp
+ ) SERVER loopback2;
+ 
+ -- ===================================================================
+ -- create objects used through FDW
+ -- ===================================================================
+ CREATE SCHEMA "S 1";
+ CREATE TABLE "S 1"."T 1" (
+ 	c1 int NOT NULL,
+ 	c2 int NOT NULL,
+ 	c3 text,
+ 	c4 timestamptz,
+ 	c5 timestamp,
+ 	CONSTRAINT t1_pkey PRIMARY KEY (c1)
+ );
+ CREATE TABLE "S 1"."T 2" (
+ 	c1 int NOT NULL,
+ 	c2 text,
+ 	CONSTRAINT t2_pkey PRIMARY KEY (c1)
+ );
+ 
+ BEGIN;
+ TRUNCATE "S 1"."T 1";
+ INSERT INTO "S 1"."T 1"
+ 	SELECT id,
+ 	       id % 10,
+ 	       to_char(id, 'FM00000'),
+ 	       '1970-01-01'::timestamptz + ((id % 100) || ' days')::interval,
+ 	       '1970-01-01'::timestamp + ((id % 100) || ' days')::interval
+ 	FROM generate_series(1, 1000) id;
+ TRUNCATE "S 1"."T 2";
+ INSERT INTO "S 1"."T 2"
+ 	SELECT id,
+ 	       'AAA' || to_char(id, 'FM000')
+ 	FROM generate_series(1, 100) id;
+ COMMIT;
+ 
+ -- ===================================================================
+ -- tests for pgsql_fdw_validator
+ -- ===================================================================
+ ALTER FOREIGN DATA WRAPPER pgsql_fdw OPTIONS (host 'value');    -- ERRROR
+ -- requiressl, krbsrvname and gsslib are omitted because they depend on
+ -- configure option
+ ALTER SERVER loopback1 OPTIONS (
+ 	--authtype 'value',
+ 	service 'value',
+ 	connect_timeout 'value',
+ 	dbname 'value',
+ 	host 'value',
+ 	hostaddr 'value',
+ 	port 'value',
+ 	--client_encoding 'value',
+ 	--tty 'value',
+ 	options 'value',
+ 	application_name 'value',
+ 	--fallback_application_name 'value',
+ 	keepalives 'value',
+ 	keepalives_idle 'value',
+ 	keepalives_interval 'value',
+ 	-- requiressl 'value',
+ 	sslmode 'value',
+ 	sslcert 'value',
+ 	sslkey 'value',
+ 	sslrootcert 'value',
+ 	sslcrl 'value'
+ 	--requirepeer 'value',
+ 	-- krbsrvname 'value',
+ 	-- gsslib 'value',
+ 	--replication 'value'
+ );
+ ALTER SERVER loopback1 OPTIONS (user 'value');                  -- ERROR
+ ALTER SERVER loopback2 OPTIONS (ADD min_cursor_rows '0');
+ ALTER SERVER loopback2 OPTIONS (ADD fetch_count '2');
+ ALTER USER MAPPING FOR public SERVER loopback1
+ 	OPTIONS (DROP user, DROP password);
+ ALTER USER MAPPING FOR public SERVER loopback1
+ 	OPTIONS (host 'value');                                     -- ERROR
+ ALTER FOREIGN TABLE ft1 OPTIONS (nspname 'S 1', relname 'T 1');
+ ALTER FOREIGN TABLE ft2 OPTIONS (nspname 'S 1', relname 'T 1', min_cursor_rows '10', fetch_count '100');
+ ALTER FOREIGN TABLE ft1 OPTIONS (invalid 'value');              -- ERROR
+ ALTER FOREIGN TABLE ft1 OPTIONS (min_cursor_rows 'a');          -- ERROR
+ ALTER FOREIGN TABLE ft1 OPTIONS (min_cursor_rows '-1');         -- ERROR
+ ALTER FOREIGN TABLE ft1 OPTIONS (fetch_count 'a');              -- ERROR
+ ALTER FOREIGN TABLE ft1 OPTIONS (fetch_count '0');              -- ERROR
+ ALTER FOREIGN TABLE ft1 OPTIONS (fetch_count '-1');             -- ERROR
+ \dew+
+ \des+
+ \deu+
+ \det+
+ 
+ -- ===================================================================
+ -- simple queries
+ -- ===================================================================
+ -- single table, with/without alias
+ EXPLAIN (VERBOSE, COSTS false) SELECT * FROM ft1 ORDER BY c3, c1 OFFSET 100 LIMIT 10;
+ SELECT * FROM ft1 ORDER BY c3, c1 OFFSET 100 LIMIT 10;
+ EXPLAIN (VERBOSE, COSTS false) SELECT * FROM ft1 t1 ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
+ SELECT * FROM ft1 t1 ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
+ -- with WHERE clause
+ SELECT * FROM ft1 t1 WHERE t1.c1 = 101;
+ -- aggregate
+ SELECT COUNT(*) FROM ft1 t1;
+ -- join two tables
+ SELECT t1.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c3, t1.c1 OFFSET 100 LIMIT 10;
+ -- subquery
+ SELECT * FROM ft1 t1 WHERE t1.c3 IN (SELECT c3 FROM ft2 t2 WHERE c1 <= 10) ORDER BY c1;
+ -- subquery+MAX
+ SELECT * FROM ft1 t1 WHERE t1.c3 = (SELECT MAX(c3) FROM ft2 t2) ORDER BY c1;
+ -- used in CTE
+ WITH t1 AS (SELECT * FROM ft1 WHERE c1 <= 10) SELECT t2.c1, t2.c2, t2.c3, t2.c4 FROM t1, ft2 t2 WHERE t1.c1 = t2.c1 ORDER BY t1.c1;
+ -- fixed values
+ SELECT 'fixed', NULL FROM ft1 t1 WHERE c1 = 1;
+ 
+ -- ===================================================================
+ -- parameterized queries
+ -- ===================================================================
+ -- simple join
+ PREPARE st1(int, int) AS SELECT t1.c3, t2.c3 FROM ft1 t1, ft2 t2 WHERE t1.c1 = $1 AND t2.c1 = $2;
+ EXPLAIN (COSTS false) EXECUTE st1(1, 2);
+ EXECUTE st1(1, 1);
+ EXECUTE st1(101, 101);
+ -- subquery using stable function (can't be pushed down)
+ PREPARE st2(int) AS SELECT * FROM ft1 t1 WHERE t1.c1 < $2 AND t1.c3 IN (SELECT c3 FROM ft2 t2 WHERE c1 > $1 AND EXTRACT(dow FROM c4) = 6) ORDER BY c1;
+ EXPLAIN (COSTS false) EXECUTE st2(10, 20);
+ EXECUTE st2(10, 20);
+ EXECUTE st1(101, 101);
+ -- subquery using immutable function (can be pushed down)
+ PREPARE st3(int) AS SELECT * FROM ft1 t1 WHERE t1.c1 < $2 AND t1.c3 IN (SELECT c3 FROM ft2 t2 WHERE c1 > $1 AND EXTRACT(dow FROM c5) = 6) ORDER BY c1;
+ EXPLAIN (COSTS false) EXECUTE st3(10, 20);
+ EXECUTE st3(10, 20);
+ EXECUTE st3(20, 30);
+ -- cleanup
+ DEALLOCATE st1;
+ DEALLOCATE st2;
+ DEALLOCATE st3;
+ 
+ -- ===================================================================
+ -- connection management
+ -- ===================================================================
+ SELECT srvname, usename FROM pgsql_fdw_connections;
+ SELECT pgsql_fdw_disconnect(srvid, usesysid) FROM pgsql_fdw_get_connections();
+ SELECT srvname, usename FROM pgsql_fdw_connections;
+ 
+ -- ===================================================================
+ -- cleanup
+ -- ===================================================================
+ DROP EXTENSION pgsql_fdw CASCADE;
+ 
diff --git a/doc/src/sgml/contrib.sgml b/doc/src/sgml/contrib.sgml
index adf09ca..65c7e81 100644
*** a/doc/src/sgml/contrib.sgml
--- b/doc/src/sgml/contrib.sgml
*************** CREATE EXTENSION <replaceable>module_nam
*** 117,122 ****
--- 117,123 ----
   &pgcrypto;
   &pgfreespacemap;
   &pgrowlocks;
+  &pgsql-fdw;
   &pgstandby;
   &pgstatstatements;
   &pgstattuple;
diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml
index ed39e0b..d72590f 100644
*** a/doc/src/sgml/filelist.sgml
--- b/doc/src/sgml/filelist.sgml
***************
*** 123,128 ****
--- 123,129 ----
  <!ENTITY pgcrypto        SYSTEM "pgcrypto.sgml">
  <!ENTITY pgfreespacemap  SYSTEM "pgfreespacemap.sgml">
  <!ENTITY pgrowlocks      SYSTEM "pgrowlocks.sgml">
+ <!ENTITY pgsql-fdw       SYSTEM "pgsql-fdw.sgml">
  <!ENTITY pgstandby       SYSTEM "pgstandby.sgml">
  <!ENTITY pgstatstatements SYSTEM "pgstatstatements.sgml">
  <!ENTITY pgstattuple     SYSTEM "pgstattuple.sgml">
diff --git a/doc/src/sgml/pgsql-fdw.sgml b/doc/src/sgml/pgsql-fdw.sgml
index ...6b7cb94 .
*** a/doc/src/sgml/pgsql-fdw.sgml
--- b/doc/src/sgml/pgsql-fdw.sgml
***************
*** 0 ****
--- 1,273 ----
+ <!-- doc/src/sgml/pgsql-fdw.sgml -->
+ 
+ <sect1 id="pgsql-fdw" xreflabel="pgsql_fdw">
+  <title>pgsql_fdw</title>
+ 
+  <indexterm zone="pgsql-fdw">
+   <primary>pgsql_fdw</primary>
+  </indexterm>
+ 
+  <para>
+   The <filename>pgsql_fdw</filename> module provides a foreign-data wrapper for
+   external <productname>PostgreSQL</productname> servers.
+   With this module, users can access data stored in external
+   <productname>PostgreSQL</productname> via plain SQL statements.
+  </para>
+ 
+  <para>
+   The <application>pgsql_fdw</application> can be installed on only
+   <productname>PostgreSQL</productname> 9.1 or later, but it can also access
+   data stored in <productname>PostgreSQL</productname> 9.0.
+   <productname>PostgreSQL</productname>8.4 or older are not available as remote
+   server because <application>pgsql_fdw</application> uses YAML format of
+   <command>EXPLAIN</command> output.
+  </para>
+ 
+  <para>
+   Note that default wrapper <literal>pgsql_fdw</literal> is created
+   automatically during <command>CREATE EXTENSION</command> command for
+   <application>pgsql_fdw</application>.
+  </para>
+ 
+  <sect2>
+   <title>FDW Options of pgsql_fdw</title>
+ 
+   <sect3>
+    <title>Connection Options</title>
+    <para>
+     A foreign server and user mapping created using this wrapper can have
+     <application>libpq</> connection options, expect below:
+ 
+     <itemizedlist>
+      <listitem><para>authtype</para></listitem>
+      <listitem><para>client_encoding</para></listitem>
+      <listitem><para>tty</para></listitem>
+      <listitem><para>fallback_application_name</para></listitem>
+      <listitem><para>replication</para></listitem>
+     </itemizedlist>
+ 
+     For details of <application>libpq</> connection options, see
+     <xref linkend="libpq-connect">.
+    </para>
+ 
+    <para>
+     <literal>user</literal> and <literal>password</literal> can be
+     specified on user mappings, and others can be specified on foreign servers.
+    </para>
+   </sect3>
+ 
+   <sect3>
+    <title>Object Name Options</title>
+    <para>
+     Foreign tables which were created using this wrapper, or its columns can
+     have object name options.  These options can be used to specify the names
+     used in SQL statement sent to remote <productname>PostgreSQL</productname>
+     server.  These options are useful when a remote object has different name
+     from corresponding local one.
+    </para>
+ 
+    <variablelist>
+ 
+     <varlistentry>
+      <term><literal>nspname</literal></term>
+      <listitem>
+       <para>
+        This option, which can be specified on a foreign table, is used as a
+        namespace (schema) reference in the SQL statement.  If this options is
+        omitted, <literal>pg_class.nspname</literal> of the foreign table is
+        used.
+       </para>
+      </listitem>
+     </varlistentry>
+ 
+     <varlistentry>
+      <term><literal>relname</literal></term>
+      <listitem>
+       <para>
+        This option, which can be specified on a foreign table, is used as a
+        relation (table) reference in the SQL statement.  If this options is
+        omitted, <literal>pg_class.relname</literal> of the foreign table is
+        used.
+       </para>
+      </listitem>
+     </varlistentry>
+ 
+     <varlistentry>
+      <term><literal>colname</literal></term>
+      <listitem>
+       <para>
+        This option, which can be specified on a column of a foreign table, is
+        used as a column (attribute) reference in the SQL statement.  If this
+        options is omitted, <literal>pg_attribute.attname</literal> of the column
+        of the foreign table is used.
+       </para>
+      </listitem>
+     </varlistentry>
+  
+    </variablelist>
+ 
+   </sect3>
+ 
+   <sect3>
+    <title>Cursor Options</title>
+    <para>
+     The <application>pgsql_fdw</application> switches the way used to retrieve
+     result of remote query according to estimated number of result rows.
+     If the estimation was less than a threshold, the result rows are retrieved
+     at once with simple <command>SELECT</command> statement.
+     In contrast, if the estimation is larger than the threshold, the result
+     rows are fetched separately with a cursor defined by
+     <command>DECLARE</command> statement.
+    </para>
+ 
+    <para>
+     Users can control this behavior with setting cursor options for a foreign
+     table.
+    </para>
+ 
+    <variablelist>
+ 
+     <varlistentry>
+      <term><literal>min_cursor_rows</literal></term>
+      <listitem>
+       <para>
+        This option specifies the minimum estimated number of result rows to use
+        cursor for fetching result.  Setting this to 1 means that every query
+        uses cursor, and setting to 0 means that every query uses simple
+        <command>SELECT</command>.  This option can be set on a foreign table,
+        and accepts only positive integer value.
+       </para>
+      </listitem>
+     </varlistentry>
+ 
+     <varlistentry>
+      <term><literal>fetch_count</literal></term>
+      <listitem>
+       <para>
+        This option specifies the number of rows fetched at once in cursor mode.
+        This option accepts only integer value larger than zero.
+       </para>
+      </listitem>
+     </varlistentry>
+ 
+    </variablelist>
+ 
+   </sect3>
+ 
+  </sect2>
+ 
+  <sect2>
+   <title>Connection Management</title>
+ 
+   <para>
+    The <application>pgsql_fdw</application> establishes a connection to a
+    foreign server in the beginning of the first query which uses a foreign
+    table associated to the foreign server, and reuses the connection following
+    queries and even in following foreign scans in same query.
+ 
+    You can see the list of active connections via
+    <structname>pgsql_fdw_connections</structname> view.  It shows pair of oid
+    and name of server and local role for each active connections established by
+    <application>pgsql_fdw</application>.  For security reason, only superuser
+    can see other role's connections.
+   </para>
+ 
+   <para>
+    Established connections are kept alive until local role changes or the
+    current transaction aborts or user requests so.
+   </para>
+ 
+   <para>
+    If role has been changed, active connections established as old local role
+    is kept alive but never be reused until locla role has restored to original
+    role.  This kind of situation happens with <command>SET ROLE</command> and
+    <command>SET SESSION AUTHORIZATION</command>.
+   </para>
+ 
+   <para>
+    If current transaction aborts by error or user request, all active
+    connections are disconnected automatically.  This behavior avoids possible
+    connection leaks on error.
+   </para>
+ 
+   <para>
+    You can discard persistent connection at arbitrary timing with
+    <function>pgsql_fdw_disconnect()</function>.  It takes server oid and
+    user oid as arguments.  This function can handle only connections
+    established in current session; connections established by other backends
+    are not reachable.
+   </para>
+ 
+   <para>
+    You can discard all active and visible connections in current session with
+    using <structname>pgsql_fdw_connections</structname> and
+    <function>pgsql_fdw_disconnect()</function> together:
+ <synopsis>
+ postgres=# SELECT pgsql_fdw_disconnect(srvid, usesysid) FROM pgsql_fdw_connections;
+  pgsql_fdw_disconnect
+ ----------------------
+  OK
+  OK
+ (2 rows)
+ </synopsis>
+   </para>
+  </sect2>
+ 
+  <sect2>
+   <title>Transaction Management</title>
+   <para>
+    The <application>pgsql_fdw</application> executes <command>BEGIN</command>
+    command when a new connection has established.  This means that all remote
+    queries for a foreign server are executed in a transaction.  Since the
+    default transaction isolation level is <literal>READ COMMITTED</literal>,
+    multiple foreign scans in a local query might produce inconsistent results.
+ 
+    To avoid this inconsistency, you can use <literal>SERIALIZABLE</literal>
+    level for remote transaction with setting
+    <literal>default_transaction_isolation</literal> for the user used for
+    <application>pgsql_fdw</application> connection on remote side.
+   </para>
+  </sect2>
+ 
+  <sect2>
+   <title>Estimation of Costs and Rows</title>
+   <para>
+    The <application>pgsql_fdw</application> estimates the costs of a foreign
+    scan by adding some basic costs:  connection costs, remote query costs and
+    data transfer costs.
+    To get remote query costs <application>pgsql_fdw</application> executes
+    <command>EXPLAIN</command> command on remote server for each foreign scan.
+   </para>
+ 
+   <para>
+    On the other hand, estimated rows which was returned by
+    <command>EXPLAIN</command> is used for local estimation as-is.
+   </para>
+  </sect2>
+ 
+  <sect2>
+   <title>EXPLAIN Output</title>
+   <para>
+    For a foreign table using <literal>pgsql_fdw</>, <command>EXPLAIN</> shows
+    a remote SQL statement which is sent to remote
+    <productname>PostgreSQL</productname> server for a ForeignScan plan node.
+     For example:
+   </para>
+ <synopsis>
+ postgres=# EXPLAIN SELECT aid FROM pgbench_accounts WHERE abalance < 0;
+                                           QUERY PLAN
+ -----------------------------------------------------------------------------------------------
+  Foreign Scan on pgbench_accounts  (cost=100.00..8769.00 rows=1 width=4)
+    Remote SQL: SELECT aid, NULL, NULL, NULL FROM public.pgbench_accounts WHERE (abalance < 0)
+ (2 rows)
+ </synopsis>
+  </sect2>
+ 
+  <sect2>
+   <title>Author</title>
+   <para>
+    Shigeru Hanada <email>shigeru.hanada@gmail.com</email>
+   </para>
+  </sect2>
+ 
+ </sect1>
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 75923a6..6fda053 100644
*** a/src/backend/utils/adt/ruleutils.c
--- b/src/backend/utils/adt/ruleutils.c
*************** deparse_context_for(const char *aliasnam
*** 2161,2166 ****
--- 2161,2189 ----
  	return list_make1(dpns);
  }
  
+ /* ----------
+  * deparse_context_for_rtelist	- Build deparse context for a single relation
+  *
+  * Given the list of RangeTableEnetry, build deparsing context for an
+  * expression referencing those relations.	This is sufficient for uses of
+  * deparse_expression before plan has been created.
+  * ----------
+  */
+ List *
+ deparse_context_for_rtelist(List *rtable)
+ {
+ 	deparse_namespace *dpns;
+ 
+ 	dpns = (deparse_namespace *) palloc0(sizeof(deparse_namespace));
+ 
+ 	/* Build a minimal RTE for the rel */
+ 	dpns->rtable = rtable;
+ 	dpns->ctes = NIL;
+ 
+ 	/* Return a one-deep namespace stack */
+ 	return list_make1(dpns);
+ }
+ 
  /*
   * deparse_context_for_planstate	- Build deparse context for a plan
   *
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index 8a1c82e..a56366f 100644
*** a/src/include/utils/builtins.h
--- b/src/include/utils/builtins.h
*************** extern char *deparse_expression(Node *ex
*** 626,631 ****
--- 626,632 ----
  extern List *deparse_context_for(const char *aliasname, Oid relid);
  extern List *deparse_context_for_planstate(Node *planstate, List *ancestors,
  							  List *rtable);
+ extern List *deparse_context_for_rtelist(List *rtable);
  extern const char *quote_identifier(const char *ident);
  extern char *quote_qualified_identifier(const char *qualifier,
  						   const char *ident);

commit 5a2f1314d197c037dfd55ea1dc0395f46333c05d
Author: Shigeru Hanada <shigeru.hanada@gmail.com>
Date:   Fri Oct 21 11:54:39 2011 +0900

    Add document about helper functions for FDW authors.

diff --git a/doc/src/sgml/fdwhandler.sgml b/doc/src/sgml/fdwhandler.sgml
index 76ff243..db02d13 100644
--- a/doc/src/sgml/fdwhandler.sgml
+++ b/doc/src/sgml/fdwhandler.sgml
@@ -235,4 +235,98 @@ EndForeignScan (ForeignScanState *node);
 
    </sect1>
 
+   <sect1 id="fdw-helpers">
+    <title>Foreign Data Wrapper Helper Functions</title>
+
+    <para>
+     Several helper functions are exported from core so that authors of FDW
+     can get easy access to attributes of FDW-related objects such as FDW
+     options.
+    </para>
+
+    <para>
+<programlisting>
+ForeignDataWrapper *
+GetForeignDataWrapper(Oid fdwid);
+</programlisting>
+
+     This function returns a <structname>ForeignDataWrapper</structname> object
+     for a foreign-data wrapper with given oid.  A
+     <structname>ForeignDataWrapper</structname> object contains oid of the
+     wrapper itself, oid of the owner of the wrapper, name of the wrapper, oid
+     of fdwhandler function, oid of fdwvalidator function, and FDW options in
+     the form of list of <structname>DefElem</structname>.
+    </para>
+
+    <para>
+<programlisting>
+ForeignServer *
+GetForeignServer(Oid serverid);
+</programlisting>
+
+     This function returns a <structname>ForeignServer</structname> object for
+     a foreign server with given oid.  A <structname>ForeignServer</structname>
+     object contains oid of the server, oid of the wrapper for the server, oid
+     of the owner of the server, name of the server, type of the server,
+     version of the server, and FDW options in the form of list of
+     <structname>DefElem</structname>.
+    </para>
+
+    <para>
+<programlisting>
+UserMapping *
+GetUserMapping(Oid userid, Oid serverid);
+</programlisting>
+
+     This function returns a <structname>UserMapping</structname> object for a
+     user mapping with given oid pair.  A <structname>UserMapping</structname>
+     object contains oid of the user, oid of the server, and FDW options in the
+     form of list of <structname>DefElem</structname>.
+    </para>
+
+    <para>
+<programlisting>
+ForeignTable *
+GetForeignTable(Oid relid);
+</programlisting>
+
+     This function returns a <structname>ForeignTable</structname> object for a
+     foreign table with given oid.  A <structname>ForeignTable</structname>
+     object contains oid of the foreign table, oid of the server for the table,
+     and FDW options in the form of list of <structname>DefElem</structname>.
+    </para>
+
+    <para>
+     Some object types have name-based functions.
+    </para>
+
+    <para>
+<programlisting>
+ForeignDataWrapper *
+GetForeignDataWrapperByName(const char *name, bool missing_ok);
+</programlisting>
+
+     This function returns a <structname>ForeignDataWrapper</structname> object
+     for a foreign-data wrapper with given name.  If the wrapper is not found,
+     return NULL if missing_ok was true, otherwise raise an error.
+    </para>
+
+    <para>
+<programlisting>
+ForeignServer *
+GetForeignServerByName(const char *name, bool missing_ok);
+</programlisting>
+
+     This function returns a <structname>ForeignServer</structname> object for
+     a foreign server with given name.  If the server is not found, return NULL
+     if missing_ok was true, otherwise raise an error.
+    </para>
+
+    <para>
+     To use any of these functions, you need to include
+     <filename>foreign/foreign.h</filename> in your source file.
+    </para>
+
+  </sect1>
+
  </chapter>

diff --git a/contrib/pgsql_fdw/deparse.c b/contrib/pgsql_fdw/deparse.c
index b5f6c79..d24b629 100644
*** a/contrib/pgsql_fdw/deparse.c
--- b/contrib/pgsql_fdw/deparse.c
*************** is_proc_remotely_executable(Oid procid)
*** 362,364 ****
--- 362,538 ----
  	return true;
  }
  
+ /*
+  * Append WHERE clause elements to buf.
+  */
+ static void
+ append_where_clause(StringInfo buf, List *context, Path *path, bool *first)
+ {
+ 	List		   *restrictinfo;
+ 	ListCell	   *lc;
+ 	Path		   *outer_path = NULL;
+ 	Path		   *inner_path = NULL;
+ 
+ 	/* Determine that which restrictinfo is used. */
+ 	if (IsA(path, ForeignPath))
+ 	{
+ 		restrictinfo = path->parent->baserestrictinfo;
+ 	}
+ 	else if (IsA(path, ForeignJoinPath))
+ 	{
+ 		JoinPath	   *joinpath = (JoinPath *) path;
+ 		restrictinfo = joinpath->joinrestrictinfo;
+ 		outer_path = joinpath->outerjoinpath;
+ 		inner_path = joinpath->innerjoinpath;
+ 	}
+ 
+ 	/* Deparse restrict expressions. */
+ 	foreach(lc, restrictinfo)
+ 	{
+ 		RestrictInfo   *ri  = (RestrictInfo *) lfirst(lc);
+ 
+ 		if (!*first)
+ 			appendStringInfo(buf, " AND ");
+ 		appendStringInfo(buf, "%s",
+ 			deparse_expression((Node *) ri->clause, context, true, false));
+ 		*first = false;
+ 	}
+ 
+ 	/* Use children's restrictinfo recursively, if any. */
+ 	if (outer_path != NULL)
+ 		append_where_clause(buf, context, outer_path, first);
+ 	if (inner_path != NULL)
+ 		append_where_clause(buf, context, inner_path, first);
+ }
+ 
+ /*
+  * Store qualified relation name into result.
+  */
+ static void
+ get_qualified_relname(Oid relid, StringInfo result)
+ {
+ 	ForeignTable   *ft;				/* foreign table to be scanned */
+ 	const char *nspname = NULL;		/* plain namespace name */
+ 	const char *relname = NULL;		/* plain relation name */
+ 	const char *q_nspname;			/* quoted namespace name */
+ 	const char *q_relname;			/* quoted relation name */
+ 
+ 	ft = GetForeignTable(relid);
+ 	if (ft->options != NIL)
+ 	{
+ 		ListCell	   *lc;
+ 
+ 		foreach (lc, ft->options)
+ 		{
+ 			DefElem	   *opt = lfirst(lc);
+ 			if (strcmp(opt->defname, "nspname") == 0)
+ 				nspname = strVal(opt->arg);
+ 			else if (strcmp(opt->defname, "relname") == 0)
+ 				relname = strVal(opt->arg);
+ 		}
+ 	}
+ 	if (nspname == NULL)
+ 		nspname = get_namespace_name(get_rel_namespace(relid));
+ 	if (relname == NULL)
+ 		relname = get_rel_name(relid);
+ 	q_nspname = quote_identifier(nspname);
+ 	q_relname = quote_identifier(relname);
+ 	appendStringInfo(result, "%s.%s", q_nspname, q_relname);
+ }
+ 
+ /*
+  * Deparse join representation into SQL statement which suits for remote
+  * PostgreSQL server.  See also deparseSql().
+  */
+ char *
+ deparseJoinSql(Oid serverid,
+ 			   PlannerInfo *root,
+ 			   RelOptInfo *joinrel,
+ 			   JoinType jointype,
+ 			   SpecialJoinInfo *sjinfo,
+ 			   Path *outer_path,
+ 			   Path *inner_path,
+ 			   List *restrict_clauses,
+ 			   List *pathkeys)
+ {
+ 	int				i;
+ 	List		   *rtables = NIL;
+ 	List		   *context;
+ 	StringInfoData	sql;
+ 	bool			first;
+ 	ListCell	   *lc;
+ 	Bitmapset	   *bms;
+ 
+ 	/*
+ 	 * First of all, check that this join can be pushed down.
+ 	 *
+ 	 * There are some redundancy such as duplicated attribute loop, but this
+ 	 * is necessary to avoid memory leak.
+ 	 */
+ 	foreach(lc, joinrel->reltargetlist)
+ 	{
+ 		Var	   *var = (Var *) lfirst(lc);
+ 		if (var->varattno < 0)
+ 			return NULL;
+ 	}
+ 
+ 	/* Create context used for deparsing this join. */
+ 	for (i = 1; i < root->simple_rel_array_size; i++)
+ 	{
+ 		rtables = lappend(rtables, copyObject(root->simple_rte_array[i]));
+ 	}
+ 	context = deparse_context_for_rtelist(rtables);
+ 
+ 	/* Initialize buffer. */
+ 	initStringInfo(&sql);
+ 
+ 	/* deparse SELECT clause */
+ 	/* TODO: replace unused references with NULL */
+ 	appendStringInfo(&sql, "SELECT ");
+ 	first = true;
+ 	foreach(lc, joinrel->reltargetlist)
+ 	{
+ 		Var	   *var = (Var *) lfirst(lc);
+ 		appendStringInfo(&sql, "%s%s", first ? "" : ", ",
+ 			deparse_expression((Node *) var, context, true, false));
+ 		first = false;
+ 	}
+ 
+ 	/* deparse FROM clause */
+ 	appendStringInfo(&sql, "\nFROM ");
+ 	bms = bms_copy(joinrel->relids);
+ 	first = true;
+ 	while (!bms_is_empty(bms))
+ 	{
+ 		int relid = bms_first_member(bms);
+ 		RangeTblEntry	   *rte = root->simple_rte_array[relid];
+ 
+ 		if (!first)
+ 			appendStringInfo(&sql, ", ");
+ 		get_qualified_relname(rte->relid, &sql);
+ 		appendStringInfo(&sql, " %s", rte->eref->aliasname);
+ 		first = false;
+ 	}
+ 
+ 	/* deparse WHERE clause */
+ 	appendStringInfo(&sql, "\nWHERE ");
+ 	first = true;
+ 	foreach(lc, restrict_clauses)
+ 	{
+ 		RestrictInfo   *ri  = (RestrictInfo *) lfirst(lc);
+ 
+ 		if (!first)
+ 			appendStringInfo(&sql, " AND ");
+ 		appendStringInfo(&sql, "%s",
+ 			deparse_expression((Node *) ri->clause, context, true, false));
+ 		first = false;
+ 	}
+ 	if (outer_path != NULL)
+ 		append_where_clause(&sql, context, outer_path, &first);
+ 	if (inner_path != NULL)
+ 		append_where_clause(&sql, context, inner_path, &first);
+ 
+ 	/* return constructed SQL statement. */
+ 	elog(DEBUG1, "deparsed join SQL: [%s]", sql.data);
+ 	return sql.data;
+ }
diff --git a/contrib/pgsql_fdw/pgsql_fdw.c b/contrib/pgsql_fdw/pgsql_fdw.c
index 61d20ee..564f45d 100644
*** a/contrib/pgsql_fdw/pgsql_fdw.c
--- b/contrib/pgsql_fdw/pgsql_fdw.c
*************** static void pgsqlBeginForeignScan(Foreig
*** 109,114 ****
--- 109,123 ----
  static TupleTableSlot *pgsqlIterateForeignScan(ForeignScanState *node);
  static void pgsqlReScanForeignScan(ForeignScanState *node);
  static void pgsqlEndForeignScan(ForeignScanState *node);
+ static FdwPlan *pgsqlPlanForeignJoin(Oid serverid,
+ 									 PlannerInfo *root,
+ 									 RelOptInfo *joinrel,
+ 									 JoinType jointype,
+ 									 SpecialJoinInfo *sjinfo,
+ 									 Path *outer_path,
+ 									 Path *inner_path,
+ 									 List *restrict_clauses,
+ 									 List *pathkeys);
  
  /*
   * Helper functions
*************** pgsql_fdw_handler(PG_FUNCTION_ARGS)
*** 141,188 ****
  	fdwroutine->ReScanForeignScan = pgsqlReScanForeignScan;
  	fdwroutine->EndForeignScan = pgsqlEndForeignScan;
  
  	PG_RETURN_POINTER(fdwroutine);
  }
  
  /*
!  * pgsqlPlanForeignScan
!  *		Create a FdwPlan for a scan on the foreign table
   */
! static FdwPlan *
! pgsqlPlanForeignScan(Oid foreigntableid,
! 					PlannerInfo *root,
! 					RelOptInfo *baserel)
  {
  	char			name[128];	/* must be larger than format + 10 */
  	StringInfoData	cursor;
  	const char	   *fetch_count_str;
  	int				fetch_count = DEFAULT_FETCH_COUNT;
- 	char		   *sql;
- 	FdwPlan		   *fdwplan;
  	List		   *fdw_private = NIL;
- 	ForeignTable   *table;
- 	ForeignServer  *server;
- 
- 	/* Construct FdwPlan with cost estimates */
- 	fdwplan = makeNode(FdwPlan);
- 	sql = deparseSql(foreigntableid, root, baserel);
- 	table = GetForeignTable(foreigntableid);
- 	server = GetForeignServer(table->serverid);
- 	estimate_costs(root, baserel, sql, server->serverid,
- 				   &fdwplan->startup_cost, &fdwplan->total_cost);
  
  	/*
  	 * Store plain SELECT statement in private area of FdwPlan.  This will be
  	 * used for executing remote query and explaining scan.
  	 */
! 	fdw_private = list_make1(makeString(sql));
  
  	/* Use specified fetch_count instead of default value, if any. */
! 	fetch_count_str = GetFdwOptionValue(InvalidOid, InvalidOid, foreigntableid,
  										InvalidAttrNumber, "fetch_count");
  	if (fetch_count_str != NULL)
  		fetch_count = strtol(fetch_count_str, NULL, 10);
! 	elog(DEBUG1, "relid=%u fetch_count=%d", foreigntableid, fetch_count);
  
  	/*
  	 * We store some more information in FdwPlan to pass them beyond the
--- 150,187 ----
  	fdwroutine->ReScanForeignScan = pgsqlReScanForeignScan;
  	fdwroutine->EndForeignScan = pgsqlEndForeignScan;
  
+ 	/* Optional handlers. */
+ 	fdwroutine->PlanForeignJoin = pgsqlPlanForeignJoin;
+ 
  	PG_RETURN_POINTER(fdwroutine);
  }
  
  /*
!  * Make list of private information which are specific to pgsql_fdw.
!  * Actual contents are:
!  *
   */
! static List *
! make_fdw_private(const char *sql, Oid serverid, Oid relid)
  {
  	char			name[128];	/* must be larger than format + 10 */
  	StringInfoData	cursor;
  	const char	   *fetch_count_str;
  	int				fetch_count = DEFAULT_FETCH_COUNT;
  	List		   *fdw_private = NIL;
  
  	/*
  	 * Store plain SELECT statement in private area of FdwPlan.  This will be
  	 * used for executing remote query and explaining scan.
  	 */
! 	fdw_private = list_make1(makeString(pstrdup(sql)));
  
  	/* Use specified fetch_count instead of default value, if any. */
! 	fetch_count_str = GetFdwOptionValue(InvalidOid, serverid, relid,
  										InvalidAttrNumber, "fetch_count");
  	if (fetch_count_str != NULL)
  		fetch_count = strtol(fetch_count_str, NULL, 10);
! 	elog(DEBUG1, "relid=%u fetch_count=%d", relid, fetch_count);
  
  	/*
  	 * We store some more information in FdwPlan to pass them beyond the
*************** pgsqlPlanForeignScan(Oid foreigntableid,
*** 224,231 ****
  	appendStringInfo(&cursor, "CLOSE %s", name);
  	fdw_private = lappend(fdw_private, makeString(cursor.data));
  
  	/* Store FDW private information into FdwPlan */
! 	fdwplan->fdw_private = fdw_private;
  
  	return fdwplan;
  }
--- 223,256 ----
  	appendStringInfo(&cursor, "CLOSE %s", name);
  	fdw_private = lappend(fdw_private, makeString(cursor.data));
  
+ 	return fdw_private;
+ }
+ 
+ /*
+  * pgsqlPlanForeignScan
+  *		Create a FdwPlan for a scan on the foreign table
+  */
+ static FdwPlan *
+ pgsqlPlanForeignScan(Oid foreigntableid,
+ 					PlannerInfo *root,
+ 					RelOptInfo *baserel)
+ {
+ 	char		   *sql;
+ 	FdwPlan		   *fdwplan;
+ 	ForeignTable   *table;
+ 	ForeignServer  *server;
+ 
+ 	/* Construct FdwPlan with cost estimates */
+ 	fdwplan = makeNode(FdwPlan);
+ 	sql = deparseSql(foreigntableid, root, baserel);
+ 	table = GetForeignTable(foreigntableid);
+ 	server = GetForeignServer(table->serverid);
+ 	estimate_costs(root, baserel, sql, server->serverid,
+ 				   &fdwplan->startup_cost, &fdwplan->total_cost);
+ 
  	/* Store FDW private information into FdwPlan */
! 	fdwplan->fdw_private = make_fdw_private(sql, table->serverid,
! 											foreigntableid);
  
  	return fdwplan;
  }
*************** pgsqlBeginForeignScan(ForeignScanState *
*** 254,261 ****
  {
  	PgsqlFdwExecutionState *festate;
  	PGconn		   *conn;
- 	Oid				relid;
- 	ForeignTable   *table;
  	ForeignServer  *server;
  	UserMapping	   *user;
  	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
--- 279,284 ----
*************** pgsqlBeginForeignScan(ForeignScanState *
*** 276,284 ****
  	 * Get connection to the foreign server.  Connection manager would
  	 * establish new connection if necessary.
  	 */
! 	relid = RelationGetRelid(node->ss.ss_currentRelation);
! 	table = GetForeignTable(relid);
! 	server = GetForeignServer(table->serverid);
  	user = GetUserMapping(GetOuterUserId(), server->serverid);
  	conn = GetConnection(server, user);
  	festate->conn = conn;
--- 299,305 ----
  	 * Get connection to the foreign server.  Connection manager would
  	 * establish new connection if necessary.
  	 */
! 	server = GetForeignServer(node->serverid);
  	user = GetUserMapping(GetOuterUserId(), server->serverid);
  	conn = GetConnection(server, user);
  	festate->conn = conn;
*************** pgsqlEndForeignScan(ForeignScanState *no
*** 501,506 ****
--- 522,577 ----
  }
  
  /*
+  * pgsqlPlanForeignJoin
+  *		Create a FdwPlan for a query which contains of join of foreign tables
+  */
+ static FdwPlan *
+ pgsqlPlanForeignJoin(Oid serverid,
+ 					 PlannerInfo *root,
+ 					 RelOptInfo *joinrel,
+ 					 JoinType jointype,
+ 					 SpecialJoinInfo *sjinfo,
+ 					 Path *outer_path,
+ 					 Path *inner_path,
+ 					 List *restrict_clauses,
+ 					 List *pathkeys)
+ {
+ 	FdwPlan	   *fdwplan = NULL;
+ 	char	   *sql;
+ 
+ 	Assert(joinrel->serverid != InvalidOid);
+ 	Assert(IsA(outer_path, ForeignPath) || IsA(outer_path, ForeignJoinPath));
+ 	Assert(IsA(inner_path, ForeignPath) || IsA(inner_path, ForeignJoinPath));
+ 
+ 	/*
+ 	 * In this first version, consider only inner join, because OUTER JOIN
+ 	 * might populate more result rows than summary of result of children.
+ 	 */
+ 	if (jointype != JOIN_INNER)
+ 		return NULL;
+ 
+ 	/*
+ 	 * Deparse join represention into SQL statement which retrieves whole
+ 	 * result of the join.  NULL means that pgsql_fdw can't push this join down
+ 	 * to remote side.
+ 	 */
+ 	sql = deparseJoinSql(serverid, root, joinrel, jointype, sjinfo,
+ 						 outer_path, inner_path, restrict_clauses, pathkeys);
+ 	if (sql == NULL)
+ 		return NULL;
+ 
+ 	fdwplan = makeNode(FdwPlan);
+ 	fdwplan->startup_cost = 0.0;
+ 	fdwplan->total_cost = 0.0;
+ 	/* TODO estimate cost by executing EXPLAIN on remote side. */
+ 	estimate_costs(root, joinrel, sql, serverid, &fdwplan->startup_cost,
+ 				   &fdwplan->total_cost);
+ 	fdwplan->fdw_private = make_fdw_private(sql, serverid, InvalidOid);
+ 
+ 	return fdwplan;
+ }
+ 
+ /*
   * Estimate costs of scanning a foreign table.
   */
  static void
*************** estimate_costs(PlannerInfo *root, RelOpt
*** 526,535 ****
--- 597,609 ----
  	 * tend to choose custom plan.
  	 *
  	 * See comments in plancache.c for details of custom plan.
+ 	 *
+ 	 * TODO check this in deparse*Sql(), and receive a flag.
  	 */
  	foreach(lc, baserel->baserestrictinfo)
  	{
  		RestrictInfo	   *rs = (RestrictInfo *) lfirst(lc);
+ 
  		if (contain_ext_param((Node *) rs->clause))
  		{
  			*startup_cost = CONNECTION_COSTS;
diff --git a/contrib/pgsql_fdw/pgsql_fdw.h b/contrib/pgsql_fdw/pgsql_fdw.h
index fb49ffb..e0c3ee2 100644
*** a/contrib/pgsql_fdw/pgsql_fdw.h
--- b/contrib/pgsql_fdw/pgsql_fdw.h
*************** int ExtractConnectionOptions(List *defel
*** 24,28 ****
--- 24,37 ----
  
  /* in deparse.c */
  char *deparseSql(Oid relid, PlannerInfo *root, RelOptInfo *baserel);
+ char *deparseJoinSql(Oid serverid,
+ 					 PlannerInfo *root,
+ 					 RelOptInfo *joinrel,
+ 					 JoinType jointype,
+ 					 SpecialJoinInfo *sjinfo,
+ 					 Path *outer_path,
+ 					 Path *inner_path,
+ 					 List *restrict_clauses,
+ 					 List *pathkeys);
  
  #endif /* PGSQL_FDW_H */
diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index d1e628f..78c5f39 100644
*** a/doc/src/sgml/config.sgml
--- b/doc/src/sgml/config.sgml
*************** SET ENABLE_SEQSCAN TO OFF;
*** 2362,2367 ****
--- 2362,2380 ----
        </listitem>
       </varlistentry>
  
+      <varlistentry id="guc-enable-foreignjoin" xreflabel="enable_foreignjoin">
+       <term><varname>enable_foreignjoin</varname> (<type>boolean</type>)</term>
+       <indexterm>
+        <primary><varname>enable_foreignjoin</> configuration parameter</primary>
+       </indexterm>
+       <listitem>
+        <para>
+         Enables or disables the query planner's use of foreign-join plan
+         types. The default is <literal>on</>.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
       <varlistentry id="guc-enable-hashagg" xreflabel="enable_hashagg">
        <term><varname>enable_hashagg</varname> (<type>boolean</type>)</term>
        <indexterm>
diff --git a/doc/src/sgml/fdwhandler.sgml b/doc/src/sgml/fdwhandler.sgml
index d809cac..7e3c5bd 100644
*** a/doc/src/sgml/fdwhandler.sgml
--- b/doc/src/sgml/fdwhandler.sgml
*************** EndForeignScan (ForeignScanState *node);
*** 228,233 ****
--- 228,273 ----
      </para>
  
      <para>
+      Callback functions above are required for every foreign data wrappers.
+      In contrast, callback functions below are optional, so you can set each of
+      them to NULL to tell the planner and/or executor that the FDW doesn't
+      support the feature.  Actually, in such case, you don't have to set NULL
+      explicitly because <function>makeNode</function> has already initialized
+      them to NULL.
+     </para>
+ 
+     <para>
+ <programlisting>
+ FdwPlan *
+ PlanForeignJoin (Oid serverid,
+                  PlannerInfo *root,
+                  RelOptInfo *joinrel,
+                  JoinType jointype,
+                  SpecialJoinInfo *sjinfo,
+                  Path *outer_path,
+                  Path *inner_path,
+                  List *restrict_clauses,
+                  List *pathkeys);
+ </programlisting>
+ 
+      Plan a join between two foreign scans performed on same server.  In this
+      context, a foreign scans can be a simple foreign table reference planned
+      by <function>PlanForeignScan</function>, or a result of a foreign join
+      planned by <function>PlanForeignJoin</function>.
+      Arguments <literal>outer_path</literal> and <literal>inner_path</literal>
+      provide details of each child nodes, and other arguments provide details
+      of the join itself.
+     </para>
+ 
+     <para>
+      This function is called during planning to determine whether foreign join
+      can be pushed down.  FDW can use private area of
+      <structname>FdwPlan</structname>, similarly to
+      <function>PlanForeignScan</function>, to store FDW-specific information
+      which are needed to get result of the join.
+     </para>
+ 
+     <para>
       The <structname>FdwRoutine</> and <structname>FdwPlan</> struct types
       are declared in <filename>src/include/foreign/fdwapi.h</>, which see
       for additional details.
*************** GetForeignTable(Oid relid);
*** 298,303 ****
--- 338,362 ----
  
      <para>
  <programlisting>
+ char *
+ GetFdwOptionValue(Oid relid, AttrNumber attnum, const char *optname);
+ </programlisting>
+ 
+      This function returns a copy (created in current memory context) of the
+      value of the given option for the given object (relation or its column).
+      If attnum is InvalidAttrNumber, pg_attribute is ignored.
+      If specified option is set in multiple object level, the one in the
+      finest-grained object is used; e.g. priority is given to user mapping 
+      over than a foreign server for the mapping or foreign-data wrapper for the
+      server.
+      This function would be useful when you know which option is needed but you
+      don't know which object(s) have it.
+      If you already know the source object, it would be more efficient to use
+      object retrieval functions.
+     </para>
+ 
+     <para>
+ <programlisting>
  List *
  GetForeignTableColumnOptions(Oid relid, AttrNumber attnum);
  </programlisting>
*************** GetForeignServerByName(const char *name,
*** 334,388 ****
      </para>
  
      <para>
- <programlisting>
- char *
- GetFdwOptionValue(Oid fdwid, Oid serverid, Oid relid, AttrNumber attnum, const char *optname);
- </programlisting>
- 
-      This function returns a copied string (created in current memory context)
-      of the value of a FDW option with given name which is set on a object with
-      given oid and attribute number.  This function ignores catalogs if invalid
-      identifir is given for it.
- 
-      <itemizedlist>
-       <listitem>
-        <para>
-         If attnum is <literal>InvalidAttrNumber</literal> or relid is
-         <literal>Invalidoid</literal>, <structname>pg_attribute</structname> is
-         ignored.
-        </para>
-       </listitem>
-       <listitem>
-        <para>
-         If relid is <literal>InvalidOid</literal>,
-         <structname>pg_foreign_table</structname> is ignored.
-        </para>
-       </listitem>
-       <listitem>
-        <para>
-         If both serverid and relid are <literal>InvalidOid</literal>,
-         <structname>pg_foreign_server</structname> is ignored.
-        </para>
-       </listitem>
-       <listitem>
-        <para>
-         If all of fdwid, serverid and relid are <literal>InvalidOid</literal>,
-         <structname>pg_foreign_data_wrapper</structname> is ignored.
-        </para>
-       </listitem>
-      </itemizedlist>
-     </para>
- 
-     <para>
-      If the option with given name is set in multiple object level, the one in
-      the finest-grained object is used; e.g. priority is given to user mappings 
-      over than foreign servers.
-      This function would be useful when you know which option is needed but you
-      don't know where it is set.  If you already know the source object, it
-      would be more efficient to use object retrieval functions.
-     </para>
- 
-     <para>
       To use any of these functions, you need to include
       <filename>foreign/foreign.h</filename> in your source file.
      </para>
--- 393,398 ----
diff --git a/doc/src/sgml/ref/postgres-ref.sgml b/doc/src/sgml/ref/postgres-ref.sgml
index 9869a1f..d785c2f 100644
*** a/doc/src/sgml/ref/postgres-ref.sgml
--- b/doc/src/sgml/ref/postgres-ref.sgml
*************** PostgreSQL documentation
*** 376,382 ****
  
      <variablelist>
       <varlistentry>
!       <term><option>-f</option> <literal>{ s | i | o | b | t | n | m | h }</literal></term>
        <listitem>
         <para>
          Forbids the use of particular scan and join methods:
--- 376,382 ----
  
      <variablelist>
       <varlistentry>
!       <term><option>-f</option> <literal>{ s | i | o | b | t | n | m | h | f }</literal></term>
        <listitem>
         <para>
          Forbids the use of particular scan and join methods:
*************** PostgreSQL documentation
*** 385,392 ****
          <literal>o</literal>, <literal>b</literal> and <literal>t</literal>
          disable index-only scans, bitmap index scans, and TID scans
          respectively, while
!         <literal>n</literal>, <literal>m</literal>, and <literal>h</literal>
!         disable nested-loop, merge and hash joins respectively.
         </para>
  
         <para>
--- 385,393 ----
          <literal>o</literal>, <literal>b</literal> and <literal>t</literal>
          disable index-only scans, bitmap index scans, and TID scans
          respectively, while
!         <literal>n</literal>, <literal>m</literal>, <literal>h</literal>, and
!         <literal>f</literal> disable nested-loop, merge joins, hash joins, and
!         foreign joins respectively.
         </para>
  
         <para>
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index e38de5c..86e0203 100644
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
*************** static const char *explain_get_index_nam
*** 82,87 ****
--- 82,88 ----
  static void ExplainIndexScanDetails(Oid indexid, ScanDirection indexorderdir,
  						ExplainState *es);
  static void ExplainScanTarget(Scan *plan, ExplainState *es);
+ static void ExplainForeignScanTarget(Scan *plan, ExplainState *es);
  static void ExplainModifyTarget(ModifyTable *plan, ExplainState *es);
  static void ExplainTargetRel(Plan *plan, Index rti, ExplainState *es);
  static void ExplainMemberNodes(List *plans, PlanState **planstates,
*************** ExplainNode(PlanState *planstate, List *
*** 803,811 ****
  		case T_ValuesScan:
  		case T_CteScan:
  		case T_WorkTableScan:
- 		case T_ForeignScan:
  			ExplainScanTarget((Scan *) plan, es);
  			break;
  		case T_IndexScan:
  			{
  				IndexScan  *indexscan = (IndexScan *) plan;
--- 804,814 ----
  		case T_ValuesScan:
  		case T_CteScan:
  		case T_WorkTableScan:
  			ExplainScanTarget((Scan *) plan, es);
  			break;
+ 		case T_ForeignScan:
+ 			ExplainForeignScanTarget((Scan *) plan, es);
+ 			break;
  		case T_IndexScan:
  			{
  				IndexScan  *indexscan = (IndexScan *) plan;
*************** ExplainScanTarget(Scan *plan, ExplainSta
*** 1674,1679 ****
--- 1677,1702 ----
  }
  
  /*
+  * Show the target of a ForeignScan node
+  */
+ static void
+ ExplainForeignScanTarget(Scan *plan, ExplainState *es)
+ {
+ 	Assert(IsA(plan, ForeignScan));
+ 
+ 	/*
+ 	 * If scan target is an foreign table, show in normal scan format,
+ 	 * otherwise, show in specific format.
+ 	 */
+ 	if (plan->scanrelid > 0)
+ 		ExplainTargetRel((Plan *) plan, plan->scanrelid, es);
+ 	else
+ 	{
+ 		appendStringInfo(es->str, " on multiple foreign tables");
+ 	}
+ }
+ 
+ /*
   * Show the target of a ModifyTable node
   */
  static void
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 65591e2..e7adb74 100644
*** a/src/backend/executor/execUtils.c
--- b/src/backend/executor/execUtils.c
*************** ExecAssignScanTypeFromOuterPlan(ScanStat
*** 760,765 ****
--- 760,790 ----
  	ExecAssignScanType(scanstate, tupDesc);
  }
  
+ /* ----------------
+  *		ExecAssignScanTypeFromTL
+  * ----------------
+  */
+ void
+ ExecAssignScanTypeFromTL(ScanState *scanstate)
+ {
+ 	bool			hasoid;
+ 	TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
+ 	TupleDesc		tupDesc;
+ 
+ 	if (ExecContextForcesOids(&scanstate->ps, &hasoid))
+ 	{
+ 		/* context forces OID choice; hasoid is now set correctly */
+ 	}
+ 	else
+ 	{
+ 		/* given free choice, don't leave space for OIDs in result tuples */
+ 		hasoid = false;
+ 	}
+ 
+ 	tupDesc = ExecTypeFromTL(scanstate->ps.plan->targetlist, hasoid);
+ 	ExecSetSlotDescriptor(slot, tupDesc);
+ }
+ 
  
  /* ----------------------------------------------------------------
   *				  Scan node support
diff --git a/src/backend/executor/nodeForeignscan.c b/src/backend/executor/nodeForeignscan.c
index 841ae69..4bf6d6c 100644
*** a/src/backend/executor/nodeForeignscan.c
--- b/src/backend/executor/nodeForeignscan.c
***************
*** 25,30 ****
--- 25,31 ----
  #include "executor/executor.h"
  #include "executor/nodeForeignscan.h"
  #include "foreign/fdwapi.h"
+ #include "foreign/foreign.h"
  #include "utils/rel.h"
  
  static TupleTableSlot *ForeignNext(ForeignScanState *node);
*************** ExecForeignScan(ForeignScanState *node)
*** 101,109 ****
  ForeignScanState *
  ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  {
! 	ForeignScanState *scanstate;
! 	Relation	currentRelation;
! 	FdwRoutine *fdwroutine;
  
  	/* check for unsupported flags */
  	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
--- 102,112 ----
  ForeignScanState *
  ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  {
! 	ForeignScanState   *scanstate;
! 	Relation			currentRelation;
! 	ForeignServer	   *server;
! 	ForeignDataWrapper *wrapper;
! 	FdwRoutine		   *fdwroutine;
  
  	/* check for unsupported flags */
  	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
*************** ExecInitForeignScan(ForeignScan *node, E
*** 140,166 ****
  	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);
  	ExecInitScanTupleSlot(estate, &scanstate->ss);
  
! 	/*
! 	 * open the base relation and acquire appropriate lock on it.
! 	 */
! 	currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid);
! 	scanstate->ss.ss_currentRelation = currentRelation;
  
! 	/*
! 	 * get the scan type from the relation descriptor.
! 	 */
! 	ExecAssignScanType(&scanstate->ss, RelationGetDescr(currentRelation));
  
! 	/*
! 	 * Initialize result tuple type and projection info.
! 	 */
! 	ExecAssignResultTypeFromTL(&scanstate->ss.ps);
! 	ExecAssignScanProjectionInfo(&scanstate->ss);
  
  	/*
  	 * Acquire function pointers from the FDW's handler, and init fdw_state.
  	 */
! 	fdwroutine = GetFdwRoutineByRelId(RelationGetRelid(currentRelation));
  	scanstate->fdwroutine = fdwroutine;
  	scanstate->fdw_state = NULL;
  
--- 143,193 ----
  	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);
  	ExecInitScanTupleSlot(estate, &scanstate->ss);
  
! 	if (node->scan.scanrelid != InvalidOid)
! 	{
! 		/*
! 		 * open the base relation and acquire appropriate lock on it.
! 		 */
! 		currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid);
! 		scanstate->ss.ss_currentRelation = currentRelation;
  
! 		/*
! 		 * get the scan type from the relation descriptor.
! 		 */
! 		ExecAssignScanType(&scanstate->ss, RelationGetDescr(currentRelation));
  
! 		/*
! 		 * Initialize result tuple type and projection info.
! 		 */
! 		ExecAssignResultTypeFromTL(&scanstate->ss.ps);
! 		ExecAssignScanProjectionInfo(&scanstate->ss);
! 	}
! 	else
! 	{
! 		/* TODO: open related relations and acquire appropriate lock on them. */
! 		scanstate->ss.ss_currentRelation = NULL;
! 
! 		/*
! 		 * get the scan type from the target list.
! 		 */
! 		ExecAssignScanTypeFromTL(&scanstate->ss);
! 
! 		/*
! 		 * Initialize result tuple type and projection info.
! 		 */
! 		ExecAssignResultTypeFromTL(&scanstate->ss.ps);
! 		ExecAssignProjectionInfo(&scanstate->ss.ps, NULL);
! 	}
! 
! 	/* We know which server should be use. */
! 	scanstate->serverid = node->serverid;
  
  	/*
  	 * Acquire function pointers from the FDW's handler, and init fdw_state.
  	 */
! 	server = GetForeignServer(node->serverid);
! 	wrapper = GetForeignDataWrapper(server->fdwid);
! 	fdwroutine = GetFdwRoutine(wrapper->fdwhandler);
  	scanstate->fdwroutine = fdwroutine;
  	scanstate->fdw_state = NULL;
  
*************** ExecEndForeignScan(ForeignScanState *nod
*** 192,198 ****
  	ExecClearTuple(node->ss.ss_ScanTupleSlot);
  
  	/* close the relation. */
! 	ExecCloseScanRelation(node->ss.ss_currentRelation);
  }
  
  /* ----------------------------------------------------------------
--- 219,226 ----
  	ExecClearTuple(node->ss.ss_ScanTupleSlot);
  
  	/* close the relation. */
! 	if (node->ss.ss_currentRelation != NULL)
! 		ExecCloseScanRelation(node->ss.ss_currentRelation);
  }
  
  /* ----------------------------------------------------------------
diff --git a/src/backend/foreign/foreign.c b/src/backend/foreign/foreign.c
index b984a5e..7c77847 100644
*** a/src/backend/foreign/foreign.c
--- b/src/backend/foreign/foreign.c
*************** GetFdwOptionValue(Oid fdwid, Oid serveri
*** 292,299 ****
  	ForeignDataWrapper  *wrapper = NULL;
  	char		   *value;
  
! 	/* Do we need to search pg_attribute? */
! 	if (attnum != InvalidAttrNumber && relid != InvalidOid)
  	{
  		value = get_options_value(GetForeignColumnOptions(relid, attnum),
  								  optname);
--- 292,299 ----
  	ForeignDataWrapper  *wrapper = NULL;
  	char		   *value;
  
! 	/* Do we need to use pg_attribute.attfdwoptions too? */
! 	if (attnum != InvalidAttrNumber)
  	{
  		value = get_options_value(GetForeignColumnOptions(relid, attnum),
  								  optname);
*************** GetFdwOptionValue(Oid fdwid, Oid serveri
*** 301,334 ****
  			return value;
  	}
  
- 	/* Do we need to search pg_foreign_table? */
  	if (relid != InvalidOid)
  	{
  		table = GetForeignTable(relid);
  		value = get_options_value(table->options, optname);
  		if (value != NULL)
  			return value;
- 
  		serverid = table->serverid;
  	}
  
- 	/* Do we need to search pg_user_mapping and pg_foreign_server? */
  	if (serverid != InvalidOid)
  	{
  		user = GetUserMapping(GetOuterUserId(), serverid);
  		value = get_options_value(user->options, optname);
  		if (value != NULL)
  			return value;
  
  		server = GetForeignServer(serverid);
  		value = get_options_value(server->options, optname);
  		if (value != NULL)
  			return value;
- 
  		fdwid = server->fdwid;
  	}
  
- 	/* Do we need to search pg_foreign_data_wrapper? */
  	if (fdwid != InvalidOid)
  	{
  		wrapper = GetForeignDataWrapper(fdwid);
--- 301,332 ----
  			return value;
  	}
  
  	if (relid != InvalidOid)
  	{
  		table = GetForeignTable(relid);
  		value = get_options_value(table->options, optname);
  		if (value != NULL)
  			return value;
  		serverid = table->serverid;
  	}
  
  	if (serverid != InvalidOid)
  	{
  		user = GetUserMapping(GetOuterUserId(), serverid);
  		value = get_options_value(user->options, optname);
  		if (value != NULL)
  			return value;
+ 	}
  
+ 	if (serverid != InvalidOid)
+ 	{
  		server = GetForeignServer(serverid);
  		value = get_options_value(server->options, optname);
  		if (value != NULL)
  			return value;
  		fdwid = server->fdwid;
  	}
  
  	if (fdwid != InvalidOid)
  	{
  		wrapper = GetForeignDataWrapper(fdwid);
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 63958c3..df3f25a 100644
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
*************** _copyForeignScan(ForeignScan *from)
*** 590,595 ****
--- 590,596 ----
  	/*
  	 * copy remainder of node
  	 */
+ 	COPY_SCALAR_FIELD(serverid);
  	COPY_SCALAR_FIELD(fsSystemCol);
  	COPY_NODE_FIELD(fdwplan);
  
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index f7d39ed..85f4071 100644
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
*************** _outForeignScan(StringInfo str, ForeignS
*** 557,562 ****
--- 557,563 ----
  
  	_outScanInfo(str, (Scan *) node);
  
+ 	WRITE_OID_FIELD(serverid);
  	WRITE_BOOL_FIELD(fsSystemCol);
  	WRITE_NODE_FIELD(fdwplan);
  }
*************** _outHashPath(StringInfo str, HashPath *n
*** 1661,1666 ****
--- 1662,1677 ----
  }
  
  static void
+ _outForeignJoinPath(StringInfo str, ForeignJoinPath *node)
+ {
+ 	WRITE_NODE_TYPE("FOREIGNJOINPATH");
+ 
+ 	_outJoinPathInfo(str, (JoinPath *) node);
+ 
+ 	WRITE_NODE_FIELD(fdwplan);
+ }
+ 
+ static void
  _outPlannerGlobal(StringInfo str, PlannerGlobal *node)
  {
  	WRITE_NODE_TYPE("PLANNERGLOBAL");
*************** _outRelOptInfo(StringInfo str, RelOptInf
*** 1749,1754 ****
--- 1760,1766 ----
  	WRITE_NODE_FIELD(baserestrictinfo);
  	WRITE_NODE_FIELD(joininfo);
  	WRITE_BOOL_FIELD(has_eclass_joins);
+ 	WRITE_OID_FIELD(serverid);
  	WRITE_BITMAPSET_FIELD(index_outer_relids);
  	WRITE_NODE_FIELD(index_inner_paths);
  }
*************** _outNode(StringInfo str, void *obj)
*** 2987,2992 ****
--- 2999,3007 ----
  			case T_HashPath:
  				_outHashPath(str, obj);
  				break;
+ 			case T_ForeignJoinPath:
+ 				_outForeignJoinPath(str, obj);
+ 				break;
  			case T_PlannerGlobal:
  				_outPlannerGlobal(str, obj);
  				break;
diff --git a/src/backend/optimizer/README b/src/backend/optimizer/README
index aaa754c..f06cb27 100644
*** a/src/backend/optimizer/README
--- b/src/backend/optimizer/README
*************** RelOptInfo      - a relation or joined r
*** 356,361 ****
--- 356,362 ----
    NestPath      - nested-loop joins
    MergePath     - merge joins
    HashPath      - hash joins
+   ForeignJoinPath - foreign joins
  
   EquivalenceClass - a data structure representing a set of values known equal
  
diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 815b996..17b8cbe 100644
*** a/src/backend/optimizer/path/allpaths.c
--- b/src/backend/optimizer/path/allpaths.c
*************** print_path(PlannerInfo *root, Path *path
*** 1610,1615 ****
--- 1610,1619 ----
  			ptype = "HashJoin";
  			join = true;
  			break;
+ 		case T_ForeignJoinPath:
+ 			ptype = "ForeignJoin";
+ 			join = true;
+ 			break;
  		default:
  			ptype = "???Path";
  			break;
diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index 348c36b..def47ee 100644
*** a/src/backend/optimizer/path/costsize.c
--- b/src/backend/optimizer/path/costsize.c
*************** bool		enable_nestloop = true;
*** 119,124 ****
--- 119,125 ----
  bool		enable_material = true;
  bool		enable_mergejoin = true;
  bool		enable_hashjoin = true;
+ bool		enable_foreignjoin = true;
  
  typedef struct
  {
*************** cost_mergejoin(MergePath *path, PlannerI
*** 2100,2105 ****
--- 2101,2111 ----
  }
  
  /*
+  * cost_foreignjoin() is not defined here because the costs of a foreign join
+  * is estimated by each FDW via PlanForeignJoin.
+  */
+ 
+ /*
   * run mergejoinscansel() with caching
   */
  static MergeScanSelCache *
diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c
index 7d3cf42..3024565 100644
*** a/src/backend/optimizer/path/joinpath.c
--- b/src/backend/optimizer/path/joinpath.c
*************** match_unsorted_outer(PlannerInfo *root,
*** 541,546 ****
--- 541,566 ----
  											  merge_pathkeys));
  		}
  
+ 		if (enable_foreignjoin &&
+ 			joinrel->serverid != InvalidOid &&
+ 			(IsA(outerpath, ForeignPath) || IsA(outerpath, ForeignJoinPath)) &&
+ 			(IsA(inner_cheapest_total, ForeignPath) ||
+ 			 IsA(inner_cheapest_total, ForeignJoinPath)))
+ 
+ 		{
+ 			ForeignJoinPath	   *path;
+ 			path = create_foreignjoin_path(root,
+ 										   joinrel,
+ 										   jointype,
+ 										   sjinfo,
+ 										   outerpath,
+ 										   inner_cheapest_total,
+ 										   restrictlist,
+ 										   merge_pathkeys);
+ 			if (path != NULL)
+ 				add_path(joinrel, (Path *) path);
+ 		}
+ 
  		/* Can't do anything else if outer path needs to be unique'd */
  		if (save_jointype == JOIN_UNIQUE_OUTER)
  			continue;
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 8138b01..8a1f1c7 100644
*** a/src/backend/optimizer/plan/createplan.c
--- b/src/backend/optimizer/plan/createplan.c
*************** static WorkTableScan *create_worktablesc
*** 75,80 ****
--- 75,82 ----
  						  List *tlist, List *scan_clauses);
  static ForeignScan *create_foreignscan_plan(PlannerInfo *root, ForeignPath *best_path,
  						List *tlist, List *scan_clauses);
+ static ForeignScan *create_foreignjoin_plan(PlannerInfo *root, ForeignJoinPath *best_path,
+ 						List *tlist, List *scan_clauses);
  static NestLoop *create_nestloop_plan(PlannerInfo *root, NestPath *best_path,
  					 Plan *outer_plan, Plan *inner_plan);
  static MergeJoin *create_mergejoin_plan(PlannerInfo *root, MergePath *best_path,
*************** static CteScan *make_ctescan(List *qptli
*** 123,129 ****
  static WorkTableScan *make_worktablescan(List *qptlist, List *qpqual,
  				   Index scanrelid, int wtParam);
  static ForeignScan *make_foreignscan(List *qptlist, List *qpqual,
! 				 Index scanrelid, bool fsSystemCol, FdwPlan *fdwplan);
  static BitmapAnd *make_bitmap_and(List *bitmapplans);
  static BitmapOr *make_bitmap_or(List *bitmapplans);
  static NestLoop *make_nestloop(List *tlist,
--- 125,132 ----
  static WorkTableScan *make_worktablescan(List *qptlist, List *qpqual,
  				   Index scanrelid, int wtParam);
  static ForeignScan *make_foreignscan(List *qptlist, List *qpqual,
! 				 Index scanrelid, Oid serverid, bool fsSystemCol,
! 				 FdwPlan *fdwplan);
  static BitmapAnd *make_bitmap_and(List *bitmapplans);
  static BitmapOr *make_bitmap_or(List *bitmapplans);
  static NestLoop *make_nestloop(List *tlist,
*************** create_plan_recurse(PlannerInfo *root, P
*** 221,226 ****
--- 224,230 ----
  		case T_CteScan:
  		case T_WorkTableScan:
  		case T_ForeignScan:
+ 		case T_ForeignJoin:		/* ForeignJoinPath become a ForeignScan */
  			plan = create_scan_plan(root, best_path);
  			break;
  		case T_HashJoin:
*************** create_scan_plan(PlannerInfo *root, Path
*** 385,390 ****
--- 389,401 ----
  													scan_clauses);
  			break;
  
+ 		case T_ForeignJoin:
+ 			plan = (Plan *) create_foreignjoin_plan(root,
+ 													(ForeignJoinPath *) best_path,
+ 													tlist,
+ 													scan_clauses);
+ 			break;
+ 
  		default:
  			elog(ERROR, "unrecognized node type: %d",
  				 (int) best_path->pathtype);
*************** create_foreignscan_plan(PlannerInfo *roo
*** 1856,1861 ****
--- 1867,1873 ----
  	scan_plan = make_foreignscan(tlist,
  								 scan_clauses,
  								 scan_relid,
+ 								 rel->serverid,
  								 fsSystemCol,
  								 best_path->fdwplan);
  
*************** create_foreignscan_plan(PlannerInfo *roo
*** 1864,1869 ****
--- 1876,1926 ----
  	return scan_plan;
  }
  
+ /*
+  * create_foreignjoin_plan
+  *	 Returns a foreignscan plan for the join relation joined by 'best_path'
+  *	 with restriction clauses 'scan_clauses' and targetlist 'tlist'.
+  */
+ static ForeignScan *
+ create_foreignjoin_plan(PlannerInfo *root, ForeignJoinPath *best_path,
+ 						List *tlist, List *scan_clauses)
+ {
+ 	ForeignScan *scan_plan;
+ 	RelOptInfo *rel = best_path->jpath.path.parent;
+ 	Index		scan_relid = rel->relid;
+ 	bool		fsSystemCol;
+ 
+ 	/* Sort clauses into best execution order */
+ 	scan_clauses = order_qual_clauses(root, scan_clauses);
+ 
+ 	/* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
+ 	scan_clauses = extract_actual_clauses(scan_clauses, false);
+ 
+ 	fsSystemCol = false;
+ #ifdef NOT_USED
+ 	/* Detect whether any system columns are requested from rel */
+ 	for (i = rel->min_attr; i < 0; i++)
+ 	{
+ 		if (!bms_is_empty(rel->attr_needed[i - rel->min_attr]))
+ 		{
+ 			fsSystemCol = true;
+ 			break;
+ 		}
+ 	}
+ #endif
+ 
+ 	scan_plan = make_foreignscan(tlist,
+ 								 scan_clauses,
+ 								 scan_relid,
+ 								 rel->serverid,
+ 								 fsSystemCol,
+ 								 best_path->fdwplan);
+ 
+ 	copy_path_costsize(&scan_plan->scan.plan, &best_path->jpath.path);
+ 
+ 	return scan_plan;
+ }
+ 
  
  /*****************************************************************************
   *
*************** static ForeignScan *
*** 3170,3175 ****
--- 3227,3233 ----
  make_foreignscan(List *qptlist,
  				 List *qpqual,
  				 Index scanrelid,
+ 				 Oid serverid,
  				 bool fsSystemCol,
  				 FdwPlan *fdwplan)
  {
*************** make_foreignscan(List *qptlist,
*** 3182,3187 ****
--- 3240,3246 ----
  	plan->lefttree = NULL;
  	plan->righttree = NULL;
  	node->scan.scanrelid = scanrelid;
+ 	node->serverid = serverid;
  	node->fsSystemCol = fsSystemCol;
  	node->fdwplan = fdwplan;
  
diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 1e7aac9..ea5095b 100644
*** a/src/backend/optimizer/util/pathnode.c
--- b/src/backend/optimizer/util/pathnode.c
***************
*** 17,22 ****
--- 17,23 ----
  #include <math.h>
  
  #include "foreign/fdwapi.h"
+ #include "foreign/foreign.h"
  #include "miscadmin.h"
  #include "nodes/nodeFuncs.h"
  #include "optimizer/clauses.h"
*************** create_hashjoin_path(PlannerInfo *root,
*** 1629,1631 ****
--- 1630,1712 ----
  
  	return pathnode;
  }
+ 
+ /*
+  * create_foreignjoin_path
+  *	  Creates a pathnode corresponding to a foreign join between two
+  *	  relations.
+  *
+  * 'joinrel' is the join relation.
+  * 'jointype' is the type of join required
+  * 'sjinfo' is extra info about the join for selectivity estimation
+  * 'outer_path' is the outer path
+  * 'inner_path' is the inner path
+  * 'restrict_clauses' are the RestrictInfo nodes to apply at the join
+  * 'pathkeys' are the path keys of the new join path
+  *
+  * Returns the resulting path node, or NULL to indicate that this path is
+  * unavailable.
+  */
+ ForeignJoinPath *
+ create_foreignjoin_path(PlannerInfo *root,
+ 						RelOptInfo *joinrel,
+ 						JoinType jointype,
+ 						SpecialJoinInfo *sjinfo,
+ 						Path *outer_path,
+ 						Path *inner_path,
+ 						List *restrict_clauses,
+ 						List *pathkeys)
+ {
+ 	ForeignJoinPath	   *pathnode;
+ 	ForeignServer	   *server;
+ 	ForeignDataWrapper *wrapper;
+ 	FdwRoutine		   *fdwroutine;
+ 	FdwPlan			   *fdwplan;
+ 
+ 	/* Both outer and inner of this join must come from same foreign server. */
+ 	Assert(IsA(outer_path, ForeignPath) || IsA(outer_path, ForeignJoinPath));
+ 	Assert(IsA(inner_path, ForeignPath) || IsA(inner_path, ForeignJoinPath));
+ 
+ 	/*
+ 	 * First we try to get FDW's callback info.  If the FDW has planner for
+ 	 * foreign join, let the FDW plan this join.
+ 	 */
+ 	server = GetForeignServer(joinrel->serverid);
+ 	wrapper = GetForeignDataWrapper(server->fdwid);
+ 	fdwroutine = GetFdwRoutine(wrapper->fdwhandler);
+ 	if (fdwroutine->PlanForeignJoin == NULL)
+ 		return NULL;
+ 
+ 	fdwplan = fdwroutine->PlanForeignJoin(joinrel->serverid,
+ 										  root,
+ 										  joinrel,
+ 										  jointype,
+ 										  sjinfo,
+ 										  outer_path,
+ 										  inner_path,
+ 										  restrict_clauses,
+ 										  pathkeys);
+ 	/* Returning NULL indicates that the FDW can't handle this join. */
+ 	if (fdwplan == NULL)
+ 		return NULL;
+ 	Assert(IsA(fdwplan, FdwPlan));
+ 
+ 	/* OK, this FDW can handle this join. */
+ 	pathnode = makeNode(ForeignJoinPath);
+ 	pathnode->jpath.path.pathtype = T_ForeignJoin;
+ 	pathnode->jpath.path.parent = joinrel;
+ 	pathnode->jpath.jointype = jointype;
+ 	pathnode->jpath.outerjoinpath = outer_path;
+ 	pathnode->jpath.innerjoinpath = inner_path;
+ 	pathnode->jpath.joinrestrictinfo = restrict_clauses;
+ 	pathnode->jpath.path.pathkeys = pathkeys;
+ 
+ 	/* Use costs estimated by FDW */
+ 	pathnode->jpath.path.startup_cost = fdwplan->startup_cost;
+ 	pathnode->jpath.path.total_cost = fdwplan->total_cost;
+ 
+ 	/* Store FDW-private information too. */
+ 	pathnode->fdwplan = fdwplan;
+ 
+ 	return pathnode;
+ }
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index de629e9..d69be69 100644
*** a/src/backend/optimizer/util/plancat.c
--- b/src/backend/optimizer/util/plancat.c
***************
*** 22,27 ****
--- 22,28 ----
  #include "access/sysattr.h"
  #include "access/transam.h"
  #include "catalog/catalog.h"
+ #include "foreign/foreign.h"
  #include "catalog/heap.h"
  #include "miscadmin.h"
  #include "nodes/makefuncs.h"
*************** get_relation_info(PlannerInfo *root, Oid
*** 359,364 ****
--- 360,374 ----
  
  	rel->indexlist = indexinfos;
  
+ 	/* Get server oid for further planning, if this is a foreign table. */
+ 	if (relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
+ 	{
+ 		ForeignTable   *table;
+ 
+ 		table = GetForeignTable(relationObjectId);
+ 		rel->serverid = table->serverid;
+ 	}
+ 
  	heap_close(relation, NoLock);
  
  	/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 37187e2..24cfe24 100644
*** a/src/backend/optimizer/util/relnode.c
--- b/src/backend/optimizer/util/relnode.c
*************** build_simple_rel(PlannerInfo *root, int 
*** 117,122 ****
--- 117,123 ----
  	rel->baserestrictcost.per_tuple = 0;
  	rel->joininfo = NIL;
  	rel->has_eclass_joins = false;
+ 	rel->serverid = InvalidOid;
  	rel->index_outer_relids = NULL;
  	rel->index_inner_paths = NIL;
  
*************** build_join_rel(PlannerInfo *root,
*** 371,376 ****
--- 372,378 ----
  	joinrel->baserestrictcost.per_tuple = 0;
  	joinrel->joininfo = NIL;
  	joinrel->has_eclass_joins = false;
+ 	joinrel->serverid = InvalidOid;
  	joinrel->index_outer_relids = NULL;
  	joinrel->index_inner_paths = NIL;
  
*************** build_join_rel(PlannerInfo *root,
*** 443,448 ****
--- 445,458 ----
  			lappend(root->join_rel_level[root->join_cur_level], joinrel);
  	}
  
+ 	/*
+ 	 * If both outer and inner are from one oreign server, maybe this join can
+ 	 * be pushed down, so remember the oid of the foreign server in this
+ 	 * relation.
+ 	 */
+ 	if (outer_rel->serverid == inner_rel->serverid)
+ 		joinrel->serverid = outer_rel->serverid;
+ 
  	return joinrel;
  }
  
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 976a832..e97a94d 100644
*** a/src/backend/tcop/postgres.c
--- b/src/backend/tcop/postgres.c
*************** set_plan_disabling_options(const char *a
*** 3093,3098 ****
--- 3093,3101 ----
  		case 'h':				/* hashjoin */
  			tmp = "enable_hashjoin";
  			break;
+ 		case 'f':				/* foreignjoin */
+ 			tmp = "enable_foreignjoin";
+ 			break;
  	}
  	if (tmp)
  	{
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index da7b6d4..524582d 100644
*** a/src/backend/utils/misc/guc.c
--- b/src/backend/utils/misc/guc.c
*************** static struct config_bool ConfigureNames
*** 765,770 ****
--- 765,779 ----
  		NULL, NULL, NULL
  	},
  	{
+ 		{"enable_foreignjoin", PGC_USERSET, QUERY_TUNING_METHOD,
+ 			gettext_noop("Enables the planner's use of foreign join plans."),
+ 			NULL
+ 		},
+ 		&enable_foreignjoin,
+ 		true,
+ 		NULL, NULL, NULL
+ 	},
+ 	{
  		{"geqo", PGC_USERSET, QUERY_TUNING_GEQO,
  			gettext_noop("Enables genetic query optimization."),
  			gettext_noop("This algorithm attempts to do planning without "
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index 315db46..d1dec0e 100644
*** a/src/backend/utils/misc/postgresql.conf.sample
--- b/src/backend/utils/misc/postgresql.conf.sample
***************
*** 240,245 ****
--- 240,246 ----
  # - Planner Method Configuration -
  
  #enable_bitmapscan = on
+ #enable_foreignjoin = on
  #enable_hashagg = on
  #enable_hashjoin = on
  #enable_indexscan = on
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index bdd499b..e4d3426 100644
*** a/src/include/executor/executor.h
--- b/src/include/executor/executor.h
*************** extern void ExecFreeExprContext(PlanStat
*** 332,337 ****
--- 332,338 ----
  extern TupleDesc ExecGetScanType(ScanState *scanstate);
  extern void ExecAssignScanType(ScanState *scanstate, TupleDesc tupDesc);
  extern void ExecAssignScanTypeFromOuterPlan(ScanState *scanstate);
+ extern void ExecAssignScanTypeFromTL(ScanState *scanstate);
  
  extern bool ExecRelationIsTargetRelation(EState *estate, Index scanrelid);
  
diff --git a/src/include/foreign/fdwapi.h b/src/include/foreign/fdwapi.h
index 3378ba9..e535e12 100644
*** a/src/include/foreign/fdwapi.h
--- b/src/include/foreign/fdwapi.h
*************** typedef void (*ReScanForeignScan_functio
*** 68,73 ****
--- 68,83 ----
  
  typedef void (*EndForeignScan_function) (ForeignScanState *node);
  
+ typedef FdwPlan *(*PlanForeignJoin_function) (Oid serverid,
+ 											  PlannerInfo *root,
+ 											  RelOptInfo *joinrel,
+ 											  JoinType jointype,
+ 											  SpecialJoinInfo *sjinfo,
+ 											  Path *outer_path,
+ 											  Path *inner_path,
+ 											  List *restrict_clauses,
+ 											  List *pathkeys);
+ 
  
  /*
   * FdwRoutine is the struct returned by a foreign-data wrapper's handler
*************** typedef struct FdwRoutine
*** 88,93 ****
--- 98,106 ----
  	IterateForeignScan_function IterateForeignScan;
  	ReScanForeignScan_function ReScanForeignScan;
  	EndForeignScan_function EndForeignScan;
+ 
+ 	/* functions below are optional */
+ 	PlanForeignJoin_function PlanForeignJoin;
  } FdwRoutine;
  
  
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 0a89f18..27d37a0 100644
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
*************** typedef struct WorkTableScanState
*** 1463,1468 ****
--- 1463,1469 ----
  typedef struct ForeignScanState
  {
  	ScanState	ss;				/* its first field is NodeTag */
+ 	Oid			serverid;		/* OID of foreign server */
  	/* use struct pointer to avoid including fdwapi.h here */
  	struct FdwRoutine *fdwroutine;
  	void	   *fdw_state;		/* foreign-data wrapper can keep state here */
diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
index 824d8b5..0f5dac2 100644
*** a/src/include/nodes/nodes.h
--- b/src/include/nodes/nodes.h
*************** typedef enum NodeTag
*** 67,72 ****
--- 67,73 ----
  	T_NestLoop,
  	T_MergeJoin,
  	T_HashJoin,
+ 	T_ForeignJoin,
  	T_Material,
  	T_Sort,
  	T_Group,
*************** typedef enum NodeTag
*** 221,226 ****
--- 222,228 ----
  	T_NestPath,
  	T_MergePath,
  	T_HashPath,
+ 	T_ForeignJoinPath,
  	T_TidPath,
  	T_ForeignPath,
  	T_AppendPath,
diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index 6685864..2fc8a36 100644
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
*************** typedef struct WorkTableScan
*** 467,472 ****
--- 467,473 ----
  typedef struct ForeignScan
  {
  	Scan		scan;
+ 	Oid			serverid;		/* OID of foreign server */
  	bool		fsSystemCol;	/* true if any "system column" is needed */
  	/* use struct pointer to avoid including fdwapi.h here */
  	struct FdwPlan *fdwplan;
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index a400960..d790a34 100644
*** a/src/include/nodes/relation.h
--- b/src/include/nodes/relation.h
*************** typedef struct RelOptInfo
*** 416,421 ****
--- 416,422 ----
  	List	   *joininfo;		/* RestrictInfo structures for join clauses
  								 * involving this rel */
  	bool		has_eclass_joins;		/* T means joininfo is incomplete */
+ 	Oid			serverid;		/* foriegn server, if foreign scan/join */
  
  	/* cached info about inner indexscan paths for relation: */
  	Relids		index_outer_relids;		/* other relids in indexable join
*************** typedef struct HashPath
*** 954,959 ****
--- 955,970 ----
  } HashPath;
  
  /*
+  * A foreignjoin path has no additional field.
+  */
+ typedef struct ForeignJoinPath
+ {
+ 	JoinPath	jpath;
+ 	/* use struct pointer to avoid including fdwapi.h here */
+ 	struct FdwPlan *fdwplan;	/* FDW-specific information */
+ } ForeignJoinPath;
+ 
+ /*
   * Restriction clause info.
   *
   * We create one of these for each AND sub-clause of a restriction condition
diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h
index 125808a..284eb92 100644
*** a/src/include/optimizer/cost.h
--- b/src/include/optimizer/cost.h
*************** extern bool enable_nestloop;
*** 61,66 ****
--- 61,67 ----
  extern bool enable_material;
  extern bool enable_mergejoin;
  extern bool enable_hashjoin;
+ extern bool enable_foreignjoin;
  extern int	constraint_exclusion;
  
  extern double clamp_row_est(double nrows);
*************** extern void cost_mergejoin(MergePath *pa
*** 114,119 ****
--- 115,124 ----
  			   SpecialJoinInfo *sjinfo);
  extern void cost_hashjoin(HashPath *path, PlannerInfo *root,
  			  SpecialJoinInfo *sjinfo);
+ /*
+  * cost_foreignjoin() is not defined here because the costs of a foreign join
+  * is estimated by each FDW via PlanForeignJoin.
+  */
  extern void cost_subplan(PlannerInfo *root, SubPlan *subplan, Plan *plan);
  extern void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root);
  extern void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root);
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 38c8c1c..b303270 100644
*** a/src/include/optimizer/pathnode.h
--- b/src/include/optimizer/pathnode.h
*************** extern HashPath *create_hashjoin_path(Pl
*** 94,99 ****
--- 94,108 ----
  					 List *restrict_clauses,
  					 List *hashclauses);
  
+ extern ForeignJoinPath *create_foreignjoin_path(PlannerInfo *root,
+ 							RelOptInfo *joinrel,
+ 							JoinType jointype,
+ 							SpecialJoinInfo *sjinfo,
+ 							Path *outer_path,
+ 							Path *inner_path,
+ 							List *restrict_clauses,
+ 							List *pathkeys);
+ 
  /*
   * prototypes for relnode.c
   */
diff --git a/src/test/regress/expected/rangefuncs.out b/src/test/regress/expected/rangefuncs.out
index 5f20c93..8a81674 100644
*** a/src/test/regress/expected/rangefuncs.out
--- b/src/test/regress/expected/rangefuncs.out
*************** SELECT name, setting FROM pg_settings WH
*** 2,7 ****
--- 2,8 ----
           name         | setting 
  ----------------------+---------
   enable_bitmapscan    | on
+  enable_foreignjoin   | on
   enable_hashagg       | on
   enable_hashjoin      | on
   enable_indexonlyscan | on
*************** SELECT name, setting FROM pg_settings WH
*** 12,18 ****
   enable_seqscan       | on
   enable_sort          | on
   enable_tidscan       | on
! (11 rows)
  
  CREATE TABLE foo2(fooid int, f2 int);
  INSERT INTO foo2 VALUES(1, 11);
--- 13,19 ----
   enable_seqscan       | on
   enable_sort          | on
   enable_tidscan       | on
! (12 rows)
  
  CREATE TABLE foo2(fooid int, f2 int);
  INSERT INTO foo2 VALUES(1, 11);