Optimization for updating foreign tables in Postgres FDW

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 188,197 **** is_foreign_expr(PlannerInfo *root,
  	if (!foreign_expr_walker((Node *) expr, &glob_cxt, &loc_cxt))
  		return false;
  
- 	/* Expressions examined here should be boolean, ie noncollatable */
- 	Assert(loc_cxt.collation == InvalidOid);
- 	Assert(loc_cxt.state == FDW_COLLATE_NONE);
- 
  	/*
  	 * An expression which includes any mutable functions can't be sent over
  	 * because its result is not stable.  For example, sending now() remote
--- 188,193 ----
***************
*** 927,932 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 923,981 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,
+ 					   Index rtindex, Relation rel,
+ 					   List	*remote_conds,
+ 					   List	*targetlist,
+ 					   List *targetAttrs, List *returningList,
+ 					   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	List	   *params_list = NIL;
+ 	deparse_expr_cxt context;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = NULL;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfo(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, &params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 949,954 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 998,1030 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root,
+ 					   Index rtindex, Relation rel,
+ 					   List	*remote_conds,
+ 					   List *returningList,
+ 					   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	List	   *params_list = NIL;
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, &params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 992,998 **** INSERT INTO ft2 (c1,c2,c3)
--- 992,1019 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, c7, c8, ctid
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, c7, c8, ctid
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (5 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1102,1108 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1123,1129 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                             -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1123,1138 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
    DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
-    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
     ->  Foreign Scan on public.ft2
           Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1144,1171 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 5 AND date(c4) = '1970-01-17'::date;  -- can't be pushed down
+                                                       QUERY PLAN                                                       
+ -----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Remote SQL: UPDATE "S 1"."T 1" SET c7 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, 'ft2       '::character(10), c8, ctid
+          Filter: (date(ft2.c4) = '01-17-1970'::date)
+          Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c8, ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
+ (6 rows)
+ 
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 5 AND date(c4) = '1970-01-17'::date;
+ EXPLAIN (verbose, costs off)
    DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
     ->  Foreign Scan on public.ft2
           Output: ctid
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (5 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1243,1249 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1276,1282 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;              -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2227,2233 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2260,2266 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2386,2392 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2419,2425 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 86,92 **** typedef struct PgFdwRelationInfo
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
--- 86,97 ----
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) List of restriction clauses that can be executed remotely
!  * 3) Integer list of attribute numbers retrieved by the SELECT
!  * 4) UPDATE/DELETE statement text to be sent to the remote server
!  * 5) Boolean flag showing if we set the command es_processed
!  * 6) Boolean flag showing if the remote query has a RETURNING clause
!  * 7) Integer list of attribute numbers retrieved by RETURNING, if any
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
***************
*** 96,105 **** enum FdwScanPrivateIndex
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
! 	/* Integer list of attribute numbers retrieved by the SELECT */
! 	FdwScanPrivateRetrievedAttrs
  };
  
  /*
   * Similarly, this enum describes what's kept in the fdw_private list for
   * a ModifyTable node referencing a postgres_fdw foreign table.  We store:
--- 101,123 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
! 	/* List of restriction clauses that can be executed remotely */
! 	FdwScanPrivateRemoteConds,
! 	/* Integer list of attribute numbers retrieved by SELECT */
! 	FdwScanPrivateRetrievedAttrsBySelect,
! 	/* UPDATE/DELETE statement to execute remotely (as a String node) */
! 	FdwScanPrivateUpdateSql,
! 	/* set-processed flag (as an integer Value node) */
! 	FdwScanPrivateSetProcessed,
! 	/* has-returning flag (as an integer Value node) */
! 	FdwScanPrivateHasReturning,
! 	/* Integer list of attribute numbers retrieved by RETURNING */
! 	FdwScanPrivateRetrievedAttrsByReturning
  };
  
+ #define SelectFdwScanPrivateLength					3
+ #define UpdateFdwScanPrivateLength					7
+ 
  /*
   * Similarly, this enum describes what's kept in the fdw_private list for
   * a ModifyTable node referencing a postgres_fdw foreign table.  We store:
***************
*** 131,138 **** typedef struct PgFdwScanState
  	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
  
  	/* extracted fdw_private data */
! 	char	   *query;			/* text of SELECT command */
  	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
  
  	/* for remote query execution */
  	PGconn	   *conn;			/* connection for the scan */
--- 149,158 ----
  	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
  
  	/* extracted fdw_private data */
! 	char	   *query;			/* text of SELECT or UPDATE/DELETE command */
  	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
  
  	/* for remote query execution */
  	PGconn	   *conn;			/* connection for the scan */
***************
*** 152,157 **** typedef struct PgFdwScanState
--- 172,182 ----
  	int			fetch_ct_2;		/* Min(# of fetches done, 2) */
  	bool		eof_reached;	/* true if last fetch reached EOF */
  
+ 	/* for update pushdown */
+ 	bool		update_is_pushed_down;	/* is UPDATE/DELETE pushed down? */
+ 	PGresult   *result;			/* result of an UPDATE/DELETE query */
+ 	TupleTableSlot *rslot;		/* slot containing the result tuple */
+ 
  	/* working memory contexts */
  	MemoryContext batch_cxt;	/* context holding current batch of tuples */
  	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
***************
*** 180,185 **** typedef struct PgFdwModifyState
--- 205,214 ----
  	int			p_nums;			/* number of parameters to transmit */
  	FmgrInfo   *p_flinfo;		/* output conversion functions for them */
  
+ 	/* for update pushdown */
+ 	bool		update_is_pushed_down;	/* is UPDATE/DELETE pushed down? */
+ 	PgFdwScanState *fsstate;	/* execution state of a foreign scan */
+ 
  	/* working memory context */
  	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
  } PgFdwModifyState;
***************
*** 308,319 **** static bool ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
  static void create_cursor(ForeignScanState *node);
  static void fetch_more_data(ForeignScanState *node);
  static void close_cursor(PGconn *conn, unsigned int cursor_number);
  static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
--- 337,365 ----
  static void create_cursor(ForeignScanState *node);
  static void fetch_more_data(ForeignScanState *node);
  static void close_cursor(PGconn *conn, unsigned int cursor_number);
+ static bool update_is_pushdown_safe(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index,
+ 									Relation rel,
+ 									List *targetAttrs);
+ static List *push_update_down(PlannerInfo *root,
+ 							  ModifyTable *plan,
+ 							  Index resultRelation,
+ 							  int subplan_index,
+ 							  Relation rel,
+ 							  List *targetAttrs);
  static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 852,858 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make2(makeString(sql.data),
  							 retrieved_attrs);
  
  	/*
--- 898,905 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make3(makeString(sql.data),
! 							 remote_conds,
  							 retrieved_attrs);
  
  	/*
***************
*** 914,935 **** postgresBeginForeignScan(ForeignScanState *node, int eflags)
  	server = GetForeignServer(table->serverid);
  	user = GetUserMapping(userid, server->serverid);
  
  	/*
  	 * Get connection to the foreign server.  Connection manager will
  	 * establish new connection if necessary.
  	 */
  	fsstate->conn = GetConnection(server, user, false);
  
- 	/* Assign a unique ID for my cursor */
- 	fsstate->cursor_number = GetCursorNumber(fsstate->conn);
- 	fsstate->cursor_exists = false;
- 
- 	/* Get private info created by planner functions. */
- 	fsstate->query = strVal(list_nth(fsplan->fdw_private,
- 									 FdwScanPrivateSelectSql));
- 	fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
- 											   FdwScanPrivateRetrievedAttrs);
- 
  	/* Create contexts for batches of tuples and per-tuple temp workspace. */
  	fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											   "postgres_fdw tuple data",
--- 961,993 ----
  	server = GetForeignServer(table->serverid);
  	user = GetUserMapping(userid, server->serverid);
  
+ 	/* Get private info created by planner functions. */
+ 	if (list_length(fsplan->fdw_private) == UpdateFdwScanPrivateLength)
+ 	{
+ 		fsstate->query = strVal(list_nth(fsplan->fdw_private,
+ 										 FdwScanPrivateUpdateSql));
+ 		fsstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+ 												 FdwScanPrivateSetProcessed));
+ 		fsstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+ 												 FdwScanPrivateHasReturning));
+ 		fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 									FdwScanPrivateRetrievedAttrsByReturning);
+ 	}
+ 	else
+ 	{
+ 		Assert(list_length(fsplan->fdw_private) == SelectFdwScanPrivateLength);
+ 		fsstate->query = strVal(list_nth(fsplan->fdw_private,
+ 										 FdwScanPrivateSelectSql));
+ 		fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 										FdwScanPrivateRetrievedAttrsBySelect);
+ 	}
+ 
  	/*
  	 * Get connection to the foreign server.  Connection manager will
  	 * establish new connection if necessary.
  	 */
  	fsstate->conn = GetConnection(server, user, false);
  
  	/* Create contexts for batches of tuples and per-tuple temp workspace. */
  	fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											   "postgres_fdw tuple data",
***************
*** 945,950 **** postgresBeginForeignScan(ForeignScanState *node, int eflags)
--- 1003,1037 ----
  	/* Get info we'll need for input data conversion. */
  	fsstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(fsstate->rel));
  
+ 	/*
+ 	 * If pushing update down, execute the statement, and check for success.
+ 	 */
+ 	if (list_length(fsplan->fdw_private) == UpdateFdwScanPrivateLength)
+ 	{
+ 		/*
+ 		 * We don't use a PG_TRY block here, so be careful not to throw error
+ 		 * without releasing the PGresult.
+ 		 */
+ 		fsstate->result = PQexec(fsstate->conn, fsstate->query);
+ 		if (PQresultStatus(fsstate->result) !=
+ 			(fsstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 			pgfdw_report_error(ERROR, fsstate->result, fsstate->conn, true,
+ 							   fsstate->query);
+ 
+ 		/* Check number of rows affected. */
+ 		if (fsstate->has_returning)
+ 			fsstate->num_tuples = PQntuples(fsstate->result);
+ 		else
+ 			fsstate->num_tuples = atoi(PQcmdTuples(fsstate->result));
+ 
+ 		fsstate->update_is_pushed_down = true;
+ 		return;
+ 	}
+ 
+ 	/* Assign a unique ID for my cursor */
+ 	fsstate->cursor_number = GetCursorNumber(fsstate->conn);
+ 	fsstate->cursor_exists = false;
+ 
  	/* Prepare for output conversion of parameters used in remote query. */
  	numParams = list_length(fsplan->fdw_exprs);
  	fsstate->numParams = numParams;
***************
*** 995,1000 **** postgresIterateForeignScan(ForeignScanState *node)
--- 1082,1155 ----
  	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
  
  	/*
+ 	 * If pushing update down, get the result of UPDATE/DELETE RETURNING.
+ 	 */
+ 	if (fsstate->update_is_pushed_down)
+ 	{
+ 		MemoryContext oldcontext;
+ 
+ 		/*
+ 		 * If the update query doesn't have a RETURNING clause, then there is
+ 		 * nothing to do, so we just return an empty slot.
+ 		 */
+ 		if (!fsstate->has_returning)
+ 		{
+ 			/*
+ 			 * Increment the command es_processed if necessary.  (ModifyTable
+ 			 * cannot do that by itself in this case.)
+ 			 */
+ 			if (fsstate->set_processed)
+ 			{
+ 				EState	   *estate = node->ss.ps.state;
+ 
+ 				estate->es_processed += fsstate->num_tuples;
+ 			}
+ 
+ 			/*
+ 			 * Increment the tuple count for EXPLAIN ANALYZE if we are running
+ 			 * it.  (The command cannot do that by itself in this case.)
+ 			 */
+ 			if (node->ss.ps.instrument)
+ 			{
+ 				Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 				instr->ntuples += fsstate->num_tuples;
+ 			}
+ 
+ 			return ExecClearTuple(slot);
+ 		}
+ 
+ 		/* If we didn't get any tuples, must be end of data. */
+ 		if (fsstate->next_tuple >= fsstate->num_tuples)
+ 			return ExecClearTuple(slot);
+ 
+ 		/* OK, we'll store RETURNING tuples in the batch_cxt. */
+ 		oldcontext = MemoryContextSwitchTo(fsstate->batch_cxt);
+ 
+ 		/* Fetch the next tuple. */
+ 		store_returning_result(slot,
+ 							   fsstate->result,
+ 							   fsstate->next_tuple,
+ 							   fsstate->rel,
+ 							   fsstate->attinmeta,
+ 							   fsstate->retrieved_attrs,
+ 							   fsstate->temp_cxt);
+ 		fsstate->rslot = slot;
+ 		fsstate->next_tuple++;
+ 
+ 		MemoryContextSwitchTo(oldcontext);
+ 
+ 		/*
+ 		 * Return slot.  Note that this is safe because we can avoid applying
+ 		 * ExecQual to the tuple due to no local quals (see the comment for
+ 		 * update_is_pushdown_safe) and because the tuple can be safely
+ 		 * projected by ExecProject (see push_update_down) and would then be
+ 		 * ignored in postgresExecForeignUpdate or postgresExecForeignDelete.
+ 		 */
+ 		return slot;
+ 	}
+ 
+ 	/*
  	 * If this is the first call after Begin or ReScan, we need to create the
  	 * cursor on the remote side.
  	 */
***************
*** 1094,1099 **** postgresEndForeignScan(ForeignScanState *node)
--- 1249,1261 ----
  	if (fsstate == NULL)
  		return;
  
+ 	/* if pushing update down, nothing to do other than cleanup */
+ 	if (fsstate->update_is_pushed_down)
+ 	{
+ 		if (fsstate->result)
+ 			PQclear(fsstate->result);
+ 	}
+ 
  	/* Close the cursor if open, to prevent accumulation of cursors */
  	if (fsstate->cursor_exists)
  		close_cursor(fsstate->conn, fsstate->cursor_number);
***************
*** 1167,1174 **** postgresPlanForeignModify(PlannerInfo *root,
  	List	   *returningList = NIL;
  	List	   *retrieved_attrs = NIL;
  
- 	initStringInfo(&sql);
- 
  	/*
  	 * Core code already has some lock on each rel being planned, so we can
  	 * use NoLock here.
--- 1329,1334 ----
***************
*** 1210,1215 **** postgresPlanForeignModify(PlannerInfo *root,
--- 1370,1399 ----
  	}
  
  	/*
+ 	 * For UPDATE/DELETE, if there are no local conditions or joins needed (see
+ 	 * update_is_pushdown_safe for more details), we push the command down.
+ 	 */
+ 	if (operation == CMD_UPDATE || operation == CMD_DELETE)
+ 	{
+ 		/* Check whether it's safe to push the command down. */
+ 		if (update_is_pushdown_safe(root, plan,
+ 									resultRelation,
+ 									subplan_index,
+ 									rel, targetAttrs))
+ 		{
+ 			List	   *fdw_private;
+ 
+ 			/* OK, modify plan so as to push the command down. */
+ 			fdw_private = push_update_down(root, plan,
+ 										   resultRelation,
+ 										   subplan_index,
+ 										   rel, targetAttrs);
+ 			heap_close(rel, NoLock);
+ 			return fdw_private;
+ 		}
+ 	}
+ 
+ 	/*
  	 * Extract the relevant RETURNING list if any.
  	 */
  	if (plan->returningLists)
***************
*** 1218,1223 **** postgresPlanForeignModify(PlannerInfo *root,
--- 1402,1408 ----
  	/*
  	 * Construct the SQL command string.
  	 */
+ 	initStringInfo(&sql);
  	switch (operation)
  	{
  		case CMD_INSERT:
***************
*** 1288,1293 **** postgresBeginForeignModify(ModifyTableState *mtstate,
--- 1473,1514 ----
  	fmstate = (PgFdwModifyState *) palloc0(sizeof(PgFdwModifyState));
  	fmstate->rel = rel;
  
+ 	/* Deconstruct fdw_private data. */
+ 	fmstate->query = strVal(list_nth(fdw_private,
+ 									 FdwModifyPrivateUpdateSql));
+ 	fmstate->target_attrs = (List *) list_nth(fdw_private,
+ 											  FdwModifyPrivateTargetAttnums);
+ 	fmstate->has_returning = intVal(list_nth(fdw_private,
+ 											 FdwModifyPrivateHasReturning));
+ 	fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
+ 											 FdwModifyPrivateRetrievedAttrs);
+ 
+ 	/*
+ 	 * if query is NULL, we are in update pushdown case.
+ 	 */
+ 	if (fmstate->query == NULL)
+ 	{
+ 		PlanState	   *node = mtstate->mt_plans[subplan_index];
+ 		PgFdwScanState *fsstate;
+ 
+ 		Assert(fmstate->target_attrs == NIL);
+ 		Assert(fmstate->has_returning == false);
+ 		Assert(fmstate->retrieved_attrs == NIL);
+ 
+ 		Assert(nodeTag(node) == T_ForeignScanState);
+ 		fsstate = ((ForeignScanState *) node)->fdw_state;
+ 		Assert(fsstate->update_is_pushed_down);
+ 
+ 		fmstate->update_is_pushed_down = true;
+ 		if (fsstate->has_returning)
+ 		{
+ 			fmstate->has_returning = true;
+ 			fmstate->fsstate = fsstate;
+ 		}
+ 		resultRelInfo->ri_FdwState = fmstate;
+ 		return;
+ 	}
+ 
  	/*
  	 * Identify which user to do the remote access as.  This should match what
  	 * ExecCheckRTEPerms() does.
***************
*** 1304,1319 **** postgresBeginForeignModify(ModifyTableState *mtstate,
  	fmstate->conn = GetConnection(server, user, true);
  	fmstate->p_name = NULL;		/* prepared statement not made yet */
  
- 	/* Deconstruct fdw_private data. */
- 	fmstate->query = strVal(list_nth(fdw_private,
- 									 FdwModifyPrivateUpdateSql));
- 	fmstate->target_attrs = (List *) list_nth(fdw_private,
- 											  FdwModifyPrivateTargetAttnums);
- 	fmstate->has_returning = intVal(list_nth(fdw_private,
- 											 FdwModifyPrivateHasReturning));
- 	fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
- 											 FdwModifyPrivateRetrievedAttrs);
- 
  	/* Create context for per-tuple temp workspace. */
  	fmstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											  "postgres_fdw temporary data",
--- 1525,1530 ----
***************
*** 1411,1417 **** postgresExecForeignInsert(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1622,1632 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1442,1447 **** postgresExecForeignUpdate(EState *estate,
--- 1657,1670 ----
  	PGresult   *res;
  	int			n_rows;
  
+ 	/* Just return slot created by the ForeignScan, if pushing update down */
+ 	if (fmstate->update_is_pushed_down)
+ 	{
+ 		Assert(fmstate->has_returning);
+ 		Assert(fmstate->fsstate->rslot);
+ 		return fmstate->fsstate->rslot;
+ 	}
+ 
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
  		prepare_foreign_modify(fmstate);
***************
*** 1481,1487 **** postgresExecForeignUpdate(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1704,1714 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1512,1517 **** postgresExecForeignDelete(EState *estate,
--- 1739,1752 ----
  	PGresult   *res;
  	int			n_rows;
  
+ 	/* Just return slot created by the ForeignScan, if pushing update down */
+ 	if (fmstate->update_is_pushed_down)
+ 	{
+ 		Assert(fmstate->has_returning);
+ 		Assert(fmstate->fsstate->rslot);
+ 		return fmstate->fsstate->rslot;
+ 	}
+ 
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
  		prepare_foreign_modify(fmstate);
***************
*** 1551,1557 **** postgresExecForeignDelete(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1786,1796 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1579,1584 **** postgresEndForeignModify(EState *estate,
--- 1818,1827 ----
  	if (fmstate == NULL)
  		return;
  
+ 	/* If pushing update down, nothing to do */
+ 	if (fmstate->update_is_pushed_down)
+ 		return;
+ 
  	/* If we created a prepared statement, destroy it */
  	if (fmstate->p_name)
  	{
***************
*** 1661,1667 **** postgresExplainForeignScan(ForeignScanState *node, ExplainState *es)
  	if (es->verbose)
  	{
  		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
! 		sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
  		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
--- 1904,1918 ----
  	if (es->verbose)
  	{
  		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
! 		if (list_length(fdw_private) == UpdateFdwScanPrivateLength)
! 		{
! 			sql = strVal(list_nth(fdw_private, FdwScanPrivateUpdateSql));
! 		}
! 		else
! 		{
! 			Assert(list_length(fdw_private) == SelectFdwScanPrivateLength);
! 			sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
! 		}
  		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
***************
*** 1682,1688 **** postgresExplainForeignModify(ModifyTableState *mtstate,
  		char	   *sql = strVal(list_nth(fdw_private,
  										  FdwModifyPrivateUpdateSql));
  
! 		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
  
--- 1933,1940 ----
  		char	   *sql = strVal(list_nth(fdw_private,
  										  FdwModifyPrivateUpdateSql));
  
! 		if (sql != NULL)
! 			ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
  
***************
*** 1911,1916 **** ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
--- 2163,2377 ----
  }
  
  /*
+  * Check whether it's safe to push the UPDATE/DELETE command down.
+  *
+  * Conditions checked here:
+  *
+  * 1. If the target relation has any BEFORE/AFTER row-level local triggers, we
+  * must not push the command down, since that breaks execution of the triggers.
+  *
+  * 2. If there are any local joins needed, we mustn't push the command down,
+  * because that breaks execution of the joins.
+  *
+  * 3. If there are any quals that can't be evaluated remotely, we mustn't push
+  * the command down, because that breaks evaluation of the quals.
+  *
+  * 4. In UPDATE, if it is unsafe to evaluate any expressions to assign to the
+  * target columns on the remote server, we must not push the command down.
+  */
+ static bool
+ update_is_pushdown_safe(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index,
+ 						Relation rel,
+ 						List *targetAttrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ListCell   *lc;
+ 
+ 	/* Check point 1 */
+ 	if (rel->trigdesc &&
+ 		(rel->trigdesc->trig_update_after_row ||
+ 		 rel->trigdesc->trig_update_before_row))
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(subplan->targetlist,
+ 											attnum);
+ 
+ 		if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 			return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ /*
+  * Modify a plan so as to push the update command down.
+  */
+ static List *
+ push_update_down(PlannerInfo *root,
+ 				 ModifyTable *plan,
+ 				 Index resultRelation,
+ 				 int subplan_index,
+ 				 Relation rel,
+ 				 List *targetAttrs)
+ {
+ 	CmdType		operation = plan->operation;
+ 	bool		canSetTag = plan->canSetTag;
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ForeignScan *fscan = (ForeignScan *) subplan;
+ 	StringInfoData sql;
+ 	List	   *remote_conds;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 	List	   *new_tlist = NIL;
+ 	List	   *fdw_private;
+ 
+ 	Assert(operation == CMD_UPDATE || operation == CMD_DELETE);
+ 
+ 	initStringInfo(&sql);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		List	   *targetlist = subplan->targetlist;
+ 
+ 		deparseDirectUpdateSql(&sql, root, resultRelation, rel,
+ 							   remote_conds,
+ 							   targetlist,
+ 							   targetAttrs,
+ 							   returningList,
+ 							   &retrieved_attrs);
+ 	}
+ 	else
+ 	{
+ 		Assert(operation == CMD_DELETE);
+ 
+ 		deparseDirectDeleteSql(&sql, root, resultRelation, rel,
+ 							   remote_conds,
+ 							   returningList,
+ 							   &retrieved_attrs);
+ 	}
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwScanPrivateIndex, above.
+ 	 */
+ 	fscan->fdw_private = lappend(fscan->fdw_private, makeString(sql.data));
+ 	fscan->fdw_private = lappend(fscan->fdw_private, makeInteger(canSetTag));
+ 	fscan->fdw_private = lappend(fscan->fdw_private,
+ 								 makeInteger((retrieved_attrs != NIL)));
+ 	fscan->fdw_private = lappend(fscan->fdw_private, retrieved_attrs);
+ 
+ 	/*
+ 	 * Rrewrite the targetlist for an UPDATE command for safety of ExecProject.
+ 	 * Note we ignore and do not reference result tuples in update pushdown case.
+ 	 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		ListCell   *lc;
+ 		int			attrno = 1;
+ 		int			numattrs = RelationGetNumberOfAttributes(rel);
+ 
+ 		foreach(lc, subplan->targetlist)
+ 		{
+ 			TargetEntry *tle = (TargetEntry *) lfirst(lc);
+ 
+ 			if (tle->resjunk)
+ 			{
+ 				new_tlist = lappend(new_tlist, tle);
+ 				continue;
+ 			}
+ 
+ 			if (attrno > numattrs)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 						 errmsg("table row type and query-specified row type do not match"),
+ 						 errdetail("Query has too many columns.")));
+ 
+ 			if (!list_member_int(targetAttrs, attrno))
+ 				new_tlist = lappend(new_tlist, tle);
+ 			else
+ 			{
+ 				Form_pg_attribute attr;
+ 				Oid			atttype;
+ 				int32		atttypmod;
+ 				Oid			attcollation;
+ 				Node	   *new_expr;
+ 				TargetEntry *new_tle;
+ 
+ 				attr = rel->rd_att->attrs[attrno - 1];
+ 
+ 				Assert(!attr->attisdropped);
+ 				atttype = attr->atttypid;
+ 				atttypmod = attr->atttypmod;
+ 				attcollation = attr->attcollation;
+ 
+ 				new_expr = (Node *) makeVar(resultRelation,
+ 											attrno,
+ 											atttype,
+ 											atttypmod,
+ 											attcollation,
+ 											0);
+ 
+ 				new_tle = makeTargetEntry((Expr *) new_expr,
+ 										  attrno,
+ 										  pstrdup(NameStr(attr->attname)),
+ 										  false);
+ 
+ 				new_tlist = lappend(new_tlist, new_tle);
+ 			}
+ 
+ 			attrno++;
+ 		}
+ 
+ 		if (attrno != numattrs + 1)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 					 errmsg("table row type and query-specified row type do not match"),
+ 					 errdetail("Query has too few columns.")));
+ 
+ 		subplan->targetlist = new_tlist;
+ 	}
+ 
+ 	/*
+ 	 * Build the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwModifyPrivateIndex, above.
+ 	 */
+ 	fdw_private = list_make4(makeString(NULL), NIL, makeInteger(false), NIL);
+ 
+ 	return fdw_private;
+ }
+ 
+ /*
   * Create cursor for node's query with current parameter values.
   */
  static void
***************
*** 2258,2275 **** convert_prep_stmt_params(PgFdwModifyState *fmstate,
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, 0,
! 											fmstate->rel,
! 											fmstate->attinmeta,
! 											fmstate->retrieved_attrs,
! 											fmstate->temp_cxt);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
--- 2719,2741 ----
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, row,
! 											rel,
! 											attinmeta,
! 											retrieved_attrs,
! 											temp_context);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 66,75 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 66,87 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,
+ 								   Index rtindex, Relation rel,
+ 								   List	*remote_conds,
+ 								   List	*targetlist,
+ 								   List *targetAttrs,
+ 								   List *returningList,
+ 								   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root,
+ 								   Index rtindex, Relation rel,
+ 								   List	*remote_conds,
+ 								   List *returningList,
+ 								   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 314,331 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
    DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  
--- 314,338 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                             -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 5 AND date(c4) = '1970-01-17'::date;  -- can't be pushed down
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 5 AND date(c4) = '1970-01-17'::date;
+ EXPLAIN (verbose, costs off)
    DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;              -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 414,419 ****
--- 414,428 ----
     <literal>WHERE</> clauses are not sent to the remote server unless they use
     only built-in data types, operators, and functions.  Operators and
     functions in the clauses must be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, or no <literal>BEFORE</> or <literal>AFTER</>
+    row-level local triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, and <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 188,197 **** is_foreign_expr(PlannerInfo *root,
  	if (!foreign_expr_walker((Node *) expr, &glob_cxt, &loc_cxt))
  		return false;
  
- 	/* Expressions examined here should be boolean, ie noncollatable */
- 	Assert(loc_cxt.collation == InvalidOid);
- 	Assert(loc_cxt.state == FDW_COLLATE_NONE);
- 
  	/*
  	 * An expression which includes any mutable functions can't be sent over
  	 * because its result is not stable.  For example, sending now() remote
--- 188,193 ----
***************
*** 927,932 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 923,981 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,
+ 					   Index rtindex, Relation rel,
+ 					   List	*remote_conds,
+ 					   List	*targetlist,
+ 					   List *targetAttrs, List *returningList,
+ 					   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	List	   *params_list = NIL;
+ 	deparse_expr_cxt context;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = NULL;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfo(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, &params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 949,954 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 998,1030 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root,
+ 					   Index rtindex, Relation rel,
+ 					   List	*remote_conds,
+ 					   List *returningList,
+ 					   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	List	   *params_list = NIL;
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, &params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 998,1004 **** INSERT INTO ft2 (c1,c2,c3)
--- 998,1025 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, c7, c8, ctid
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, c7, c8, ctid
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (5 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1108,1114 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1129,1135 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1129,1144 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
-    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
     ->  Foreign Scan on public.ft2
           Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1150,1164 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
     ->  Foreign Scan on public.ft2
           Output: ctid
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (5 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1249,1255 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1269,1275 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2092,2097 **** SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
--- 2112,2130 ----
   1104 | 204 | ddd                | 
  (819 rows)
  
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;    -- can't be pushed down
+                                                       QUERY PLAN                                                       
+ -----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Remote SQL: UPDATE "S 1"."T 1" SET c7 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, 'ft2       '::character(10), c8, ctid
+          Filter: (date(ft2.c4) = '01-01-1970'::date)
+          Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c8, ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 0)) FOR UPDATE
+ (6 rows)
+ 
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
***************
*** 2233,2239 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2266,2272 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2392,2398 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2425,2431 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2840,2845 **** NOTICE:  NEW: (13,"test triggered !")
--- 2873,3082 ----
   (0,27)
  (1 row)
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ -- Test update-pushdown functionality
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_stmt_before ON rem1;
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_stmt_after ON rem1;
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_row_before_update ON rem1;
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                   QUERY PLAN                                   
+ -------------------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_row_after_update ON rem1;
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                                QUERY PLAN                               
+ ------------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_after_delete ON rem1;
  -- ===================================================================
  -- test IMPORT FOREIGN SCHEMA
  -- ===================================================================
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 86,92 **** typedef struct PgFdwRelationInfo
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
--- 86,97 ----
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) List of restriction clauses that can be executed remotely
!  * 3) Integer list of attribute numbers retrieved by the SELECT
!  * 4) UPDATE/DELETE statement text to be sent to the remote server
!  * 5) Boolean flag showing if we set the command es_processed
!  * 6) Boolean flag showing if the remote query has a RETURNING clause
!  * 7) Integer list of attribute numbers retrieved by RETURNING, if any
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
***************
*** 96,105 **** enum FdwScanPrivateIndex
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
! 	/* Integer list of attribute numbers retrieved by the SELECT */
! 	FdwScanPrivateRetrievedAttrs
  };
  
  /*
   * Similarly, this enum describes what's kept in the fdw_private list for
   * a ModifyTable node referencing a postgres_fdw foreign table.  We store:
--- 101,123 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
! 	/* List of restriction clauses that can be executed remotely */
! 	FdwScanPrivateRemoteConds,
! 	/* Integer list of attribute numbers retrieved by SELECT */
! 	FdwScanPrivateRetrievedAttrsBySelect,
! 	/* UPDATE/DELETE statement to execute remotely (as a String node) */
! 	FdwScanPrivateUpdateSql,
! 	/* set-processed flag (as an integer Value node) */
! 	FdwScanPrivateSetProcessed,
! 	/* has-returning flag (as an integer Value node) */
! 	FdwScanPrivateHasReturning,
! 	/* Integer list of attribute numbers retrieved by RETURNING */
! 	FdwScanPrivateRetrievedAttrsByReturning
  };
  
+ #define SelectFdwScanPrivateLength					3
+ #define UpdateFdwScanPrivateLength					7
+ 
  /*
   * Similarly, this enum describes what's kept in the fdw_private list for
   * a ModifyTable node referencing a postgres_fdw foreign table.  We store:
***************
*** 131,138 **** typedef struct PgFdwScanState
  	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
  
  	/* extracted fdw_private data */
! 	char	   *query;			/* text of SELECT command */
  	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
  
  	/* for remote query execution */
  	PGconn	   *conn;			/* connection for the scan */
--- 149,158 ----
  	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
  
  	/* extracted fdw_private data */
! 	char	   *query;			/* text of SELECT or UPDATE/DELETE command */
  	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
  
  	/* for remote query execution */
  	PGconn	   *conn;			/* connection for the scan */
***************
*** 152,157 **** typedef struct PgFdwScanState
--- 172,182 ----
  	int			fetch_ct_2;		/* Min(# of fetches done, 2) */
  	bool		eof_reached;	/* true if last fetch reached EOF */
  
+ 	/* for update pushdown */
+ 	bool		update_is_pushed_down;	/* is UPDATE/DELETE pushed down? */
+ 	PGresult   *result;			/* result of an UPDATE/DELETE query */
+ 	TupleTableSlot *rslot;		/* slot containing the result tuple */
+ 
  	/* working memory contexts */
  	MemoryContext batch_cxt;	/* context holding current batch of tuples */
  	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
***************
*** 180,185 **** typedef struct PgFdwModifyState
--- 205,214 ----
  	int			p_nums;			/* number of parameters to transmit */
  	FmgrInfo   *p_flinfo;		/* output conversion functions for them */
  
+ 	/* for update pushdown */
+ 	bool		update_is_pushed_down;	/* is UPDATE/DELETE pushed down? */
+ 	PgFdwScanState *fsstate;	/* execution state of a foreign scan */
+ 
  	/* working memory context */
  	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
  } PgFdwModifyState;
***************
*** 308,319 **** static bool ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
  static void create_cursor(ForeignScanState *node);
  static void fetch_more_data(ForeignScanState *node);
  static void close_cursor(PGconn *conn, unsigned int cursor_number);
  static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
--- 337,365 ----
  static void create_cursor(ForeignScanState *node);
  static void fetch_more_data(ForeignScanState *node);
  static void close_cursor(PGconn *conn, unsigned int cursor_number);
+ static bool update_is_pushdown_safe(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index,
+ 									Relation rel,
+ 									List *targetAttrs);
+ static List *push_update_down(PlannerInfo *root,
+ 							  ModifyTable *plan,
+ 							  Index resultRelation,
+ 							  int subplan_index,
+ 							  Relation rel,
+ 							  List *targetAttrs);
  static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 852,858 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make2(makeString(sql.data),
  							 retrieved_attrs);
  
  	/*
--- 898,905 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make3(makeString(sql.data),
! 							 remote_conds,
  							 retrieved_attrs);
  
  	/*
***************
*** 914,935 **** postgresBeginForeignScan(ForeignScanState *node, int eflags)
  	server = GetForeignServer(table->serverid);
  	user = GetUserMapping(userid, server->serverid);
  
  	/*
  	 * Get connection to the foreign server.  Connection manager will
  	 * establish new connection if necessary.
  	 */
  	fsstate->conn = GetConnection(server, user, false);
  
- 	/* Assign a unique ID for my cursor */
- 	fsstate->cursor_number = GetCursorNumber(fsstate->conn);
- 	fsstate->cursor_exists = false;
- 
- 	/* Get private info created by planner functions. */
- 	fsstate->query = strVal(list_nth(fsplan->fdw_private,
- 									 FdwScanPrivateSelectSql));
- 	fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
- 											   FdwScanPrivateRetrievedAttrs);
- 
  	/* Create contexts for batches of tuples and per-tuple temp workspace. */
  	fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											   "postgres_fdw tuple data",
--- 961,994 ----
  	server = GetForeignServer(table->serverid);
  	user = GetUserMapping(userid, server->serverid);
  
+ 	/* Get private info created by planner functions. */
+ 	if (list_length(fsplan->fdw_private) == UpdateFdwScanPrivateLength)
+ 	{
+ 		fsstate->query = strVal(list_nth(fsplan->fdw_private,
+ 										 FdwScanPrivateUpdateSql));
+ 		fsstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+ 												 FdwScanPrivateSetProcessed));
+ 		fsstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+ 												 FdwScanPrivateHasReturning));
+ 		fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 									FdwScanPrivateRetrievedAttrsByReturning);
+ 	}
+ 	else
+ 	{
+ 		Assert(list_length(fsplan->fdw_private) == SelectFdwScanPrivateLength);
+ 
+ 		fsstate->query = strVal(list_nth(fsplan->fdw_private,
+ 										 FdwScanPrivateSelectSql));
+ 		fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 										FdwScanPrivateRetrievedAttrsBySelect);
+ 	}
+ 
  	/*
  	 * Get connection to the foreign server.  Connection manager will
  	 * establish new connection if necessary.
  	 */
  	fsstate->conn = GetConnection(server, user, false);
  
  	/* Create contexts for batches of tuples and per-tuple temp workspace. */
  	fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											   "postgres_fdw tuple data",
***************
*** 945,950 **** postgresBeginForeignScan(ForeignScanState *node, int eflags)
--- 1004,1023 ----
  	/* Get info we'll need for input data conversion. */
  	fsstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(fsstate->rel));
  
+ 	/*
+ 	 * If pushing update down, we've got no more to do.
+ 	 */
+ 	if (list_length(fsplan->fdw_private) == UpdateFdwScanPrivateLength)
+ 	{
+ 		fsstate->num_tuples = -1;		/* -1 means not set yet */
+ 		fsstate->update_is_pushed_down = true;
+ 		return;
+ 	}
+ 
+ 	/* Assign a unique ID for my cursor */
+ 	fsstate->cursor_number = GetCursorNumber(fsstate->conn);
+ 	fsstate->cursor_exists = false;
+ 
  	/* Prepare for output conversion of parameters used in remote query. */
  	numParams = list_length(fsplan->fdw_exprs);
  	fsstate->numParams = numParams;
***************
*** 995,1000 **** postgresIterateForeignScan(ForeignScanState *node)
--- 1068,1164 ----
  	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
  
  	/*
+ 	 * If pushing update down, get the result of UPDATE/DELETE RETURNING.
+ 	 */
+ 	if (fsstate->update_is_pushed_down)
+ 	{
+ 		MemoryContext oldcontext;
+ 
+ 		/*
+ 		 * If this is the first call after Begin, we need to execute the statement,
+ 		 * and check for success.
+ 		 */
+ 		if (fsstate->num_tuples == -1)
+ 		{
+ 			/*
+ 			 * We don't use a PG_TRY block here, so be careful not to throw error
+ 			 * without releasing the PGresult.
+ 			 */
+ 			fsstate->result = PQexec(fsstate->conn, fsstate->query);
+ 			if (PQresultStatus(fsstate->result) !=
+ 				(fsstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 				pgfdw_report_error(ERROR, fsstate->result, fsstate->conn, true,
+ 								   fsstate->query);
+ 
+ 			/* Check number of rows affected. */
+ 			if (fsstate->has_returning)
+ 				fsstate->num_tuples = PQntuples(fsstate->result);
+ 			else
+ 				fsstate->num_tuples = atoi(PQcmdTuples(fsstate->result));
+ 		}
+ 
+ 		/*
+ 		 * If the update query doesn't have a RETURNING clause, then there is
+ 		 * nothing to do, so we just return an empty slot.
+ 		 */
+ 		if (!fsstate->has_returning)
+ 		{
+ 			/*
+ 			 * Increment the command es_processed count if necessary.
+ 			 * (ModifyTable cannot do that by itself in this case.)
+ 			 */
+ 			if (fsstate->set_processed)
+ 			{
+ 				EState	   *estate = node->ss.ps.state;
+ 
+ 				estate->es_processed += fsstate->num_tuples;
+ 			}
+ 
+ 			/*
+ 			 * Increment the tuple count for EXPLAIN ANALYZE if necessary.
+ 			 * (EXPLAIN ANALYZE cannot do that by itself in this case.)
+ 			 */
+ 			if (node->ss.ps.instrument)
+ 			{
+ 				Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 				instr->ntuples += fsstate->num_tuples;
+ 			}
+ 
+ 			return ExecClearTuple(slot);
+ 		}
+ 
+ 		/* If we didn't get any tuples, must be end of data. */
+ 		if (fsstate->next_tuple >= fsstate->num_tuples)
+ 			return ExecClearTuple(slot);
+ 
+ 		/* OK, we'll store RETURNING tuples in the batch_cxt. */
+ 		oldcontext = MemoryContextSwitchTo(fsstate->batch_cxt);
+ 
+ 		/* Fetch the next tuple. */
+ 		store_returning_result(slot,
+ 							   fsstate->result,
+ 							   fsstate->next_tuple,
+ 							   fsstate->rel,
+ 							   fsstate->attinmeta,
+ 							   fsstate->retrieved_attrs,
+ 							   fsstate->temp_cxt);
+ 		fsstate->rslot = slot;
+ 		fsstate->next_tuple++;
+ 
+ 		MemoryContextSwitchTo(oldcontext);
+ 
+ 		/*
+ 		 * Return slot.  Note that this is safe because we can avoid applying
+ 		 * ExecQual to the tuple due to no local quals (see the comment for
+ 		 * update_is_pushdown_safe) and because the tuple can be safely
+ 		 * projected by ExecProject (see push_update_down) and would then be
+ 		 * ignored in postgresExecForeignUpdate or postgresExecForeignDelete.
+ 		 */
+ 		return slot;
+ 	}
+ 
+ 	/*
  	 * If this is the first call after Begin or ReScan, we need to create the
  	 * cursor on the remote side.
  	 */
***************
*** 1036,1041 **** postgresReScanForeignScan(ForeignScanState *node)
--- 1200,1208 ----
  	char		sql[64];
  	PGresult   *res;
  
+ 	/* This shouldn't be called in update pushdown case. */
+ 	Assert(fsstate->update_is_pushed_down == false);
+ 
  	/* If we haven't created the cursor yet, nothing to do. */
  	if (!fsstate->cursor_exists)
  		return;
***************
*** 1094,1099 **** postgresEndForeignScan(ForeignScanState *node)
--- 1261,1273 ----
  	if (fsstate == NULL)
  		return;
  
+ 	/* if pushing update down, nothing to do other than cleanup */
+ 	if (fsstate->update_is_pushed_down)
+ 	{
+ 		if (fsstate->result)
+ 			PQclear(fsstate->result);
+ 	}
+ 
  	/* Close the cursor if open, to prevent accumulation of cursors */
  	if (fsstate->cursor_exists)
  		close_cursor(fsstate->conn, fsstate->cursor_number);
***************
*** 1167,1174 **** postgresPlanForeignModify(PlannerInfo *root,
  	List	   *returningList = NIL;
  	List	   *retrieved_attrs = NIL;
  
- 	initStringInfo(&sql);
- 
  	/*
  	 * Core code already has some lock on each rel being planned, so we can
  	 * use NoLock here.
--- 1341,1346 ----
***************
*** 1210,1215 **** postgresPlanForeignModify(PlannerInfo *root,
--- 1382,1411 ----
  	}
  
  	/*
+ 	 * For UPDATE/DELETE, if there are no local conditions or joins needed (see
+ 	 * update_is_pushdown_safe for more details), we push the command down.
+ 	 */
+ 	if (operation == CMD_UPDATE || operation == CMD_DELETE)
+ 	{
+ 		/* Check whether it's safe to push the command down. */
+ 		if (update_is_pushdown_safe(root, plan,
+ 									resultRelation,
+ 									subplan_index,
+ 									rel, targetAttrs))
+ 		{
+ 			List	   *fdw_private;
+ 
+ 			/* OK, modify plan so as to push the command down. */
+ 			fdw_private = push_update_down(root, plan,
+ 										   resultRelation,
+ 										   subplan_index,
+ 										   rel, targetAttrs);
+ 			heap_close(rel, NoLock);
+ 			return fdw_private;
+ 		}
+ 	}
+ 
+ 	/*
  	 * Extract the relevant RETURNING list if any.
  	 */
  	if (plan->returningLists)
***************
*** 1218,1223 **** postgresPlanForeignModify(PlannerInfo *root,
--- 1414,1420 ----
  	/*
  	 * Construct the SQL command string.
  	 */
+ 	initStringInfo(&sql);
  	switch (operation)
  	{
  		case CMD_INSERT:
***************
*** 1288,1293 **** postgresBeginForeignModify(ModifyTableState *mtstate,
--- 1485,1526 ----
  	fmstate = (PgFdwModifyState *) palloc0(sizeof(PgFdwModifyState));
  	fmstate->rel = rel;
  
+ 	/* Deconstruct fdw_private data. */
+ 	fmstate->query = strVal(list_nth(fdw_private,
+ 									 FdwModifyPrivateUpdateSql));
+ 	fmstate->target_attrs = (List *) list_nth(fdw_private,
+ 											  FdwModifyPrivateTargetAttnums);
+ 	fmstate->has_returning = intVal(list_nth(fdw_private,
+ 											 FdwModifyPrivateHasReturning));
+ 	fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
+ 											 FdwModifyPrivateRetrievedAttrs);
+ 
+ 	/*
+ 	 * if query is NULL, we are in update pushdown case.
+ 	 */
+ 	if (fmstate->query == NULL)
+ 	{
+ 		PlanState	   *node = mtstate->mt_plans[subplan_index];
+ 		PgFdwScanState *fsstate;
+ 
+ 		Assert(fmstate->target_attrs == NIL);
+ 		Assert(fmstate->has_returning == false);
+ 		Assert(fmstate->retrieved_attrs == NIL);
+ 
+ 		Assert(nodeTag(node) == T_ForeignScanState);
+ 		fsstate = (PgFdwScanState *) ((ForeignScanState *) node)->fdw_state;
+ 		Assert(fsstate->update_is_pushed_down);
+ 
+ 		fmstate->update_is_pushed_down = true;
+ 		if (fsstate->has_returning)
+ 		{
+ 			fmstate->has_returning = true;
+ 			fmstate->fsstate = fsstate;
+ 		}
+ 		resultRelInfo->ri_FdwState = fmstate;
+ 		return;
+ 	}
+ 
  	/*
  	 * Identify which user to do the remote access as.  This should match what
  	 * ExecCheckRTEPerms() does.
***************
*** 1304,1319 **** postgresBeginForeignModify(ModifyTableState *mtstate,
  	fmstate->conn = GetConnection(server, user, true);
  	fmstate->p_name = NULL;		/* prepared statement not made yet */
  
- 	/* Deconstruct fdw_private data. */
- 	fmstate->query = strVal(list_nth(fdw_private,
- 									 FdwModifyPrivateUpdateSql));
- 	fmstate->target_attrs = (List *) list_nth(fdw_private,
- 											  FdwModifyPrivateTargetAttnums);
- 	fmstate->has_returning = intVal(list_nth(fdw_private,
- 											 FdwModifyPrivateHasReturning));
- 	fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
- 											 FdwModifyPrivateRetrievedAttrs);
- 
  	/* Create context for per-tuple temp workspace. */
  	fmstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											  "postgres_fdw temporary data",
--- 1537,1542 ----
***************
*** 1411,1417 **** postgresExecForeignInsert(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1634,1644 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1442,1447 **** postgresExecForeignUpdate(EState *estate,
--- 1669,1682 ----
  	PGresult   *res;
  	int			n_rows;
  
+ 	/* Just return slot created by the ForeignScan, if pushing update down */
+ 	if (fmstate->update_is_pushed_down)
+ 	{
+ 		Assert(fmstate->has_returning);
+ 		Assert(fmstate->fsstate->rslot);
+ 		return fmstate->fsstate->rslot;
+ 	}
+ 
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
  		prepare_foreign_modify(fmstate);
***************
*** 1481,1487 **** postgresExecForeignUpdate(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1716,1726 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1512,1517 **** postgresExecForeignDelete(EState *estate,
--- 1751,1764 ----
  	PGresult   *res;
  	int			n_rows;
  
+ 	/* Just return slot created by the ForeignScan, if pushing update down */
+ 	if (fmstate->update_is_pushed_down)
+ 	{
+ 		Assert(fmstate->has_returning);
+ 		Assert(fmstate->fsstate->rslot);
+ 		return fmstate->fsstate->rslot;
+ 	}
+ 
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
  		prepare_foreign_modify(fmstate);
***************
*** 1551,1557 **** postgresExecForeignDelete(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1798,1808 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1579,1584 **** postgresEndForeignModify(EState *estate,
--- 1830,1839 ----
  	if (fmstate == NULL)
  		return;
  
+ 	/* If pushing update down, nothing to do */
+ 	if (fmstate->update_is_pushed_down)
+ 		return;
+ 
  	/* If we created a prepared statement, destroy it */
  	if (fmstate->p_name)
  	{
***************
*** 1661,1667 **** postgresExplainForeignScan(ForeignScanState *node, ExplainState *es)
  	if (es->verbose)
  	{
  		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
! 		sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
  		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
--- 1916,1930 ----
  	if (es->verbose)
  	{
  		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
! 		if (list_length(fdw_private) == UpdateFdwScanPrivateLength)
! 		{
! 			sql = strVal(list_nth(fdw_private, FdwScanPrivateUpdateSql));
! 		}
! 		else
! 		{
! 			Assert(list_length(fdw_private) == SelectFdwScanPrivateLength);
! 			sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
! 		}
  		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
***************
*** 1682,1688 **** postgresExplainForeignModify(ModifyTableState *mtstate,
  		char	   *sql = strVal(list_nth(fdw_private,
  										  FdwModifyPrivateUpdateSql));
  
! 		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
  
--- 1945,1952 ----
  		char	   *sql = strVal(list_nth(fdw_private,
  										  FdwModifyPrivateUpdateSql));
  
! 		if (sql != NULL)
! 			ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
  
***************
*** 1911,1916 **** ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
--- 2175,2394 ----
  }
  
  /*
+  * Check whether it's safe to push the UPDATE/DELETE command down.
+  *
+  * Conditions checked here:
+  *
+  * 1. If the target relation has any row-level local BEFORE/AFTER triggers, we
+  * must not push the command down, since that breaks execution of the triggers.
+  *
+  * 2. If there are any local joins needed, we mustn't push the command down,
+  * because that breaks execution of the joins.
+  *
+  * 3. If there are any quals that can't be evaluated remotely, we mustn't push
+  * the command down, because that breaks evaluation of the quals.
+  *
+  * 4. In UPDATE, if it is unsafe to evaluate any expressions to assign to the
+  * target columns on the remote server, we must not push the command down.
+  */
+ static bool
+ update_is_pushdown_safe(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index,
+ 						Relation rel,
+ 						List *targetAttrs)
+ {
+ 	CmdType		operation = plan->operation;
+ 	RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ListCell   *lc;
+ 
+ 	/* Check point 1 */
+ 	if (rel->trigdesc &&
+ 		((operation == CMD_UPDATE &&
+ 		  (rel->trigdesc->trig_update_after_row ||
+ 		   rel->trigdesc->trig_update_before_row)) ||
+ 		 (operation == CMD_DELETE &&
+ 		  (rel->trigdesc->trig_delete_after_row ||
+ 		   rel->trigdesc->trig_delete_before_row))))
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(subplan->targetlist,
+ 											attnum);
+ 
+ 		if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 			return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ /*
+  * Modify a plan so as to push the update command down.
+  */
+ static List *
+ push_update_down(PlannerInfo *root,
+ 				 ModifyTable *plan,
+ 				 Index resultRelation,
+ 				 int subplan_index,
+ 				 Relation rel,
+ 				 List *targetAttrs)
+ {
+ 	CmdType		operation = plan->operation;
+ 	bool		canSetTag = plan->canSetTag;
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ForeignScan *fscan = (ForeignScan *) subplan;
+ 	StringInfoData sql;
+ 	List	   *remote_conds;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 	List	   *new_tlist = NIL;
+ 	List	   *fdw_private;
+ 
+ 	Assert(operation == CMD_UPDATE || operation == CMD_DELETE);
+ 
+ 	initStringInfo(&sql);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		List	   *targetlist = subplan->targetlist;
+ 
+ 		deparseDirectUpdateSql(&sql, root, resultRelation, rel,
+ 							   remote_conds,
+ 							   targetlist,
+ 							   targetAttrs,
+ 							   returningList,
+ 							   &retrieved_attrs);
+ 	}
+ 	else
+ 	{
+ 		Assert(operation == CMD_DELETE);
+ 
+ 		deparseDirectDeleteSql(&sql, root, resultRelation, rel,
+ 							   remote_conds,
+ 							   returningList,
+ 							   &retrieved_attrs);
+ 	}
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwScanPrivateIndex, above.
+ 	 */
+ 	fscan->fdw_private = lappend(fscan->fdw_private, makeString(sql.data));
+ 	fscan->fdw_private = lappend(fscan->fdw_private, makeInteger(canSetTag));
+ 	fscan->fdw_private = lappend(fscan->fdw_private,
+ 								 makeInteger((retrieved_attrs != NIL)));
+ 	fscan->fdw_private = lappend(fscan->fdw_private, retrieved_attrs);
+ 
+ 	/*
+ 	 * Rrewrite the targetlist for an UPDATE command for safety of ExecProject.
+ 	 * Note we ignore and do not reference result tuples in update pushdown case.
+ 	 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		ListCell   *lc;
+ 		int			attrno = 1;
+ 		int			numattrs = RelationGetNumberOfAttributes(rel);
+ 
+ 		foreach(lc, subplan->targetlist)
+ 		{
+ 			TargetEntry *tle = (TargetEntry *) lfirst(lc);
+ 
+ 			if (tle->resjunk)
+ 			{
+ 				new_tlist = lappend(new_tlist, tle);
+ 				continue;
+ 			}
+ 
+ 			if (attrno > numattrs)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 						 errmsg("table row type and query-specified row type do not match"),
+ 						 errdetail("Query has too many columns.")));
+ 
+ 			if (!list_member_int(targetAttrs, attrno))
+ 				new_tlist = lappend(new_tlist, tle);
+ 			else
+ 			{
+ 				Form_pg_attribute attr;
+ 				Oid			atttype;
+ 				int32		atttypmod;
+ 				Oid			attcollation;
+ 				Node	   *new_expr;
+ 				TargetEntry *new_tle;
+ 
+ 				attr = rel->rd_att->attrs[attrno - 1];
+ 
+ 				Assert(!attr->attisdropped);
+ 				atttype = attr->atttypid;
+ 				atttypmod = attr->atttypmod;
+ 				attcollation = attr->attcollation;
+ 
+ 				new_expr = (Node *) makeVar(resultRelation,
+ 											attrno,
+ 											atttype,
+ 											atttypmod,
+ 											attcollation,
+ 											0);
+ 
+ 				new_tle = makeTargetEntry((Expr *) new_expr,
+ 										  attrno,
+ 										  pstrdup(NameStr(attr->attname)),
+ 										  false);
+ 
+ 				new_tlist = lappend(new_tlist, new_tle);
+ 			}
+ 
+ 			attrno++;
+ 		}
+ 
+ 		if (attrno != numattrs + 1)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 					 errmsg("table row type and query-specified row type do not match"),
+ 					 errdetail("Query has too few columns.")));
+ 
+ 		subplan->targetlist = new_tlist;
+ 	}
+ 
+ 	/*
+ 	 * Build the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwModifyPrivateIndex, above.
+ 	 */
+ 	fdw_private = list_make4(makeString(NULL), NIL, makeInteger(false), NIL);
+ 
+ 	return fdw_private;
+ }
+ 
+ /*
   * Create cursor for node's query with current parameter values.
   */
  static void
***************
*** 2258,2275 **** convert_prep_stmt_params(PgFdwModifyState *fmstate,
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, 0,
! 											fmstate->rel,
! 											fmstate->attinmeta,
! 											fmstate->retrieved_attrs,
! 											fmstate->temp_cxt);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
--- 2736,2758 ----
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, row,
! 											rel,
! 											attinmeta,
! 											retrieved_attrs,
! 											temp_context);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 66,75 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 66,87 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,
+ 								   Index rtindex, Relation rel,
+ 								   List	*remote_conds,
+ 								   List	*targetlist,
+ 								   List *targetAttrs,
+ 								   List *returningList,
+ 								   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root,
+ 								   Index rtindex, Relation rel,
+ 								   List	*remote_conds,
+ 								   List *returningList,
+ 								   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 320,339 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
--- 320,346 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;    -- can't be pushed down
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
***************
*** 616,621 **** UPDATE rem1 SET f2 = 'testo';
--- 623,711 ----
  -- Test returning a system attribute
  INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ 
+ 
+ -- Test update-pushdown functionality
+ 
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_before ON rem1;
+ 
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_after ON rem1;
+ 
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ 
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_update ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_update ON rem1;
+ 
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_after_delete ON rem1;
+ 
  -- ===================================================================
  -- test IMPORT FOREIGN SCHEMA
  -- ===================================================================
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 414,419 ****
--- 414,428 ----
     <literal>WHERE</> clauses are not sent to the remote server unless they use
     only built-in data types, operators, and functions.  Operators and
     functions in the clauses must be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, or no row-level local <literal>BEFORE</> or
+    <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, and <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 188,197 **** is_foreign_expr(PlannerInfo *root,
  	if (!foreign_expr_walker((Node *) expr, &glob_cxt, &loc_cxt))
  		return false;
  
- 	/* Expressions examined here should be boolean, ie noncollatable */
- 	Assert(loc_cxt.collation == InvalidOid);
- 	Assert(loc_cxt.state == FDW_COLLATE_NONE);
- 
  	/*
  	 * An expression which includes any mutable functions can't be sent over
  	 * because its result is not stable.  For example, sending now() remote
--- 188,193 ----
***************
*** 927,932 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 923,982 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,
+ 					   Index rtindex, Relation rel,
+ 					   List	*remote_conds,
+ 					   List	*targetlist,
+ 					   List *targetAttrs,
+ 					   List *returningList,
+ 					   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	List	   *params_list = NIL;
+ 	deparse_expr_cxt context;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = &params_list;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfo(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, &params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 949,954 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 999,1031 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root,
+ 					   Index rtindex, Relation rel,
+ 					   List	*remote_conds,
+ 					   List *returningList,
+ 					   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	List	   *params_list = NIL;
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, &params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 998,1004 **** INSERT INTO ft2 (c1,c2,c3)
--- 998,1025 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, c7, c8, ctid
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, c7, c8, ctid
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (5 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1108,1114 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1129,1135 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1129,1144 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
-    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
     ->  Foreign Scan on public.ft2
           Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1150,1164 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
     ->  Foreign Scan on public.ft2
           Output: ctid
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (5 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1249,1255 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1269,1275 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2092,2097 **** SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
--- 2112,2130 ----
   1104 | 204 | ddd                | 
  (819 rows)
  
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;    -- can't be pushed down
+                                                       QUERY PLAN                                                       
+ -----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Remote SQL: UPDATE "S 1"."T 1" SET c7 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, 'ft2       '::character(10), c8, ctid
+          Filter: (date(ft2.c4) = '01-01-1970'::date)
+          Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c8, ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 0)) FOR UPDATE
+ (6 rows)
+ 
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
***************
*** 2233,2239 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2266,2272 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2392,2398 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2425,2431 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2840,2845 **** NOTICE:  NEW: (13,"test triggered !")
--- 2873,3083 ----
   (0,27)
  (1 row)
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ -- Test update-pushdown functionality
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_stmt_before ON rem1;
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_stmt_after ON rem1;
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_row_before_update ON rem1;
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                   QUERY PLAN                                   
+ -------------------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: ctid
+          Remote SQL: DELETE FROM public.loc1
+ (4 rows)
+ 
+ DROP TRIGGER trig_row_after_update ON rem1;
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Scan on public.rem1
+          Output: f1, f2, ctid
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (4 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                                QUERY PLAN                               
+ ------------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_after_delete ON rem1;
  -- ===================================================================
  -- test IMPORT FOREIGN SCHEMA
  -- ===================================================================
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 86,92 **** typedef struct PgFdwRelationInfo
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
--- 86,98 ----
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) List of restriction clauses that can be executed remotely
!  * 3) Integer list of attribute numbers retrieved by the SELECT
!  * 4) Boolean flag showing if an UPDATE/DELETE is pushed down
!  * 5) UPDATE/DELETE statement text to be sent to the remote server
!  * 6) Boolean flag showing if we set the command es_processed
!  * 7) Boolean flag showing if the remote query has a RETURNING clause
!  * 8) Integer list of attribute numbers retrieved by RETURNING, if any
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
***************
*** 96,103 **** enum FdwScanPrivateIndex
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
! 	/* Integer list of attribute numbers retrieved by the SELECT */
! 	FdwScanPrivateRetrievedAttrs
  };
  
  /*
--- 102,121 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
! 	/* List of restriction clauses that can be executed remotely */
! 	FdwScanPrivateRemoteConds,
! 	/* Integer list of attribute numbers retrieved by SELECT */
! 	FdwScanPrivateRetrievedAttrsBySelect,
! 	/* UPDATE/DELETE-pushdown flag (as an integer Value node) */
! 	FdwScanPrivateUpdatePushdown,
! 	/* UPDATE/DELETE statement to execute remotely (as a String node) */
! 	FdwScanPrivateUpdateSql,
! 	/* set-processed flag (as an integer Value node) */
! 	FdwScanPrivateSetProcessed,
! 	/* has-returning flag (as an integer Value node) */
! 	FdwScanPrivateHasReturning,
! 	/* Integer list of attribute numbers retrieved by RETURNING */
! 	FdwScanPrivateRetrievedAttrsByReturning
  };
  
  /*
***************
*** 131,138 **** typedef struct PgFdwScanState
  	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
  
  	/* extracted fdw_private data */
! 	char	   *query;			/* text of SELECT command */
  	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
  
  	/* for remote query execution */
  	PGconn	   *conn;			/* connection for the scan */
--- 149,158 ----
  	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
  
  	/* extracted fdw_private data */
! 	char	   *query;			/* text of SELECT or UPDATE/DELETE command */
  	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
  
  	/* for remote query execution */
  	PGconn	   *conn;			/* connection for the scan */
***************
*** 152,157 **** typedef struct PgFdwScanState
--- 172,182 ----
  	int			fetch_ct_2;		/* Min(# of fetches done, 2) */
  	bool		eof_reached;	/* true if last fetch reached EOF */
  
+ 	/* for update pushdown */
+ 	bool		update_pushdown;	/* is an UPDATE/DELETE pushed down? */
+ 	PGresult   *result;			/* result of an UPDATE/DELETE query */
+ 	TupleTableSlot *rslot;		/* slot containing the result tuple */
+ 
  	/* working memory contexts */
  	MemoryContext batch_cxt;	/* context holding current batch of tuples */
  	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
***************
*** 180,185 **** typedef struct PgFdwModifyState
--- 205,214 ----
  	int			p_nums;			/* number of parameters to transmit */
  	FmgrInfo   *p_flinfo;		/* output conversion functions for them */
  
+ 	/* for update pushdown */
+ 	bool		update_pushdown;	/* is an UPDATE/DELETE pushed down? */
+ 	PgFdwScanState *fsstate;	/* execution state of a foreign scan */
+ 
  	/* working memory context */
  	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
  } PgFdwModifyState;
***************
*** 308,319 **** static bool ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
  static void create_cursor(ForeignScanState *node);
  static void fetch_more_data(ForeignScanState *node);
  static void close_cursor(PGconn *conn, unsigned int cursor_number);
  static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
--- 337,367 ----
  static void create_cursor(ForeignScanState *node);
  static void fetch_more_data(ForeignScanState *node);
  static void close_cursor(PGconn *conn, unsigned int cursor_number);
+ static bool update_is_pushdown_safe(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index,
+ 									Relation rel,
+ 									List *targetAttrs);
+ static List *push_update_down(PlannerInfo *root,
+ 							  ModifyTable *plan,
+ 							  Index resultRelation,
+ 							  int subplan_index,
+ 							  Relation rel,
+ 							  List *targetAttrs);
+ static List *rewrite_targetlist(Index resultRelation, Relation rel,
+ 								List *targetlist, List *targetAttrs);
  static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 852,859 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make2(makeString(sql.data),
! 							 retrieved_attrs);
  
  	/*
  	 * Create the ForeignScan node from target list, local filtering
--- 900,909 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make4(makeString(sql.data),
! 							 remote_conds,
! 							 retrieved_attrs,
! 							 makeInteger(false));
  
  	/*
  	 * Create the ForeignScan node from target list, local filtering
***************
*** 914,935 **** postgresBeginForeignScan(ForeignScanState *node, int eflags)
  	server = GetForeignServer(table->serverid);
  	user = GetUserMapping(userid, server->serverid);
  
  	/*
  	 * Get connection to the foreign server.  Connection manager will
  	 * establish new connection if necessary.
  	 */
  	fsstate->conn = GetConnection(server, user, false);
  
- 	/* Assign a unique ID for my cursor */
- 	fsstate->cursor_number = GetCursorNumber(fsstate->conn);
- 	fsstate->cursor_exists = false;
- 
- 	/* Get private info created by planner functions. */
- 	fsstate->query = strVal(list_nth(fsplan->fdw_private,
- 									 FdwScanPrivateSelectSql));
- 	fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
- 											   FdwScanPrivateRetrievedAttrs);
- 
  	/* Create contexts for batches of tuples and per-tuple temp workspace. */
  	fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											   "postgres_fdw tuple data",
--- 964,997 ----
  	server = GetForeignServer(table->serverid);
  	user = GetUserMapping(userid, server->serverid);
  
+ 	/* Get private info created by planner functions. */
+ 	fsstate->update_pushdown = intVal(list_nth(fsplan->fdw_private,
+ 											   FdwScanPrivateUpdatePushdown));
+ 	if (fsstate->update_pushdown)
+ 	{
+ 		fsstate->query = strVal(list_nth(fsplan->fdw_private,
+ 										 FdwScanPrivateUpdateSql));
+ 		fsstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+ 												 FdwScanPrivateSetProcessed));
+ 		fsstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+ 												 FdwScanPrivateHasReturning));
+ 		fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 									  FdwScanPrivateRetrievedAttrsByReturning);
+ 	}
+ 	else
+ 	{
+ 		fsstate->query = strVal(list_nth(fsplan->fdw_private,
+ 										 FdwScanPrivateSelectSql));
+ 		fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 										 FdwScanPrivateRetrievedAttrsBySelect);
+ 	}
+ 
  	/*
  	 * Get connection to the foreign server.  Connection manager will
  	 * establish new connection if necessary.
  	 */
  	fsstate->conn = GetConnection(server, user, false);
  
  	/* Create contexts for batches of tuples and per-tuple temp workspace. */
  	fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											   "postgres_fdw tuple data",
***************
*** 945,950 **** postgresBeginForeignScan(ForeignScanState *node, int eflags)
--- 1007,1025 ----
  	/* Get info we'll need for input data conversion. */
  	fsstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(fsstate->rel));
  
+ 	/*
+ 	 * If pushing update down, we've got no more to do.
+ 	 */
+ 	if (fsstate->update_pushdown)
+ 	{
+ 		fsstate->num_tuples = -1;		/* -1 means not set yet */
+ 		return;
+ 	}
+ 
+ 	/* Assign a unique ID for my cursor */
+ 	fsstate->cursor_number = GetCursorNumber(fsstate->conn);
+ 	fsstate->cursor_exists = false;
+ 
  	/* Prepare for output conversion of parameters used in remote query. */
  	numParams = list_length(fsplan->fdw_exprs);
  	fsstate->numParams = numParams;
***************
*** 995,1000 **** postgresIterateForeignScan(ForeignScanState *node)
--- 1070,1166 ----
  	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
  
  	/*
+ 	 * Get the result of an UPDATE/DELETE RETURNING, if pushing the command down.
+ 	 */
+ 	if (fsstate->update_pushdown)
+ 	{
+ 		MemoryContext oldcontext;
+ 
+ 		/*
+ 		 * If this is the first call after Begin, we need to execute the statement,
+ 		 * and check for success.
+ 		 */
+ 		if (fsstate->num_tuples == -1)
+ 		{
+ 			/*
+ 			 * We don't use a PG_TRY block here, so be careful not to throw error
+ 			 * without releasing the PGresult.
+ 			 */
+ 			fsstate->result = PQexec(fsstate->conn, fsstate->query);
+ 			if (PQresultStatus(fsstate->result) !=
+ 				(fsstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 				pgfdw_report_error(ERROR, fsstate->result, fsstate->conn, true,
+ 								   fsstate->query);
+ 
+ 			/* Check number of rows affected. */
+ 			if (fsstate->has_returning)
+ 				fsstate->num_tuples = PQntuples(fsstate->result);
+ 			else
+ 				fsstate->num_tuples = atoi(PQcmdTuples(fsstate->result));
+ 		}
+ 
+ 		/*
+ 		 * If the update query doesn't have a RETURNING clause, then there is
+ 		 * nothing to do, so we just return an empty slot.
+ 		 */
+ 		if (!fsstate->has_returning)
+ 		{
+ 			/*
+ 			 * Increment the command es_processed count if necessary.
+ 			 * (Note: ModifyTable cannot do that by itself in this case.)
+ 			 */
+ 			if (fsstate->set_processed)
+ 			{
+ 				EState	   *estate = node->ss.ps.state;
+ 
+ 				estate->es_processed += fsstate->num_tuples;
+ 			}
+ 
+ 			/*
+ 			 * Increment the tuple count for EXPLAIN ANALYZE if necessary.
+ 			 * (Note: EXPLAIN ANALYZE cannot do that by itself in this case.)
+ 			 */
+ 			if (node->ss.ps.instrument)
+ 			{
+ 				Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 				instr->ntuples += fsstate->num_tuples;
+ 			}
+ 
+ 			return ExecClearTuple(slot);
+ 		}
+ 
+ 		/* If we didn't get any tuples, must be end of data. */
+ 		if (fsstate->next_tuple >= fsstate->num_tuples)
+ 			return ExecClearTuple(slot);
+ 
+ 		/* OK, we'll store RETURNING tuples in the batch_cxt. */
+ 		oldcontext = MemoryContextSwitchTo(fsstate->batch_cxt);
+ 
+ 		/* Fetch the next tuple. */
+ 		store_returning_result(slot,
+ 							   fsstate->result,
+ 							   fsstate->next_tuple,
+ 							   fsstate->rel,
+ 							   fsstate->attinmeta,
+ 							   fsstate->retrieved_attrs,
+ 							   fsstate->temp_cxt);
+ 		fsstate->rslot = slot;
+ 		fsstate->next_tuple++;
+ 
+ 		MemoryContextSwitchTo(oldcontext);
+ 
+ 		/*
+ 		 * Return slot.  Note that this is safe because we can avoid applying
+ 		 * ExecQual to the tuple due to no local quals (see the comment for
+ 		 * update_is_pushdown_safe) and because the tuple can be safely
+ 		 * projected by ExecProject (see push_update_down) and would then be
+ 		 * ignored by postgresExecForeignUpdate or postgresExecForeignDelete.
+ 		 */
+ 		return slot;
+ 	}
+ 
+ 	/*
  	 * If this is the first call after Begin or ReScan, we need to create the
  	 * cursor on the remote side.
  	 */
***************
*** 1036,1041 **** postgresReScanForeignScan(ForeignScanState *node)
--- 1202,1210 ----
  	char		sql[64];
  	PGresult   *res;
  
+ 	/* This shouldn't be called in update pushdown case. */
+ 	Assert(fsstate->update_pushdown == false);
+ 
  	/* If we haven't created the cursor yet, nothing to do. */
  	if (!fsstate->cursor_exists)
  		return;
***************
*** 1094,1099 **** postgresEndForeignScan(ForeignScanState *node)
--- 1263,1275 ----
  	if (fsstate == NULL)
  		return;
  
+ 	/* if pushing update down, nothing to do other than cleanup */
+ 	if (fsstate->update_pushdown)
+ 	{
+ 		if (fsstate->result)
+ 			PQclear(fsstate->result);
+ 	}
+ 
  	/* Close the cursor if open, to prevent accumulation of cursors */
  	if (fsstate->cursor_exists)
  		close_cursor(fsstate->conn, fsstate->cursor_number);
***************
*** 1145,1157 **** postgresAddForeignUpdateTargets(Query *parsetree,
  /*
   * postgresPlanForeignModify
   *		Plan an insert/update/delete operation on a foreign table
-  *
-  * Note: currently, the plan tree generated for UPDATE/DELETE will always
-  * include a ForeignScan that retrieves ctids (using SELECT FOR UPDATE)
-  * and then the ModifyTable node will have to execute individual remote
-  * UPDATE/DELETE commands.  If there are no local conditions or joins
-  * needed, it'd be better to let the scan node do UPDATE/DELETE RETURNING
-  * and then do nothing at ModifyTable.  Room for future optimization ...
   */
  static List *
  postgresPlanForeignModify(PlannerInfo *root,
--- 1321,1326 ----
***************
*** 1167,1174 **** postgresPlanForeignModify(PlannerInfo *root,
  	List	   *returningList = NIL;
  	List	   *retrieved_attrs = NIL;
  
- 	initStringInfo(&sql);
- 
  	/*
  	 * Core code already has some lock on each rel being planned, so we can
  	 * use NoLock here.
--- 1336,1341 ----
***************
*** 1210,1215 **** postgresPlanForeignModify(PlannerInfo *root,
--- 1377,1405 ----
  	}
  
  	/*
+ 	 * For UPDATE/DELETE, try to push the command down into the remote.
+ 	 */
+ 	if (operation == CMD_UPDATE || operation == CMD_DELETE)
+ 	{
+ 		/* Check to see whether it's safe to push the command down. */
+ 		if (update_is_pushdown_safe(root, plan,
+ 									resultRelation,
+ 									subplan_index,
+ 									rel, targetAttrs))
+ 		{
+ 			List	   *fdw_private;
+ 
+ 			/* OK, modify plan so as to push the command down. */
+ 			fdw_private = push_update_down(root, plan,
+ 										   resultRelation,
+ 										   subplan_index,
+ 										   rel, targetAttrs);
+ 			heap_close(rel, NoLock);
+ 			return fdw_private;
+ 		}
+ 	}
+ 
+ 	/*
  	 * Extract the relevant RETURNING list if any.
  	 */
  	if (plan->returningLists)
***************
*** 1218,1223 **** postgresPlanForeignModify(PlannerInfo *root,
--- 1408,1414 ----
  	/*
  	 * Construct the SQL command string.
  	 */
+ 	initStringInfo(&sql);
  	switch (operation)
  	{
  		case CMD_INSERT:
***************
*** 1288,1293 **** postgresBeginForeignModify(ModifyTableState *mtstate,
--- 1479,1520 ----
  	fmstate = (PgFdwModifyState *) palloc0(sizeof(PgFdwModifyState));
  	fmstate->rel = rel;
  
+ 	/* Deconstruct fdw_private data. */
+ 	fmstate->query = strVal(list_nth(fdw_private,
+ 									 FdwModifyPrivateUpdateSql));
+ 	fmstate->target_attrs = (List *) list_nth(fdw_private,
+ 											  FdwModifyPrivateTargetAttnums);
+ 	fmstate->has_returning = intVal(list_nth(fdw_private,
+ 											 FdwModifyPrivateHasReturning));
+ 	fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
+ 											 FdwModifyPrivateRetrievedAttrs);
+ 
+ 	/*
+ 	 * if query is NULL, we are in update pushdown case.
+ 	 */
+ 	if (fmstate->query == NULL)
+ 	{
+ 		PlanState	   *node = mtstate->mt_plans[subplan_index];
+ 		PgFdwScanState *fsstate;
+ 
+ 		Assert(fmstate->target_attrs == NIL);
+ 		Assert(fmstate->has_returning == false);
+ 		Assert(fmstate->retrieved_attrs == NIL);
+ 
+ 		Assert(nodeTag(node) == T_ForeignScanState);
+ 		fsstate = (PgFdwScanState *) ((ForeignScanState *) node)->fdw_state;
+ 		Assert(fsstate->update_pushdown);
+ 
+ 		fmstate->update_pushdown = true;
+ 		if (fsstate->has_returning)
+ 		{
+ 			fmstate->has_returning = true;
+ 			fmstate->fsstate = fsstate;
+ 		}
+ 		resultRelInfo->ri_FdwState = fmstate;
+ 		return;
+ 	}
+ 
  	/*
  	 * Identify which user to do the remote access as.  This should match what
  	 * ExecCheckRTEPerms() does.
***************
*** 1304,1319 **** postgresBeginForeignModify(ModifyTableState *mtstate,
  	fmstate->conn = GetConnection(server, user, true);
  	fmstate->p_name = NULL;		/* prepared statement not made yet */
  
- 	/* Deconstruct fdw_private data. */
- 	fmstate->query = strVal(list_nth(fdw_private,
- 									 FdwModifyPrivateUpdateSql));
- 	fmstate->target_attrs = (List *) list_nth(fdw_private,
- 											  FdwModifyPrivateTargetAttnums);
- 	fmstate->has_returning = intVal(list_nth(fdw_private,
- 											 FdwModifyPrivateHasReturning));
- 	fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
- 											 FdwModifyPrivateRetrievedAttrs);
- 
  	/* Create context for per-tuple temp workspace. */
  	fmstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											  "postgres_fdw temporary data",
--- 1531,1536 ----
***************
*** 1411,1417 **** postgresExecForeignInsert(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1628,1638 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1442,1447 **** postgresExecForeignUpdate(EState *estate,
--- 1663,1676 ----
  	PGresult   *res;
  	int			n_rows;
  
+ 	/* Just return the slot of the ForeignScan node, if pushing update down */
+ 	if (fmstate->update_pushdown)
+ 	{
+ 		Assert(fmstate->has_returning);
+ 		Assert(fmstate->fsstate->rslot);
+ 		return fmstate->fsstate->rslot;
+ 	}
+ 
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
  		prepare_foreign_modify(fmstate);
***************
*** 1481,1487 **** postgresExecForeignUpdate(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1710,1720 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1512,1517 **** postgresExecForeignDelete(EState *estate,
--- 1745,1758 ----
  	PGresult   *res;
  	int			n_rows;
  
+ 	/* Just return the slot of the ForeignScan node, if pushing update down */
+ 	if (fmstate->update_pushdown)
+ 	{
+ 		Assert(fmstate->has_returning);
+ 		Assert(fmstate->fsstate->rslot);
+ 		return fmstate->fsstate->rslot;
+ 	}
+ 
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
  		prepare_foreign_modify(fmstate);
***************
*** 1551,1557 **** postgresExecForeignDelete(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1792,1802 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1579,1584 **** postgresEndForeignModify(EState *estate,
--- 1824,1833 ----
  	if (fmstate == NULL)
  		return;
  
+ 	/* If pushing update down, nothing to do */
+ 	if (fmstate->update_pushdown)
+ 		return;
+ 
  	/* If we created a prepared statement, destroy it */
  	if (fmstate->p_name)
  	{
***************
*** 1657,1667 **** postgresExplainForeignScan(ForeignScanState *node, ExplainState *es)
  {
  	List	   *fdw_private;
  	char	   *sql;
  
  	if (es->verbose)
  	{
  		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
! 		sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
  		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
--- 1906,1922 ----
  {
  	List	   *fdw_private;
  	char	   *sql;
+ 	bool		update_pushdown;
  
  	if (es->verbose)
  	{
  		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
! 		update_pushdown = intVal(list_nth(fdw_private,
! 										  FdwScanPrivateUpdatePushdown));
! 		if (update_pushdown)
! 			sql = strVal(list_nth(fdw_private, FdwScanPrivateUpdateSql));
! 		else
! 			sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
  		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
***************
*** 1682,1688 **** postgresExplainForeignModify(ModifyTableState *mtstate,
  		char	   *sql = strVal(list_nth(fdw_private,
  										  FdwModifyPrivateUpdateSql));
  
! 		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
  
--- 1937,1944 ----
  		char	   *sql = strVal(list_nth(fdw_private,
  										  FdwModifyPrivateUpdateSql));
  
! 		if (sql != NULL)
! 			ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
  
***************
*** 1911,1916 **** ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
--- 2167,2402 ----
  }
  
  /*
+  * Check to see whether it's safe to push an UPDATE/DELETE command down.
+  *
+  * Conditions checked here:
+  *
+  * 1. If the target relation has any row-level local BEFORE/AFTER triggers, we
+  * must not push the command down, since that breaks execution of the triggers.
+  *
+  * 2. If there are any local joins needed, we mustn't push the command down,
+  * because that breaks execution of the joins.
+  *
+  * 3. If there are any quals that can't be evaluated remotely, we mustn't push
+  * the command down, because that breaks evaluation of the quals.
+  *
+  * 4. In UPDATE, if it is unsafe to evaluate any expressions to assign to the
+  * target columns on the remote server, we must not push the command down.
+  */
+ static bool
+ update_is_pushdown_safe(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index,
+ 						Relation rel,
+ 						List *targetAttrs)
+ {
+ 	CmdType		operation = plan->operation;
+ 	RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ListCell   *lc;
+ 
+ 	/* Check point 1 */
+ 	if (rel->trigdesc &&
+ 		((operation == CMD_UPDATE &&
+ 		  (rel->trigdesc->trig_update_after_row ||
+ 		   rel->trigdesc->trig_update_before_row)) ||
+ 		 (operation == CMD_DELETE &&
+ 		  (rel->trigdesc->trig_delete_after_row ||
+ 		   rel->trigdesc->trig_delete_before_row))))
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(subplan->targetlist,
+ 											attnum);
+ 
+ 		if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 			return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ /*
+  * Modify a plan so as to push an UPDATE/DELETE command down.
+  */
+ static List *
+ push_update_down(PlannerInfo *root,
+ 				 ModifyTable *plan,
+ 				 Index resultRelation,
+ 				 int subplan_index,
+ 				 Relation rel,
+ 				 List *targetAttrs)
+ {
+ 	CmdType		operation = plan->operation;
+ 	bool		canSetTag = plan->canSetTag;
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ForeignScan *fscan = (ForeignScan *) subplan;
+ 	StringInfoData sql;
+ 	List	   *remote_conds;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 	List	   *fdw_private;
+ 	Value	   *v;
+ 
+ 	Assert(operation == CMD_UPDATE || operation == CMD_DELETE);
+ 
+ 	initStringInfo(&sql);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		List	   *targetlist = subplan->targetlist;
+ 
+ 		deparseDirectUpdateSql(&sql, root, resultRelation, rel,
+ 							   remote_conds,
+ 							   targetlist,
+ 							   targetAttrs,
+ 							   returningList,
+ 							   &retrieved_attrs);
+ 
+ 		/*
+ 		 * Rrewrite targetlist for safety of ExecProject.
+ 		 */
+ 		subplan->targetlist = rewrite_targetlist(resultRelation,
+ 												 rel,
+ 												 targetlist,
+ 												 targetAttrs);
+ 	}
+ 	else
+ 	{
+ 		Assert(operation == CMD_DELETE);
+ 
+ 		deparseDirectDeleteSql(&sql, root, resultRelation, rel,
+ 							   remote_conds,
+ 							   returningList,
+ 							   &retrieved_attrs);
+ 	}
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwScanPrivateIndex, above.
+ 	 */
+ 	fscan->fdw_private = lappend(fscan->fdw_private, makeString(sql.data));
+ 	fscan->fdw_private = lappend(fscan->fdw_private, makeInteger(canSetTag));
+ 	fscan->fdw_private = lappend(fscan->fdw_private,
+ 								 makeInteger((retrieved_attrs != NIL)));
+ 	fscan->fdw_private = lappend(fscan->fdw_private, retrieved_attrs);
+ 
+ 	/*
+ 	 * Also set the UPDATE/DELETE-pushdown flag in the fdw_private list.
+ 	 */
+ 	v = (Value *) list_nth(fscan->fdw_private, FdwScanPrivateUpdatePushdown);
+ 	v->val.ival = true;
+ 
+ 	/*
+ 	 * Build the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwModifyPrivateIndex, above.
+ 	 */
+ 	fdw_private = list_make4(makeString(NULL), NIL, makeInteger(false), NIL);
+ 
+ 	return fdw_private;
+ }
+ 
+ /*
+  * Rrewrite the targetlist of an UPDATE.
+  *
+  * This is called for safety of ExecProject if pushing the command down.
+  */
+ static List *
+ rewrite_targetlist(Index resultRelation, Relation rel,
+ 				   List *targetlist, List *targetAttrs)
+ {
+ 	List	   *new_tlist = NIL;
+ 	int			numattrs = RelationGetNumberOfAttributes(rel);
+ 	int			attrno = 1;
+ 	ListCell   *lc;
+ 
+ 	foreach(lc, targetlist)
+ 	{
+ 		TargetEntry *tle = (TargetEntry *) lfirst(lc);
+ 
+ 		if (tle->resjunk)
+ 		{
+ 			new_tlist = lappend(new_tlist, tle);
+ 			continue;
+ 		}
+ 
+ 		if (attrno > numattrs)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 					 errmsg("table row type and query-specified row type do not match"),
+ 					 errdetail("Query has too many columns.")));
+ 
+ 		if (!list_member_int(targetAttrs, attrno))
+ 			new_tlist = lappend(new_tlist, tle);
+ 		else
+ 		{
+ 			Form_pg_attribute attr = rel->rd_att->attrs[attrno - 1];
+ 			Oid			atttype;
+ 			int32		atttypmod;
+ 			Oid			attcollation;
+ 			Node	   *new_expr;
+ 			TargetEntry *new_tle;
+ 
+ 			Assert(!attr->attisdropped);
+ 			atttype = attr->atttypid;
+ 			atttypmod = attr->atttypmod;
+ 			attcollation = attr->attcollation;
+ 
+ 			new_expr = (Node *) makeVar(resultRelation,
+ 										attrno,
+ 										atttype,
+ 										atttypmod,
+ 										attcollation,
+ 										0);
+ 
+ 			new_tle = makeTargetEntry((Expr *) new_expr,
+ 									  attrno,
+ 									  pstrdup(NameStr(attr->attname)),
+ 									  false);
+ 
+ 			new_tlist = lappend(new_tlist, new_tle);
+ 		}
+ 
+ 		attrno++;
+ 	}
+ 
+ 	if (attrno != numattrs + 1)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 				 errmsg("table row type and query-specified row type do not match"),
+ 				 errdetail("Query has too few columns.")));
+ 
+ 	return new_tlist;
+ }
+ 
+ /*
   * Create cursor for node's query with current parameter values.
   */
  static void
***************
*** 2258,2275 **** convert_prep_stmt_params(PgFdwModifyState *fmstate,
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, 0,
! 											fmstate->rel,
! 											fmstate->attinmeta,
! 											fmstate->retrieved_attrs,
! 											fmstate->temp_cxt);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
--- 2744,2766 ----
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, row,
! 											rel,
! 											attinmeta,
! 											retrieved_attrs,
! 											temp_context);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 66,75 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 66,87 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,
+ 								   Index rtindex, Relation rel,
+ 								   List	*remote_conds,
+ 								   List	*targetlist,
+ 								   List *targetAttrs,
+ 								   List *returningList,
+ 								   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root,
+ 								   Index rtindex, Relation rel,
+ 								   List	*remote_conds,
+ 								   List *returningList,
+ 								   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 320,339 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
--- 320,346 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;    -- can't be pushed down
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
***************
*** 616,621 **** UPDATE rem1 SET f2 = 'testo';
--- 623,712 ----
  -- Test returning a system attribute
  INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ 
+ 
+ -- Test update-pushdown functionality
+ 
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_before ON rem1;
+ 
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_after ON rem1;
+ 
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ 
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_update ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_update ON rem1;
+ 
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_after_delete ON rem1;
+ 
  -- ===================================================================
  -- test IMPORT FOREIGN SCHEMA
  -- ===================================================================
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 414,419 ****
--- 414,428 ----
     <literal>WHERE</> clauses are not sent to the remote server unless they use
     only built-in data types, operators, and functions.  Operators and
     functions in the clauses must be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, or no row-level local <literal>BEFORE</> or
+    <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, and <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 189,198 **** is_foreign_expr(PlannerInfo *root,
  	if (!foreign_expr_walker((Node *) expr, &glob_cxt, &loc_cxt))
  		return false;
  
- 	/* Expressions examined here should be boolean, ie noncollatable */
- 	Assert(loc_cxt.collation == InvalidOid);
- 	Assert(loc_cxt.state == FDW_COLLATE_NONE);
- 
  	/*
  	 * An expression which includes any mutable functions can't be sent over
  	 * because its result is not stable.  For example, sending now() remote
--- 189,194 ----
***************
*** 788,794 **** deparseTargetList(StringInfo buf,
   *
   * If params is not NULL, it receives a list of Params and other-relation Vars
   * used in the clauses; these values must be transmitted to the remote server
!  * as parameter values.
   *
   * If params is NULL, we're generating the query for EXPLAIN purposes,
   * so Params and other-relation Vars should be replaced by dummy values.
--- 784,791 ----
   *
   * If params is not NULL, it receives a list of Params and other-relation Vars
   * used in the clauses; these values must be transmitted to the remote server
!  * as parameter values.  Caller is responsible for initializing the result list
!  * to empty if necessary.
   *
   * If params is NULL, we're generating the query for EXPLAIN purposes,
   * so Params and other-relation Vars should be replaced by dummy values.
***************
*** 805,813 **** appendWhereClause(StringInfo buf,
  	int			nestlevel;
  	ListCell   *lc;
  
- 	if (params)
- 		*params = NIL;			/* initialize result list to empty */
- 
  	/* Set up context struct for recursion */
  	context.root = root;
  	context.foreignrel = baserel;
--- 802,807 ----
***************
*** 940,945 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 934,996 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*targetlist,
+ 						   List *targetAttrs,
+ 						   List	*remote_conds,
+ 						   List **params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	deparse_expr_cxt context;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	if (params_list)
+ 		*params_list = NIL;		/* initialize result list to empty */
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = params_list;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfo(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 962,967 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 1013,1048 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*remote_conds,
+ 						   List	**params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 
+ 	if (params_list)
+ 		*params_list = NIL;		/* initialize result list to empty */
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 1099,1105 **** INSERT INTO ft2 (c1,c2,c3)
--- 1099,1124 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (3 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1209,1215 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1228,1234 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1230,1245 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1249,1262 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1350,1356 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1367,1373 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2193,2198 **** SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
--- 2210,2228 ----
   1104 | 204 | ddd                | 
  (819 rows)
  
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;    -- can't be pushed down
+                                                       QUERY PLAN                                                       
+ -----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Remote SQL: UPDATE "S 1"."T 1" SET c7 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, 'ft2       '::character(10), c8, ctid
+          Filter: (date(ft2.c4) = '01-01-1970'::date)
+          Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c8, ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 0)) FOR UPDATE
+ (6 rows)
+ 
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
***************
*** 2334,2340 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2364,2370 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2493,2499 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2523,2529 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2633,2639 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
--- 2663,2669 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
***************
*** 3026,3031 **** NOTICE:  NEW: (13,"test triggered !")
--- 3056,3254 ----
   (0,27)
  (1 row)
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ -- Test update-pushdown functionality
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_before ON rem1;
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_after ON rem1;
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_update ON rem1;
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                   QUERY PLAN                                   
+ -------------------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_update ON rem1;
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                                QUERY PLAN                               
+ ------------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_after_delete ON rem1;
  -- ===================================================================
  -- test IMPORT FOREIGN SCHEMA
  -- ===================================================================
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 87,93 **** typedef struct PgFdwRelationInfo
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
--- 87,99 ----
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) List of restriction clauses that can be executed remotely
!  * 3) Integer list of attribute numbers retrieved by the SELECT
!  * 4) Boolean flag showing if an UPDATE/DELETE is pushed down
!  * 5) UPDATE/DELETE statement text to be sent to the remote server
!  * 6) Boolean flag showing if we set the command es_processed
!  * 7) Boolean flag showing if the remote query has a RETURNING clause
!  * 8) Integer list of attribute numbers retrieved by RETURNING, if any
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
***************
*** 97,104 **** enum FdwScanPrivateIndex
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
! 	/* Integer list of attribute numbers retrieved by the SELECT */
! 	FdwScanPrivateRetrievedAttrs
  };
  
  /*
--- 103,122 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
! 	/* List of restriction clauses that can be executed remotely */
! 	FdwScanPrivateRemoteConds,
! 	/* Integer list of attribute numbers retrieved by SELECT */
! 	FdwScanPrivateRetrievedAttrsBySelect,
! 	/* UPDATE/DELETE-pushdown flag (as an integer Value node) */
! 	FdwScanPrivateUpdatePushedDown,
! 	/* UPDATE/DELETE statement to execute remotely (as a String node) */
! 	FdwScanPrivateUpdateSql,
! 	/* set-processed flag (as an integer Value node) */
! 	FdwScanPrivateSetProcessed,
! 	/* has-returning flag (as an integer Value node) */
! 	FdwScanPrivateHasReturning,
! 	/* Integer list of attribute numbers retrieved by RETURNING */
! 	FdwScanPrivateRetrievedAttrsByReturning
  };
  
  /*
***************
*** 132,139 **** typedef struct PgFdwScanState
  	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
  
  	/* extracted fdw_private data */
! 	char	   *query;			/* text of SELECT command */
  	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
  
  	/* for remote query execution */
  	PGconn	   *conn;			/* connection for the scan */
--- 150,159 ----
  	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
  
  	/* extracted fdw_private data */
! 	char	   *query;			/* text of SELECT or UPDATE/DELETE command */
  	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
  
  	/* for remote query execution */
  	PGconn	   *conn;			/* connection for the scan */
***************
*** 153,158 **** typedef struct PgFdwScanState
--- 173,183 ----
  	int			fetch_ct_2;		/* Min(# of fetches done, 2) */
  	bool		eof_reached;	/* true if last fetch reached EOF */
  
+ 	/* for update pushdown */
+ 	bool		update_pushed_down;	/* is an UPDATE/DELETE pushed down? */
+ 	PGresult   *result;			/* result of an UPDATE/DELETE query */
+ 	TupleTableSlot *rslot;		/* slot containing the result tuple */
+ 
  	/* working memory contexts */
  	MemoryContext batch_cxt;	/* context holding current batch of tuples */
  	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
***************
*** 181,186 **** typedef struct PgFdwModifyState
--- 206,215 ----
  	int			p_nums;			/* number of parameters to transmit */
  	FmgrInfo   *p_flinfo;		/* output conversion functions for them */
  
+ 	/* for update pushdown */
+ 	bool		update_pushed_down;	/* is an UPDATE/DELETE pushed down? */
+ 	PgFdwScanState *fsstate;	/* execution state of a foreign scan */
+ 
  	/* working memory context */
  	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
  } PgFdwModifyState;
***************
*** 309,320 **** static bool ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
  static void create_cursor(ForeignScanState *node);
  static void fetch_more_data(ForeignScanState *node);
  static void close_cursor(PGconn *conn, unsigned int cursor_number);
  static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
--- 338,370 ----
  static void create_cursor(ForeignScanState *node);
  static void fetch_more_data(ForeignScanState *node);
  static void close_cursor(PGconn *conn, unsigned int cursor_number);
+ static void execute_pushed_down_command(ForeignScanState *node);
+ static TupleTableSlot *get_next_returning_result(ForeignScanState *node);
+ static bool update_is_pushdown_safe(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index,
+ 									Relation rel,
+ 									List *targetAttrs);
+ static List *push_update_down(PlannerInfo *root,
+ 							  ModifyTable *plan,
+ 							  Index resultRelation,
+ 							  int subplan_index,
+ 							  Relation rel,
+ 							  List *targetAttrs);
+ static List *rewrite_targetlist(Index resultRelation, Relation rel,
+ 								List *targetlist, List *targetAttrs);
  static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 853,860 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make2(makeString(sql.data),
! 							 retrieved_attrs);
  
  	/*
  	 * Create the ForeignScan node from target list, local filtering
--- 903,912 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make4(makeString(sql.data),
! 							 remote_conds,
! 							 retrieved_attrs,
! 							 makeInteger(false));
  
  	/*
  	 * Create the ForeignScan node from target list, local filtering
***************
*** 903,908 **** postgresBeginForeignScan(ForeignScanState *node, int eflags)
--- 955,966 ----
  	node->fdw_state = (void *) fsstate;
  
  	/*
+ 	 * Decide whether we push an UPDATE/DELETE command down.
+ 	 */
+ 	fsstate->update_pushed_down = intVal(list_nth(fsplan->fdw_private,
+ 												  FdwScanPrivateUpdatePushedDown));
+ 
+ 	/*
  	 * Identify which user to do the remote access as.  This should match what
  	 * ExecCheckRTEPerms() does.
  	 */
***************
*** 921,935 **** postgresBeginForeignScan(ForeignScanState *node, int eflags)
  	 */
  	fsstate->conn = GetConnection(server, user, false);
  
! 	/* Assign a unique ID for my cursor */
! 	fsstate->cursor_number = GetCursorNumber(fsstate->conn);
! 	fsstate->cursor_exists = false;
  
! 	/* Get private info created by planner functions. */
! 	fsstate->query = strVal(list_nth(fsplan->fdw_private,
! 									 FdwScanPrivateSelectSql));
! 	fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
! 											   FdwScanPrivateRetrievedAttrs);
  
  	/* Create contexts for batches of tuples and per-tuple temp workspace. */
  	fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
--- 979,1011 ----
  	 */
  	fsstate->conn = GetConnection(server, user, false);
  
! 	if (fsstate->update_pushed_down)
! 	{
! 		/* Initialize state variable */
! 		fsstate->num_tuples = -1;		/* -1 means not set yet */
  
! 		/* Get private info created by planner functions. */
! 		fsstate->query = strVal(list_nth(fsplan->fdw_private,
! 										 FdwScanPrivateUpdateSql));
! 		fsstate->set_processed = intVal(list_nth(fsplan->fdw_private,
! 												 FdwScanPrivateSetProcessed));
! 		fsstate->has_returning = intVal(list_nth(fsplan->fdw_private,
! 												 FdwScanPrivateHasReturning));
! 		fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
! 									  FdwScanPrivateRetrievedAttrsByReturning);
! 	}
! 	else
! 	{
! 		/* Assign a unique ID for my cursor */
! 		fsstate->cursor_number = GetCursorNumber(fsstate->conn);
! 		fsstate->cursor_exists = false;
! 
! 		/* Get private info created by planner functions. */
! 		fsstate->query = strVal(list_nth(fsplan->fdw_private,
! 										 FdwScanPrivateSelectSql));
! 		fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
! 										 FdwScanPrivateRetrievedAttrsBySelect);
! 	}
  
  	/* Create contexts for batches of tuples and per-tuple temp workspace. */
  	fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
***************
*** 996,1001 **** postgresIterateForeignScan(ForeignScanState *node)
--- 1072,1094 ----
  	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
  
  	/*
+ 	 * Get the result of an UPDATE/DELETE RETURNING, if pushing the command down.
+ 	 */
+ 	if (fsstate->update_pushed_down)
+ 	{
+ 		/*
+ 		 * If this is the first call after Begin, execute the command.
+ 		 */
+ 		if (fsstate->num_tuples == -1)
+ 			execute_pushed_down_command(node);
+ 
+ 		/*
+ 		 * Get the next returning result.
+ 		 */
+ 		return get_next_returning_result(node);
+ 	}
+ 
+ 	/*
  	 * If this is the first call after Begin or ReScan, we need to create the
  	 * cursor on the remote side.
  	 */
***************
*** 1037,1042 **** postgresReScanForeignScan(ForeignScanState *node)
--- 1130,1138 ----
  	char		sql[64];
  	PGresult   *res;
  
+ 	/* This shouldn't be called in update pushdown case. */
+ 	Assert(fsstate->update_pushed_down == false);
+ 
  	/* If we haven't created the cursor yet, nothing to do. */
  	if (!fsstate->cursor_exists)
  		return;
***************
*** 1095,1103 **** postgresEndForeignScan(ForeignScanState *node)
  	if (fsstate == NULL)
  		return;
  
! 	/* Close the cursor if open, to prevent accumulation of cursors */
! 	if (fsstate->cursor_exists)
! 		close_cursor(fsstate->conn, fsstate->cursor_number);
  
  	/* Release remote connection */
  	ReleaseConnection(fsstate->conn);
--- 1191,1208 ----
  	if (fsstate == NULL)
  		return;
  
! 	if (fsstate->update_pushed_down)
! 	{
! 		/* Clean up */
! 		if (fsstate->result)
! 			PQclear(fsstate->result);
! 	}
! 	else
! 	{
! 		/* Close the cursor if open, to prevent accumulation of cursors */
! 		if (fsstate->cursor_exists)
! 			close_cursor(fsstate->conn, fsstate->cursor_number);
! 	}
  
  	/* Release remote connection */
  	ReleaseConnection(fsstate->conn);
***************
*** 1146,1158 **** postgresAddForeignUpdateTargets(Query *parsetree,
  /*
   * postgresPlanForeignModify
   *		Plan an insert/update/delete operation on a foreign table
-  *
-  * Note: currently, the plan tree generated for UPDATE/DELETE will always
-  * include a ForeignScan that retrieves ctids (using SELECT FOR UPDATE)
-  * and then the ModifyTable node will have to execute individual remote
-  * UPDATE/DELETE commands.  If there are no local conditions or joins
-  * needed, it'd be better to let the scan node do UPDATE/DELETE RETURNING
-  * and then do nothing at ModifyTable.  Room for future optimization ...
   */
  static List *
  postgresPlanForeignModify(PlannerInfo *root,
--- 1251,1256 ----
***************
*** 1168,1175 **** postgresPlanForeignModify(PlannerInfo *root,
  	List	   *returningList = NIL;
  	List	   *retrieved_attrs = NIL;
  
- 	initStringInfo(&sql);
- 
  	/*
  	 * Core code already has some lock on each rel being planned, so we can
  	 * use NoLock here.
--- 1266,1271 ----
***************
*** 1213,1218 **** postgresPlanForeignModify(PlannerInfo *root,
--- 1309,1337 ----
  	}
  
  	/*
+ 	 * For UPDATE/DELETE, try to push the command down into the remote.
+ 	 */
+ 	if (operation == CMD_UPDATE || operation == CMD_DELETE)
+ 	{
+ 		/* Check to see whether it's safe to push the command down. */
+ 		if (update_is_pushdown_safe(root, plan,
+ 									resultRelation,
+ 									subplan_index,
+ 									rel, targetAttrs))
+ 		{
+ 			List	   *fdw_private;
+ 
+ 			/* OK, modify plan so as to push the command down. */
+ 			fdw_private = push_update_down(root, plan,
+ 										   resultRelation,
+ 										   subplan_index,
+ 										   rel, targetAttrs);
+ 			heap_close(rel, NoLock);
+ 			return fdw_private;
+ 		}
+ 	}
+ 
+ 	/*
  	 * Extract the relevant RETURNING list if any.
  	 */
  	if (plan->returningLists)
***************
*** 1221,1226 **** postgresPlanForeignModify(PlannerInfo *root,
--- 1340,1346 ----
  	/*
  	 * Construct the SQL command string.
  	 */
+ 	initStringInfo(&sql);
  	switch (operation)
  	{
  		case CMD_INSERT:
***************
*** 1291,1296 **** postgresBeginForeignModify(ModifyTableState *mtstate,
--- 1411,1452 ----
  	fmstate = (PgFdwModifyState *) palloc0(sizeof(PgFdwModifyState));
  	fmstate->rel = rel;
  
+ 	/* Deconstruct fdw_private data. */
+ 	fmstate->query = strVal(list_nth(fdw_private,
+ 									 FdwModifyPrivateUpdateSql));
+ 	fmstate->target_attrs = (List *) list_nth(fdw_private,
+ 											  FdwModifyPrivateTargetAttnums);
+ 	fmstate->has_returning = intVal(list_nth(fdw_private,
+ 											 FdwModifyPrivateHasReturning));
+ 	fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
+ 											 FdwModifyPrivateRetrievedAttrs);
+ 
+ 	/*
+ 	 * if query is NULL, we are in update pushdown case.
+ 	 */
+ 	if (fmstate->query == NULL)
+ 	{
+ 		PlanState	   *node = mtstate->mt_plans[subplan_index];
+ 		PgFdwScanState *fsstate;
+ 
+ 		Assert(fmstate->target_attrs == NIL);
+ 		Assert(fmstate->has_returning == false);
+ 		Assert(fmstate->retrieved_attrs == NIL);
+ 
+ 		Assert(nodeTag(node) == T_ForeignScanState);
+ 		fsstate = (PgFdwScanState *) ((ForeignScanState *) node)->fdw_state;
+ 		Assert(fsstate->update_pushed_down);
+ 
+ 		fmstate->update_pushed_down = true;
+ 		if (fsstate->has_returning)
+ 		{
+ 			fmstate->has_returning = true;
+ 			fmstate->fsstate = fsstate;
+ 		}
+ 		resultRelInfo->ri_FdwState = fmstate;
+ 		return;
+ 	}
+ 
  	/*
  	 * Identify which user to do the remote access as.  This should match what
  	 * ExecCheckRTEPerms() does.
***************
*** 1307,1322 **** postgresBeginForeignModify(ModifyTableState *mtstate,
  	fmstate->conn = GetConnection(server, user, true);
  	fmstate->p_name = NULL;		/* prepared statement not made yet */
  
- 	/* Deconstruct fdw_private data. */
- 	fmstate->query = strVal(list_nth(fdw_private,
- 									 FdwModifyPrivateUpdateSql));
- 	fmstate->target_attrs = (List *) list_nth(fdw_private,
- 											  FdwModifyPrivateTargetAttnums);
- 	fmstate->has_returning = intVal(list_nth(fdw_private,
- 											 FdwModifyPrivateHasReturning));
- 	fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
- 											 FdwModifyPrivateRetrievedAttrs);
- 
  	/* Create context for per-tuple temp workspace. */
  	fmstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
  											  "postgres_fdw temporary data",
--- 1463,1468 ----
***************
*** 1414,1420 **** postgresExecForeignInsert(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1560,1570 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1445,1450 **** postgresExecForeignUpdate(EState *estate,
--- 1595,1608 ----
  	PGresult   *res;
  	int			n_rows;
  
+ 	/* Just return the slot of the ForeignScan node, if pushing update down */
+ 	if (fmstate->update_pushed_down)
+ 	{
+ 		Assert(fmstate->has_returning);
+ 		Assert(fmstate->fsstate->rslot);
+ 		return fmstate->fsstate->rslot;
+ 	}
+ 
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
  		prepare_foreign_modify(fmstate);
***************
*** 1484,1490 **** postgresExecForeignUpdate(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1642,1652 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1515,1520 **** postgresExecForeignDelete(EState *estate,
--- 1677,1690 ----
  	PGresult   *res;
  	int			n_rows;
  
+ 	/* Just return the slot of the ForeignScan node, if pushing update down */
+ 	if (fmstate->update_pushed_down)
+ 	{
+ 		Assert(fmstate->has_returning);
+ 		Assert(fmstate->fsstate->rslot);
+ 		return fmstate->fsstate->rslot;
+ 	}
+ 
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
  		prepare_foreign_modify(fmstate);
***************
*** 1554,1560 **** postgresExecForeignDelete(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1724,1734 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1582,1587 **** postgresEndForeignModify(EState *estate,
--- 1756,1765 ----
  	if (fmstate == NULL)
  		return;
  
+ 	/* If pushing update down, nothing to do */
+ 	if (fmstate->update_pushed_down)
+ 		return;
+ 
  	/* If we created a prepared statement, destroy it */
  	if (fmstate->p_name)
  	{
***************
*** 1660,1670 **** postgresExplainForeignScan(ForeignScanState *node, ExplainState *es)
  {
  	List	   *fdw_private;
  	char	   *sql;
  
  	if (es->verbose)
  	{
  		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
! 		sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
  		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
--- 1838,1854 ----
  {
  	List	   *fdw_private;
  	char	   *sql;
+ 	bool		update_pushed_down;
  
  	if (es->verbose)
  	{
  		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
! 		update_pushed_down = intVal(list_nth(fdw_private,
! 											 FdwScanPrivateUpdatePushedDown));
! 		if (update_pushed_down)
! 			sql = strVal(list_nth(fdw_private, FdwScanPrivateUpdateSql));
! 		else
! 			sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
  		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
***************
*** 1685,1691 **** postgresExplainForeignModify(ModifyTableState *mtstate,
  		char	   *sql = strVal(list_nth(fdw_private,
  										  FdwModifyPrivateUpdateSql));
  
! 		ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
  
--- 1869,1876 ----
  		char	   *sql = strVal(list_nth(fdw_private,
  										  FdwModifyPrivateUpdateSql));
  
! 		if (sql != NULL)
! 			ExplainPropertyText("Remote SQL", sql, es);
  	}
  }
  
***************
*** 1914,1919 **** ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel,
--- 2099,2344 ----
  }
  
  /*
+  * Check to see whether it's safe to push an UPDATE/DELETE command down.
+  *
+  * Conditions checked here:
+  *
+  * 1. If the target relation has any row-level local BEFORE/AFTER triggers, we
+  * must not push the command down, since that breaks execution of the triggers.
+  *
+  * 2. If there are any local joins needed, we mustn't push the command down,
+  * because that breaks execution of the joins.
+  *
+  * 3. If there are any quals that can't be evaluated remotely, we mustn't push
+  * the command down, because that breaks evaluation of the quals.
+  *
+  * 4. In UPDATE, if it is unsafe to evaluate any expressions to assign to the
+  * target columns on the remote server, we must not push the command down.
+  */
+ static bool
+ update_is_pushdown_safe(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index,
+ 						Relation rel,
+ 						List *targetAttrs)
+ {
+ 	CmdType		operation = plan->operation;
+ 	RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ListCell   *lc;
+ 
+ 	/* Check point 1 */
+ 	if (rel->trigdesc &&
+ 		((operation == CMD_UPDATE &&
+ 		  (rel->trigdesc->trig_update_after_row ||
+ 		   rel->trigdesc->trig_update_before_row)) ||
+ 		 (operation == CMD_DELETE &&
+ 		  (rel->trigdesc->trig_delete_after_row ||
+ 		   rel->trigdesc->trig_delete_before_row))))
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(subplan->targetlist,
+ 											attnum);
+ 
+ 		if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 			return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ /*
+  * Modify a plan so as to push an UPDATE/DELETE command down.
+  */
+ static List *
+ push_update_down(PlannerInfo *root,
+ 				 ModifyTable *plan,
+ 				 Index resultRelation,
+ 				 int subplan_index,
+ 				 Relation rel,
+ 				 List *targetAttrs)
+ {
+ 	CmdType		operation = plan->operation;
+ 	bool		canSetTag = plan->canSetTag;
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ForeignScan *fscan = (ForeignScan *) subplan;
+ 	StringInfoData sql;
+ 	List	   *remote_conds;
+ 	List	   *params_list = NIL;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 	List	   *fdw_private;
+ 	ListCell   *lc;
+ 
+ 	Assert(operation == CMD_UPDATE || operation == CMD_DELETE);
+ 
+ 	initStringInfo(&sql);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		List	   *targetlist = subplan->targetlist;
+ 
+ 		deparsePushedDownUpdateSql(&sql, root, resultRelation, rel,
+ 								   targetlist,
+ 								   targetAttrs,
+ 								   remote_conds,
+ 								   &params_list,
+ 								   returningList,
+ 								   &retrieved_attrs);
+ 
+ 		/*
+ 		 * Rrewrite targetlist for safety of ExecProject.
+ 		 */
+ 		subplan->targetlist = rewrite_targetlist(resultRelation,
+ 												 rel,
+ 												 targetlist,
+ 												 targetAttrs);
+ 	}
+ 	else
+ 	{
+ 		Assert(operation == CMD_DELETE);
+ 
+ 		deparsePushedDownDeleteSql(&sql, root, resultRelation, rel,
+ 								   remote_conds,
+ 								   &params_list,
+ 								   returningList,
+ 								   &retrieved_attrs);
+ 	}
+ 
+ 	/*
+ 	 * Update the operation info.
+ 	 */
+ 	fscan->operation = operation;
+ 
+ 	/*
+ 	 * Update the fdw_exprs list that will be available to the executor.
+ 	 */
+ 	fscan->fdw_exprs = params_list;
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwScanPrivateIndex, above.
+ 	 */
+ 	lc = list_nth_cell(fscan->fdw_private, FdwScanPrivateUpdatePushedDown);
+ 	lfirst(lc) = makeInteger(true);
+ 
+ 	fscan->fdw_private = lappend(fscan->fdw_private, makeString(sql.data));
+ 	fscan->fdw_private = lappend(fscan->fdw_private, makeInteger(canSetTag));
+ 	fscan->fdw_private = lappend(fscan->fdw_private,
+ 								 makeInteger((retrieved_attrs != NIL)));
+ 	fscan->fdw_private = lappend(fscan->fdw_private, retrieved_attrs);
+ 
+ 	/*
+ 	 * Build the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwModifyPrivateIndex, above.
+ 	 */
+ 	fdw_private = list_make4(makeString(NULL), NIL, makeInteger(false), NIL);
+ 
+ 	return fdw_private;
+ }
+ 
+ /*
+  * Rrewrite the targetlist of an UPDATE.
+  *
+  * This is called for safety of ExecProject if pushing the command down.
+  */
+ static List *
+ rewrite_targetlist(Index resultRelation, Relation rel,
+ 				   List *targetlist, List *targetAttrs)
+ {
+ 	List	   *new_tlist = NIL;
+ 	int			numattrs = RelationGetNumberOfAttributes(rel);
+ 	int			attrno = 1;
+ 	ListCell   *lc;
+ 
+ 	foreach(lc, targetlist)
+ 	{
+ 		TargetEntry *tle = (TargetEntry *) lfirst(lc);
+ 
+ 		if (tle->resjunk)
+ 		{
+ 			new_tlist = lappend(new_tlist, tle);
+ 			continue;
+ 		}
+ 
+ 		if (attrno > numattrs)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 					 errmsg("table row type and query-specified row type do not match"),
+ 					 errdetail("Query has too many columns.")));
+ 
+ 		if (!list_member_int(targetAttrs, attrno))
+ 			new_tlist = lappend(new_tlist, tle);
+ 		else
+ 		{
+ 			Form_pg_attribute attr = rel->rd_att->attrs[attrno - 1];
+ 			Oid			atttype;
+ 			int32		atttypmod;
+ 			Oid			attcollation;
+ 			Node	   *new_expr;
+ 			TargetEntry *new_tle;
+ 
+ 			Assert(!attr->attisdropped);
+ 			atttype = attr->atttypid;
+ 			atttypmod = attr->atttypmod;
+ 			attcollation = attr->attcollation;
+ 
+ 			new_expr = (Node *) makeVar(resultRelation,
+ 										attrno,
+ 										atttype,
+ 										atttypmod,
+ 										attcollation,
+ 										0);
+ 
+ 			new_tle = makeTargetEntry((Expr *) new_expr,
+ 									  attrno,
+ 									  pstrdup(NameStr(attr->attname)),
+ 									  false);
+ 
+ 			new_tlist = lappend(new_tlist, new_tle);
+ 		}
+ 
+ 		attrno++;
+ 	}
+ 
+ 	if (attrno != numattrs + 1)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_DATATYPE_MISMATCH),
+ 				 errmsg("table row type and query-specified row type do not match"),
+ 				 errdetail("Query has too few columns.")));
+ 
+ 	return new_tlist;
+ }
+ 
+ /*
   * Create cursor for node's query with current parameter values.
   */
  static void
***************
*** 2150,2155 **** close_cursor(PGconn *conn, unsigned int cursor_number)
--- 2575,2729 ----
  }
  
  /*
+  * Execute a pushed-down UPDATE/DELETE command.
+  */
+ static void
+ execute_pushed_down_command(ForeignScanState *node)
+ {
+ 	PgFdwScanState *fsstate = (PgFdwScanState *) node->fdw_state;
+ 	ExprContext *econtext = node->ss.ps.ps_ExprContext;
+ 	int			numParams = fsstate->numParams;
+ 	const char **values = fsstate->param_values;
+ 
+ 	/*
+ 	 * Construct array of query parameter values in text format.  We do the
+ 	 * conversions in the short-lived per-tuple context, so as not to cause a
+ 	 * memory leak over repeated scans.
+ 	 */
+ 	if (numParams > 0)
+ 	{
+ 		int			nestlevel;
+ 		MemoryContext oldcontext;
+ 		int			i;
+ 		ListCell   *lc;
+ 
+ 		oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
+ 
+ 		nestlevel = set_transmission_modes();
+ 
+ 		i = 0;
+ 		foreach(lc, fsstate->param_exprs)
+ 		{
+ 			ExprState  *expr_state = (ExprState *) lfirst(lc);
+ 			Datum		expr_value;
+ 			bool		isNull;
+ 
+ 			/* Evaluate the parameter expression */
+ 			expr_value = ExecEvalExpr(expr_state, econtext, &isNull, NULL);
+ 
+ 			/*
+ 			 * Get string representation of each parameter value by invoking
+ 			 * type-specific output function, unless the value is null.
+ 			 */
+ 			if (isNull)
+ 				values[i] = NULL;
+ 			else
+ 				values[i] = OutputFunctionCall(&fsstate->param_flinfo[i],
+ 											   expr_value);
+ 			i++;
+ 		}
+ 
+ 		reset_transmission_modes(nestlevel);
+ 
+ 		MemoryContextSwitchTo(oldcontext);
+ 	}
+ 
+ 	/*
+ 	 * Notice that we pass NULL for paramTypes, thus forcing the remote server
+ 	 * to infer types for all parameters.  Since we explicitly cast every
+ 	 * parameter (see deparse.c), the "inference" is trivial and will produce
+ 	 * the desired result.  This allows us to avoid assuming that the remote
+ 	 * server has the same OIDs we do for the parameters' types.
+ 	 *
+ 	 * We don't use a PG_TRY block here, so be careful not to throw error
+ 	 * without releasing the PGresult.
+ 	 */
+ 	fsstate->result = PQexecParams(fsstate->conn, fsstate->query,
+ 								   numParams, NULL, values, NULL, NULL, 0);
+ 	if (PQresultStatus(fsstate->result) !=
+ 		(fsstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 		pgfdw_report_error(ERROR, fsstate->result, fsstate->conn, true,
+ 						   fsstate->query);
+ 
+ 	/* Get the number of rows affected. */
+ 	if (fsstate->has_returning)
+ 		fsstate->num_tuples = PQntuples(fsstate->result);
+ 	else
+ 		fsstate->num_tuples = atoi(PQcmdTuples(fsstate->result));
+ }
+ 
+ /*
+  * Get the result of an UPDATE/DELETE RETURNING.
+  */
+ static TupleTableSlot *
+ get_next_returning_result(ForeignScanState *node)
+ {
+ 	PgFdwScanState *fsstate = (PgFdwScanState *) node->fdw_state;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 	MemoryContext oldcontext;
+ 
+ 	/*
+ 	 * If the update query doesn't have a RETURNING clause, then there is
+ 	 * nothing to do, so we just return an empty slot.
+ 	 */
+ 	if (!fsstate->has_returning)
+ 	{
+ 		/*
+ 		 * Increment the command es_processed count if necessary.
+ 		 * (Note: ModifyTable cannot do that by itself in this case.)
+ 		 */
+ 		if (fsstate->set_processed)
+ 		{
+ 			EState	   *estate = node->ss.ps.state;
+ 
+ 			estate->es_processed += fsstate->num_tuples;
+ 		}
+ 
+ 		/*
+ 		 * Increment the tuple count for EXPLAIN ANALYZE if necessary.
+ 		 * (Note: EXPLAIN ANALYZE cannot do that by itself in this case.)
+ 		 */
+ 		if (node->ss.ps.instrument)
+ 		{
+ 			Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 			instr->ntuples += fsstate->num_tuples;
+ 		}
+ 
+ 		return ExecClearTuple(slot);
+ 	}
+ 
+ 	/* If we didn't get any tuples, must be end of data. */
+ 	if (fsstate->next_tuple >= fsstate->num_tuples)
+ 		return ExecClearTuple(slot);
+ 
+ 	/* OK, we'll store RETURNING tuples in the batch_cxt. */
+ 	oldcontext = MemoryContextSwitchTo(fsstate->batch_cxt);
+ 
+ 	/* Fetch the next tuple. */
+ 	store_returning_result(slot,
+ 						   fsstate->result,
+ 						   fsstate->next_tuple,
+ 						   fsstate->rel,
+ 						   fsstate->attinmeta,
+ 						   fsstate->retrieved_attrs,
+ 						   fsstate->temp_cxt);
+ 	fsstate->rslot = slot;
+ 	fsstate->next_tuple++;
+ 
+ 	MemoryContextSwitchTo(oldcontext);
+ 
+ 	/*
+ 	 * Return slot.  Note that this is safe because we can avoid applying
+ 	 * ExecQual to the tuple due to no local quals (see the comment for
+ 	 * update_is_pushdown_safe) and because the tuple can be safely
+ 	 * projected by ExecProject (see push_update_down) and would then be
+ 	 * ignored by postgresExecForeignUpdate or postgresExecForeignDelete.
+ 	 */
+ 	return slot;
+ }
+ 
+ /*
   * prepare_foreign_modify
   *		Establish a prepared statement for execution of INSERT/UPDATE/DELETE
   */
***************
*** 2261,2278 **** convert_prep_stmt_params(PgFdwModifyState *fmstate,
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, 0,
! 											fmstate->rel,
! 											fmstate->attinmeta,
! 											fmstate->retrieved_attrs,
! 											fmstate->temp_cxt);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
--- 2835,2857 ----
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, row,
! 											rel,
! 											attinmeta,
! 											retrieved_attrs,
! 											temp_context);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 66,75 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 66,89 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*targetlist,
+ 									   List *targetAttrs,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 339,358 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
--- 339,365 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;    -- can't be pushed down
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
***************
*** 665,670 **** UPDATE rem1 SET f2 = 'testo';
--- 672,761 ----
  -- Test returning a system attribute
  INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ 
+ 
+ -- Test update-pushdown functionality
+ 
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_before ON rem1;
+ 
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_after ON rem1;
+ 
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ 
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_update ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_update ON rem1;
+ 
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_after_delete ON rem1;
+ 
  -- ===================================================================
  -- test IMPORT FOREIGN SCHEMA
  -- ===================================================================
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 414,419 ****
--- 414,428 ----
     <literal>WHERE</> clauses are not sent to the remote server unless they use
     only built-in data types, operators, and functions.  Operators and
     functions in the clauses must be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, or no row-level local <literal>BEFORE</> or
+    <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, and <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 947,953 **** ExplainNode(PlanState *planstate, List *ancestors,
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			pname = sname = "Foreign Scan";
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
--- 947,971 ----
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			sname = "Foreign Scan";
! 			switch (((ForeignScan *) plan)->operation)
! 			{
! 				case CMD_SELECT:
! 					pname = "Foreign Scan";
! 					operation = "Select";
! 					break;
! 				case CMD_UPDATE:
! 					pname = "Foreign Update";
! 					operation = "Update";
! 					break;
! 				case CMD_DELETE:
! 					pname = "Foreign Delete";
! 					operation = "Delete";
! 					break;
! 				default:
! 					pname = "???";
! 					break;
! 			}
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
***************
*** 1683,1688 **** show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
--- 1701,1711 ----
  		return;
  	if (IsA(plan, RecursiveUnion))
  		return;
+ 	/* Likewise for ForeignScan in case of pushed-down UPDATE/DELETE */
+ 	if (IsA(plan, ForeignScan) &&
+ 		(((ForeignScan *) plan)->operation == CMD_UPDATE ||
+ 		 ((ForeignScan *) plan)->operation == CMD_DELETE))
+ 		return;
  
  	/* Set up deparsing context */
  	context = set_deparse_context_planstate(es->deparse_cxt,
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 592,597 **** _copyForeignScan(const ForeignScan *from)
--- 592,598 ----
  	/*
  	 * copy remainder of node
  	 */
+ 	COPY_SCALAR_FIELD(operation);
  	COPY_NODE_FIELD(fdw_exprs);
  	COPY_NODE_FIELD(fdw_private);
  	COPY_SCALAR_FIELD(fsSystemCol);
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 558,563 **** _outForeignScan(StringInfo str, const ForeignScan *node)
--- 558,564 ----
  
  	_outScanInfo(str, (const Scan *) node);
  
+ 	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_NODE_FIELD(fdw_exprs);
  	WRITE_NODE_FIELD(fdw_private);
  	WRITE_BOOL_FIELD(fsSystemCol);
*** a/src/backend/optimizer/plan/createplan.c
--- b/src/backend/optimizer/plan/createplan.c
***************
*** 3569,3574 **** make_foreignscan(List *qptlist,
--- 3569,3575 ----
  	plan->lefttree = NULL;
  	plan->righttree = NULL;
  	node->scan.scanrelid = scanrelid;
+ 	node->operation = CMD_SELECT;
  	node->fdw_exprs = fdw_exprs;
  	node->fdw_private = fdw_private;
  	/* fsSystemCol will be filled in by create_foreignscan_plan */
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
***************
*** 480,485 **** typedef struct WorkTableScan
--- 480,486 ----
  typedef struct ForeignScan
  {
  	Scan		scan;
+ 	CmdType		operation;		/* SELECT, UPDATE, or DELETE */
  	List	   *fdw_exprs;		/* expressions that FDW may evaluate */
  	List	   *fdw_private;	/* private data for FDW */
  	bool		fsSystemCol;	/* true if any "system column" is needed */

*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 887,893 **** ExplainNode(PlanState *planstate, List *ancestors,
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			pname = sname = "Foreign Scan";
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
--- 887,911 ----
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			sname = "Foreign Scan";
! 			switch (((ForeignScan *) plan)->operation)
! 			{
! 				case CMD_SELECT:
! 					pname = "Foreign Scan";
! 					operation = "Select";
! 					break;
! 				case CMD_UPDATE:
! 					pname = "Foreign Update";
! 					operation = "Update";
! 					break;
! 				case CMD_DELETE:
! 					pname = "Foreign Delete";
! 					operation = "Delete";
! 					break;
! 				default:
! 					pname = "???";
! 					break;
! 			}
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
***************
*** 1658,1663 **** show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
--- 1676,1686 ----
  		return;
  	if (IsA(plan, RecursiveUnion))
  		return;
+ 	/* Likewise for ForeignScan in case of pushed-down UPDATE/DELETE */
+ 	if (IsA(plan, ForeignScan) &&
+ 		(((ForeignScan *) plan)->operation == CMD_UPDATE ||
+ 		 ((ForeignScan *) plan)->operation == CMD_DELETE))
+ 		return;
  
  	/* Set up deparsing context */
  	context = set_deparse_context_planstate(es->deparse_cxt,
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1011,1020 **** InitPlan(QueryDesc *queryDesc, int eflags)
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(Relation resultRel, CmdType operation)
  {
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
  
  	switch (resultRel->rd_rel->relkind)
  	{
--- 1011,1022 ----
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
  {
+ 	Relation	resultRel = resultRelInfo->ri_RelationDesc;
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
+ 	bool		supported;
  
  	switch (resultRel->rd_rel->relkind)
  	{
***************
*** 1083,1096 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  		case RELKIND_FOREIGN_TABLE:
  			/* Okay only if the FDW supports it */
  			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
  			switch (operation)
  			{
  				case CMD_INSERT:
! 					if (fdwroutine->ExecForeignInsert == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 							errmsg("cannot insert into foreign table \"%s\"",
! 								   RelationGetRelationName(resultRel))));
  					if (fdwroutine->IsForeignRelUpdatable != NULL &&
  						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
  						ereport(ERROR,
--- 1085,1107 ----
  		case RELKIND_FOREIGN_TABLE:
  			/* Okay only if the FDW supports it */
  			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
+ 			supported = ((fdwroutine->BeginDMLPushdown != NULL) &&
+ 						 (fdwroutine->IterateDMLPushdown != NULL) &&
+ 						 (fdwroutine->EndDMLPushdown != NULL));
  			switch (operation)
  			{
  				case CMD_INSERT:
! 					if (resultRelInfo->ri_FdwPushdown && !supported)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down insert on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignInsert == NULL)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot insert into foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
  					if (fdwroutine->IsForeignRelUpdatable != NULL &&
  						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
  						ereport(ERROR,
***************
*** 1099,1105 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_UPDATE:
! 					if (fdwroutine->ExecForeignUpdate == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  								 errmsg("cannot update foreign table \"%s\"",
--- 1110,1122 ----
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_UPDATE:
! 					if (resultRelInfo->ri_FdwPushdown && !supported)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down update on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignUpdate == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  								 errmsg("cannot update foreign table \"%s\"",
***************
*** 1112,1118 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_DELETE:
! 					if (fdwroutine->ExecForeignDelete == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  							errmsg("cannot delete from foreign table \"%s\"",
--- 1129,1141 ----
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_DELETE:
! 					if (resultRelInfo->ri_FdwPushdown && !supported)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down delete on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignDelete == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  							errmsg("cannot delete from foreign table \"%s\"",
***************
*** 1245,1250 **** InitResultRelInfo(ResultRelInfo *resultRelInfo,
--- 1268,1274 ----
  	else
  		resultRelInfo->ri_FdwRoutine = NULL;
  	resultRelInfo->ri_FdwState = NULL;
+ 	resultRelInfo->ri_FdwPushdown = false;
  	resultRelInfo->ri_ConstraintExprs = NULL;
  	resultRelInfo->ri_junkFilter = NULL;
  	resultRelInfo->ri_projectReturning = NULL;
*** a/src/backend/executor/nodeForeignscan.c
--- b/src/backend/executor/nodeForeignscan.c
***************
*** 48,54 **** ForeignNext(ForeignScanState *node)
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
--- 48,57 ----
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	if (plan->operation != CMD_SELECT)
! 		slot = node->fdwroutine->IterateDMLPushdown(node);
! 	else
! 		slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
***************
*** 226,232 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
--- 229,238 ----
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	if (node->operation != CMD_SELECT)
! 		fdwroutine->BeginDMLPushdown(scanstate, eflags);
! 	else
! 		fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
***************
*** 240,247 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
  	/* Let the FDW shut down */
! 	node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
--- 246,258 ----
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
+ 	ForeignScan *plan = (ForeignScan *) node->ss.ps.plan;
+ 
  	/* Let the FDW shut down */
! 	if (plan->operation != CMD_SELECT)
! 		node->fdwroutine->EndDMLPushdown(node);
! 	else
! 		node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
*** a/src/backend/executor/nodeModifyTable.c
--- b/src/backend/executor/nodeModifyTable.c
***************
*** 1348,1353 **** ExecModifyTable(ModifyTableState *node)
--- 1348,1359 ----
  				break;
  		}
  
+ 		if (resultRelInfo->ri_FdwPushdown)
+ 		{
+ 			estate->es_result_relation_info = saved_resultRelInfo;
+ 			return planSlot;
+ 		}
+ 
  		EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
  		slot = planSlot;
  
***************
*** 1527,1536 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  	{
  		subplan = (Plan *) lfirst(l);
  
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo->ri_RelationDesc, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
--- 1533,1545 ----
  	{
  		subplan = (Plan *) lfirst(l);
  
+ 		/* Initialize the FdwPushdown flag */
+ 		resultRelInfo->ri_FdwPushdown = list_nth_int(node->fdwPushdowns, i);
+ 
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
***************
*** 1551,1557 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
--- 1560,1567 ----
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (resultRelInfo->ri_FdwPushdown == false &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
***************
*** 1722,1734 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1732,1753 ----
  		erm = ExecFindRowMark(estate, rc->rti, false);
  
  		/* build ExecAuxRowMark for each subplan */
+ 		resultRelInfo = mtstate->resultRelInfo;
  		for (i = 0; i < nplans; i++)
  		{
  			ExecAuxRowMark *aerm;
  
+ 			/* ignore subplan if the FDW pushes the statement down */
+ 			if (resultRelInfo->ri_FdwPushdown)
+ 			{
+ 				resultRelInfo++;
+ 				continue;
+ 			}
+ 
  			subplan = mtstate->mt_plans[i]->plan;
  			aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
  			mtstate->mt_arowmarks[i] = lappend(mtstate->mt_arowmarks[i], aerm);
+ 			resultRelInfo++;
  		}
  	}
  
***************
*** 1784,1789 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1803,1815 ----
  			{
  				JunkFilter *j;
  
+ 				/* ignore subplan if the FDW pushes the statement down */
+ 				if (resultRelInfo->ri_FdwPushdown)
+ 				{
+ 					resultRelInfo++;
+ 					continue;
+ 				}
+ 
  				subplan = mtstate->mt_plans[i]->plan;
  				if (operation == CMD_INSERT || operation == CMD_UPDATE)
  					ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
***************
*** 1878,1884 **** ExecEndModifyTable(ModifyTableState *node)
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
--- 1904,1911 ----
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (resultRelInfo->ri_FdwPushdown == false &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 185,190 **** _copyModifyTable(const ModifyTable *from)
--- 185,191 ----
  	COPY_NODE_FIELD(plans);
  	COPY_NODE_FIELD(withCheckOptionLists);
  	COPY_NODE_FIELD(returningLists);
+ 	COPY_NODE_FIELD(fdwPushdowns);
  	COPY_NODE_FIELD(fdwPrivLists);
  	COPY_NODE_FIELD(rowMarks);
  	COPY_SCALAR_FIELD(epqParam);
***************
*** 645,650 **** _copyForeignScan(const ForeignScan *from)
--- 646,652 ----
  	/*
  	 * copy remainder of node
  	 */
+ 	COPY_SCALAR_FIELD(operation);
  	COPY_SCALAR_FIELD(fs_server);
  	COPY_NODE_FIELD(fdw_exprs);
  	COPY_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 339,344 **** _outModifyTable(StringInfo str, const ModifyTable *node)
--- 339,345 ----
  	WRITE_NODE_FIELD(plans);
  	WRITE_NODE_FIELD(withCheckOptionLists);
  	WRITE_NODE_FIELD(returningLists);
+ 	WRITE_NODE_FIELD(fdwPushdowns);
  	WRITE_NODE_FIELD(fdwPrivLists);
  	WRITE_NODE_FIELD(rowMarks);
  	WRITE_INT_FIELD(epqParam);
***************
*** 591,596 **** _outForeignScan(StringInfo str, const ForeignScan *node)
--- 592,598 ----
  
  	_outScanInfo(str, (const Scan *) node);
  
+ 	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_OID_FIELD(fs_server);
  	WRITE_NODE_FIELD(fdw_exprs);
  	WRITE_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/readfuncs.c
--- b/src/backend/nodes/readfuncs.c
***************
*** 1470,1475 **** _readModifyTable(void)
--- 1470,1476 ----
  	READ_NODE_FIELD(plans);
  	READ_NODE_FIELD(withCheckOptionLists);
  	READ_NODE_FIELD(returningLists);
+ 	READ_NODE_FIELD(fdwPushdowns);
  	READ_NODE_FIELD(fdwPrivLists);
  	READ_NODE_FIELD(rowMarks);
  	READ_INT_FIELD(epqParam);
*** a/src/backend/optimizer/plan/createplan.c
--- b/src/backend/optimizer/plan/createplan.c
***************
*** 3765,3770 **** make_foreignscan(List *qptlist,
--- 3765,3771 ----
  	plan->lefttree = outer_plan;
  	plan->righttree = NULL;
  	node->scan.scanrelid = scanrelid;
+ 	node->operation = CMD_SELECT;
  	/* fs_server will be filled in by create_foreignscan_plan */
  	node->fs_server = InvalidOid;
  	node->fdw_exprs = fdw_exprs;
***************
*** 5039,5044 **** make_modifytable(PlannerInfo *root,
--- 5040,5046 ----
  	ModifyTable *node = makeNode(ModifyTable);
  	Plan	   *plan = &node->plan;
  	double		total_size;
+ 	List	   *fdwpushdown_list;
  	List	   *fdw_private_list;
  	ListCell   *subnode;
  	ListCell   *lc;
***************
*** 5119,5130 **** make_modifytable(PlannerInfo *root,
--- 5121,5134 ----
  	 * For each result relation that is a foreign table, allow the FDW to
  	 * construct private plan data, and accumulate it all into a list.
  	 */
+ 	fdwpushdown_list = NIL;
  	fdw_private_list = NIL;
  	i = 0;
  	foreach(lc, resultRelations)
  	{
  		Index		rti = lfirst_int(lc);
  		FdwRoutine *fdwroutine;
+ 		bool		fdwpushdown;
  		List	   *fdw_private;
  
  		/*
***************
*** 5153,5158 **** make_modifytable(PlannerInfo *root,
--- 5157,5170 ----
  		}
  
  		if (fdwroutine != NULL &&
+ 			fdwroutine->PlanDMLPushdown != NULL)
+ 			fdwpushdown = fdwroutine->PlanDMLPushdown(root, node, rti, i);
+ 		else
+ 			fdwpushdown = false;
+ 		fdwpushdown_list = lappend_int(fdwpushdown_list, fdwpushdown);
+ 
+ 		if (!fdwpushdown &&
+ 			fdwroutine != NULL &&
  			fdwroutine->PlanForeignModify != NULL)
  			fdw_private = fdwroutine->PlanForeignModify(root, node, rti, i);
  		else
***************
*** 5160,5165 **** make_modifytable(PlannerInfo *root,
--- 5172,5178 ----
  		fdw_private_list = lappend(fdw_private_list, fdw_private);
  		i++;
  	}
+ 	node->fdwPushdowns = fdwpushdown_list;
  	node->fdwPrivLists = fdw_private_list;
  
  	return node;
*** a/src/include/executor/executor.h
--- b/src/include/executor/executor.h
***************
*** 184,190 **** extern void ExecutorEnd(QueryDesc *queryDesc);
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(Relation resultRel, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
--- 184,190 ----
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
*** a/src/include/foreign/fdwapi.h
--- b/src/include/foreign/fdwapi.h
***************
*** 91,96 **** typedef TupleTableSlot *(*ExecForeignDelete_function) (EState *estate,
--- 91,108 ----
  typedef void (*EndForeignModify_function) (EState *estate,
  													   ResultRelInfo *rinfo);
  
+ typedef bool (*PlanDMLPushdown_function) (PlannerInfo *root,
+ 										  ModifyTable *plan,
+ 										  Index resultRelation,
+ 										  int subplan_index);
+ 
+ typedef void (*BeginDMLPushdown_function) (ForeignScanState *node,
+ 										   int eflags);
+ 
+ typedef TupleTableSlot *(*IterateDMLPushdown_function) (ForeignScanState *node);
+ 
+ typedef void (*EndDMLPushdown_function) (ForeignScanState *node);
+ 
  typedef int (*IsForeignRelUpdatable_function) (Relation rel);
  
  typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
***************
*** 161,166 **** typedef struct FdwRoutine
--- 173,182 ----
  	ExecForeignUpdate_function ExecForeignUpdate;
  	ExecForeignDelete_function ExecForeignDelete;
  	EndForeignModify_function EndForeignModify;
+ 	PlanDMLPushdown_function PlanDMLPushdown;
+ 	BeginDMLPushdown_function BeginDMLPushdown;
+ 	IterateDMLPushdown_function IterateDMLPushdown;
+ 	EndDMLPushdown_function EndDMLPushdown;
  	IsForeignRelUpdatable_function IsForeignRelUpdatable;
  
  	/* Functions for SELECT FOR UPDATE/SHARE row locking */
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 311,316 **** typedef struct JunkFilter
--- 311,317 ----
   *		TrigInstrument			optional runtime measurements for triggers
   *		FdwRoutine				FDW callback functions, if foreign table
   *		FdwState				available to save private state of FDW
+  *		FdwPushdown				true when the command is pushed down
   *		WithCheckOptions		list of WithCheckOption's to be checked
   *		WithCheckOptionExprs	list of WithCheckOption expr states
   *		ConstraintExprs			array of constraint-checking expr states
***************
*** 334,339 **** typedef struct ResultRelInfo
--- 335,341 ----
  	Instrumentation *ri_TrigInstrument;
  	struct FdwRoutine *ri_FdwRoutine;
  	void	   *ri_FdwState;
+ 	bool		ri_FdwPushdown;
  	List	   *ri_WithCheckOptions;
  	List	   *ri_WithCheckOptionExprs;
  	List	  **ri_ConstraintExprs;
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
***************
*** 187,192 **** typedef struct ModifyTable
--- 187,193 ----
  	List	   *plans;			/* plan(s) producing source data */
  	List	   *withCheckOptionLists;	/* per-target-table WCO lists */
  	List	   *returningLists; /* per-target-table RETURNING tlists */
+ 	List	   *fdwPushdowns;	/* per-target-table FDW pushdown flags */
  	List	   *fdwPrivLists;	/* per-target-table FDW private data lists */
  	List	   *rowMarks;		/* PlanRowMarks (non-locking only) */
  	int			epqParam;		/* ID of Param for EvalPlanQual re-eval */
***************
*** 530,535 **** typedef struct WorkTableScan
--- 531,537 ----
  typedef struct ForeignScan
  {
  	Scan		scan;
+ 	CmdType		operation;		/* SELECT/UPDATE/DELETE */
  	Oid			fs_server;		/* OID of foreign server */
  	List	   *fdw_exprs;		/* expressions that FDW may evaluate */
  	List	   *fdw_private;	/* private data for FDW */

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 816,822 **** deparseTargetList(StringInfo buf,
   *
   * If params is not NULL, it receives a list of Params and other-relation Vars
   * used in the clauses; these values must be transmitted to the remote server
!  * as parameter values.
   *
   * If params is NULL, we're generating the query for EXPLAIN purposes,
   * so Params and other-relation Vars should be replaced by dummy values.
--- 816,822 ----
   *
   * If params is not NULL, it receives a list of Params and other-relation Vars
   * used in the clauses; these values must be transmitted to the remote server
!  * as parameter values.  Caller is responsible for initializing it to empty.
   *
   * If params is NULL, we're generating the query for EXPLAIN purposes,
   * so Params and other-relation Vars should be replaced by dummy values.
***************
*** 833,841 **** appendWhereClause(StringInfo buf,
  	int			nestlevel;
  	ListCell   *lc;
  
- 	if (params)
- 		*params = NIL;			/* initialize result list to empty */
- 
  	/* Set up context struct for recursion */
  	context.root = root;
  	context.foreignrel = baserel;
--- 833,838 ----
***************
*** 971,976 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 968,1030 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*targetlist,
+ 						   List *targetAttrs,
+ 						   List	*remote_conds,
+ 						   List **params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	deparse_expr_cxt context;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	if (params_list)
+ 		*params_list = NIL;		/* initialize result list to empty */
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = params_list;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfoString(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 993,998 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 1047,1082 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*remote_conds,
+ 						   List	**params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 
+ 	if (params_list)
+ 		*params_list = NIL;		/* initialize result list to empty */
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 1314,1320 **** INSERT INTO ft2 (c1,c2,c3)
--- 1314,1339 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (3 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1424,1430 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1443,1449 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1445,1460 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1464,1477 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1565,1571 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1582,1588 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2408,2413 **** SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
--- 2425,2443 ----
   1104 | 204 | ddd                | 
  (819 rows)
  
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;    -- can't be pushed down
+                                                       QUERY PLAN                                                       
+ -----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Remote SQL: UPDATE "S 1"."T 1" SET c7 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, c3, c4, c5, c6, 'ft2       '::character(10), c8, ctid
+          Filter: (date(ft2.c4) = '01-01-1970'::date)
+          Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c8, ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 0)) FOR UPDATE
+ (6 rows)
+ 
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
***************
*** 2554,2560 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2584,2590 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2713,2719 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2743,2749 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2853,2859 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
--- 2883,2889 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
***************
*** 3246,3251 **** NOTICE:  NEW: (13,"test triggered !")
--- 3276,3474 ----
   (0,27)
  (1 row)
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ -- Test update-pushdown functionality
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_before ON rem1;
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_after ON rem1;
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_update ON rem1;
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                   QUERY PLAN                                   
+ -------------------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_update ON rem1;
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                                QUERY PLAN                               
+ ------------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_after_delete ON rem1;
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 57,63 **** PG_MODULE_MAGIC;
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
--- 57,64 ----
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) List of restriction clauses that can be executed remotely
!  * 3) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
***************
*** 67,72 **** enum FdwScanPrivateIndex
--- 68,75 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
+ 	/* List of restriction clauses that can be executed remotely */
+ 	FdwScanPrivateRemoteConds,
  	/* Integer list of attribute numbers retrieved by the SELECT */
  	FdwScanPrivateRetrievedAttrs
  };
***************
*** 94,99 **** enum FdwModifyPrivateIndex
--- 97,124 ----
  };
  
  /*
+  * Similarly, this enum describes what's kept in the fdw_private list for
+  * a ForeignScan node referencing a postgres_fdw foreign table when a DML
+  * query is pushed down to the remote server.  We store:
+  *
+  * 1) UPDATE/DELETE statement text to be sent to the remote server
+  * 2) Boolean flag showing if the remote query has a RETURNING clause
+  * 3) Integer list of attribute numbers retrieved by RETURNING, if any
+  * 4) Boolean flag showing if we set the command es_processed
+  */
+ enum FdwDmlPushdownPrivateIndex
+ {
+ 	/* SQL statement to execute remotely (as a String node) */
+ 	FdwDmlPushdownPrivateUpdateSql,
+ 	/* has-returning flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateHasReturning,
+ 	/* Integer list of attribute numbers retrieved by RETURNING */
+ 	FdwDmlPushdownPrivateRetrievedAttrs,
+ 	/* set-processed flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateSetProcessed
+ };
+ 
+ /*
   * Execution state of a foreign scan using postgres_fdw.
   */
  typedef struct PgFdwScanState
***************
*** 156,161 **** typedef struct PgFdwModifyState
--- 181,217 ----
  } PgFdwModifyState;
  
  /*
+  * Execution state of a foreign scan using postgres_fdw.
+  */
+ typedef struct PgFdwDmlPushdownState
+ {
+ 	Relation	rel;			/* relcache entry for the foreign table */
+ 	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
+ 
+ 	/* extracted fdw_private data */
+ 	char	   *query;			/* text of UPDATE/DELETE command */
+ 	List	   *retrieved_attrs;	/* list of retrieved attribute numbers */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 
+ 	/* for remote query execution */
+ 	PGconn	   *conn;			/* connection for the scan */
+ 	int			numParams;		/* number of parameters passed to query */
+ 	FmgrInfo   *param_flinfo;	/* output conversion functions for them */
+ 	List	   *param_exprs;	/* executable expressions for param values */
+ 	const char **param_values;	/* textual values of query parameters */
+ 
+ 	/* for storing result tuples */
+ 	PGresult   *result;			/* result for query */
+ 	int			num_tuples;		/* # of tuples in array */
+ 	int			next_tuple;		/* index of next one to return */
+ 
+ 	/* working memory contexts */
+ 	MemoryContext batch_cxt;	/* context holding current batch of tuples */
+ 	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
+ } PgFdwDmlPushdownState;
+ 
+ /*
   * Workspace for analyzing a foreign table.
   */
  typedef struct PgFdwAnalyzeState
***************
*** 246,251 **** static TupleTableSlot *postgresExecForeignDelete(EState *estate,
--- 302,314 ----
  						  TupleTableSlot *planSlot);
  static void postgresEndForeignModify(EState *estate,
  						 ResultRelInfo *resultRelInfo);
+ static bool postgresPlanDMLPushdown(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index);
+ static void postgresBeginDMLPushdown(ForeignScanState *node, int eflags);
+ static TupleTableSlot *postgresIterateDMLPushdown(ForeignScanState *node);
+ static void postgresEndDMLPushdown(ForeignScanState *node);
  static int	postgresIsForeignRelUpdatable(Relation rel);
  static void postgresExplainForeignScan(ForeignScanState *node,
  						   ExplainState *es);
***************
*** 254,259 **** static void postgresExplainForeignModify(ModifyTableState *mtstate,
--- 317,324 ----
  							 List *fdw_private,
  							 int subplan_index,
  							 ExplainState *es);
+ static void postgresExplainDMLPushdown(ForeignScanState *node,
+ 						   ExplainState *es);
  static bool postgresAnalyzeForeignTable(Relation relation,
  							AcquireSampleRowsFunc *func,
  							BlockNumber *totalpages);
***************
*** 288,295 **** static void prepare_foreign_modify(PgFdwModifyState *fmstate);
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
--- 353,374 ----
  static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
  						 ItemPointer tupleid,
  						 TupleTableSlot *slot);
! static void store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context);
! static bool dml_is_pushdown_safe(PlannerInfo *root,
! 								 ModifyTable *plan,
! 								 Index resultRelation,
! 								 int subplan_index,
! 								 Relation rel,
! 								 List *targetAttrs);
! static void execute_dml_stmt(ForeignScanState *node);
! static bool relation_has_row_level_triggers(Relation rel, CmdType operation);
! static TupleTableSlot *get_returning_result(ForeignScanState *node);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 331,341 **** postgres_fdw_handler(PG_FUNCTION_ARGS)
--- 410,425 ----
  	routine->ExecForeignUpdate = postgresExecForeignUpdate;
  	routine->ExecForeignDelete = postgresExecForeignDelete;
  	routine->EndForeignModify = postgresEndForeignModify;
+ 	routine->PlanDMLPushdown = postgresPlanDMLPushdown;
+ 	routine->BeginDMLPushdown = postgresBeginDMLPushdown;
+ 	routine->IterateDMLPushdown = postgresIterateDMLPushdown;
+ 	routine->EndDMLPushdown = postgresEndDMLPushdown;
  	routine->IsForeignRelUpdatable = postgresIsForeignRelUpdatable;
  
  	/* Support functions for EXPLAIN */
  	routine->ExplainForeignScan = postgresExplainForeignScan;
  	routine->ExplainForeignModify = postgresExplainForeignModify;
+ 	routine->ExplainDMLPushdown = postgresExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	routine->AnalyzeForeignTable = postgresAnalyzeForeignTable;
***************
*** 1067,1073 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make2(makeString(sql.data),
  							 retrieved_attrs);
  
  	/*
--- 1151,1158 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make3(makeString(sql.data),
! 							 remote_conds,
  							 retrieved_attrs);
  
  	/*
***************
*** 1363,1375 **** postgresAddForeignUpdateTargets(Query *parsetree,
  /*
   * postgresPlanForeignModify
   *		Plan an insert/update/delete operation on a foreign table
-  *
-  * Note: currently, the plan tree generated for UPDATE/DELETE will always
-  * include a ForeignScan that retrieves ctids (using SELECT FOR UPDATE)
-  * and then the ModifyTable node will have to execute individual remote
-  * UPDATE/DELETE commands.  If there are no local conditions or joins
-  * needed, it'd be better to let the scan node do UPDATE/DELETE RETURNING
-  * and then do nothing at ModifyTable.  Room for future optimization ...
   */
  static List *
  postgresPlanForeignModify(PlannerInfo *root,
--- 1448,1453 ----
***************
*** 1644,1650 **** postgresExecForeignInsert(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1722,1732 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1714,1720 **** postgresExecForeignUpdate(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1796,1806 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1784,1790 **** postgresExecForeignDelete(EState *estate,
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(fmstate, slot, res);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
--- 1870,1880 ----
  	{
  		n_rows = PQntuples(res);
  		if (n_rows > 0)
! 			store_returning_result(slot, res, 0,
! 								   fmstate->rel,
! 								   fmstate->attinmeta,
! 								   fmstate->retrieved_attrs,
! 								   fmstate->temp_cxt);
  	}
  	else
  		n_rows = atoi(PQcmdTuples(res));
***************
*** 1837,1842 **** postgresEndForeignModify(EState *estate,
--- 1927,2242 ----
  }
  
  /*
+  * postgresPlanDMLPushdown
+  *		Plan to push down an update/delete operation on a foreign table
+  */
+ static bool
+ postgresPlanDMLPushdown(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index)
+ {
+ 	CmdType		operation = plan->operation;
+ 	RangeTblEntry *rte = planner_rt_fetch(resultRelation, root);
+ 	Relation	rel;
+ 	StringInfoData sql;
+ 	List	   *targetAttrs = NIL;
+ 	List	   *params_list = NIL;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 	List	   *remote_conds;
+ 	ForeignScan *fscan;
+ 
+ 	if (operation == CMD_INSERT)
+ 		return false;
+ 
+ 	/*
+ 	 * Core code already has some lock on each rel being planned, so we can
+ 	 * use NoLock here.
+ 	 */
+ 	rel = heap_open(rte->relid, NoLock);
+ 
+ 	/*
+ 	 * In an UPDATE, we transmit only columns that were explicitly targets
+ 	 * of the UPDATE, so as to avoid unnecessary data transmission.
+ 	 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		int			col;
+ 
+ 		col = -1;
+ 		while ((col = bms_next_member(rte->updatedCols, col)) >= 0)
+ 		{
+ 			/* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
+ 			AttrNumber	attno = col + FirstLowInvalidHeapAttributeNumber;
+ 
+ 			if (attno <= InvalidAttrNumber)		/* shouldn't happen */
+ 				elog(ERROR, "system-column update is not supported");
+ 			targetAttrs = lappend_int(targetAttrs, attno);
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Ok, check to see whether it's safe to push the command down.
+ 	 */
+ 	if (!dml_is_pushdown_safe(root, plan,
+ 							  resultRelation,
+ 							  subplan_index,
+ 							  rel, targetAttrs))
+ 	{
+ 		heap_close(rel, NoLock);
+ 		return false;
+ 	}
+ 
+ 	/*
+ 	 * Ok, modify subplan so as to execute the pushed-down command.
+ 	 */
+ 	fscan = (ForeignScan *) list_nth(plan->plans, subplan_index);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	initStringInfo(&sql);
+ 	switch (operation)
+ 	{
+ 		case CMD_UPDATE:
+ 			deparsePushedDownUpdateSql(&sql, root, resultRelation, rel,
+ 									   ((Plan *) fscan)->targetlist,
+ 									   targetAttrs,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		case CMD_DELETE:
+ 			deparsePushedDownDeleteSql(&sql, root, resultRelation, rel,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		default:
+ 			elog(ERROR, "unexpected operation: %d", (int) operation);
+ 			break;
+ 	}
+ 
+ 	/*
+ 	 * Update the operation info.
+ 	 */
+ 	fscan->operation = operation;
+ 
+ 	/*
+ 	 * Update the fdw_exprs list that will be available to the executor.
+ 	 */
+ 	fscan->fdw_exprs = params_list;
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwDmlPushdownPrivateIndex, above.
+ 	 */
+ 	fscan->fdw_private = list_make4(makeString(sql.data),
+ 									makeInteger((retrieved_attrs != NIL)),
+ 									retrieved_attrs,
+ 									makeInteger(plan->canSetTag));
+ 
+ 	heap_close(rel, NoLock);
+ 	return true;
+ }
+ 
+ /*
+  * postgresBeginDMLPushdown
+  *		Initiate a pushed-down update/delete operation on a foreign table
+  */
+ static void
+ postgresBeginDMLPushdown(ForeignScanState *node, int eflags)
+ {
+ 	ForeignScan *fsplan = (ForeignScan *) node->ss.ps.plan;
+ 	EState	   *estate = node->ss.ps.state;
+ 	PgFdwDmlPushdownState *dpstate;
+ 	RangeTblEntry *rte;
+ 	Oid			userid;
+ 	ForeignTable *table;
+ 	ForeignServer *server;
+ 	UserMapping *user;
+ 	int			numParams;
+ 	int			i;
+ 	ListCell   *lc;
+ 
+ 	/*
+ 	 * Do nothing in EXPLAIN (no ANALYZE) case.  node->fdw_state stays NULL.
+ 	 */
+ 	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
+ 		return;
+ 
+ 	/*
+ 	 * We'll save private state in node->fdw_state.
+ 	 */
+ 	dpstate = (PgFdwDmlPushdownState *) palloc0(sizeof(PgFdwDmlPushdownState));
+ 	node->fdw_state = (void *) dpstate;
+ 
+ 	/*
+ 	 * Identify which user to do the remote access as.  This should match what
+ 	 * ExecCheckRTEPerms() does.
+ 	 */
+ 	rte = rt_fetch(fsplan->scan.scanrelid, estate->es_range_table);
+ 	userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
+ 
+ 	/* Get info about foreign table. */
+ 	dpstate->rel = node->ss.ss_currentRelation;
+ 	table = GetForeignTable(RelationGetRelid(dpstate->rel));
+ 	server = GetForeignServer(table->serverid);
+ 	user = GetUserMapping(userid, server->serverid);
+ 
+ 	/*
+ 	 * Get connection to the foreign server.  Connection manager will
+ 	 * establish new connection if necessary.
+ 	 */
+ 	dpstate->conn = GetConnection(server, user, false);
+ 
+ 	/* Initialize state variable */
+ 	dpstate->num_tuples = -1;		/* -1 means not set yet */
+ 
+ 	/* Get private info created by planner functions. */
+ 	dpstate->query = strVal(list_nth(fsplan->fdw_private,
+ 									 FdwDmlPushdownPrivateUpdateSql));
+ 	dpstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateHasReturning));
+ 	dpstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 										FdwDmlPushdownPrivateRetrievedAttrs);
+ 	dpstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateSetProcessed));
+ 
+ 	/* Create contexts for batches of tuples and per-tuple temp workspace. */
+ 	dpstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
+ 											   "postgres_fdw tuple data",
+ 											   ALLOCSET_DEFAULT_MINSIZE,
+ 											   ALLOCSET_DEFAULT_INITSIZE,
+ 											   ALLOCSET_DEFAULT_MAXSIZE);
+ 	dpstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
+ 											  "postgres_fdw temporary data",
+ 											  ALLOCSET_SMALL_MINSIZE,
+ 											  ALLOCSET_SMALL_INITSIZE,
+ 											  ALLOCSET_SMALL_MAXSIZE);
+ 
+ 	/* Prepare for input conversion of RETURNING results. */
+ 	if (dpstate->has_returning)
+ 		dpstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(dpstate->rel));
+ 
+ 	/* Prepare for output conversion of parameters used in remote query. */
+ 	numParams = list_length(fsplan->fdw_exprs);
+ 	dpstate->numParams = numParams;
+ 	dpstate->param_flinfo = (FmgrInfo *) palloc0(sizeof(FmgrInfo) * numParams);
+ 
+ 	i = 0;
+ 	foreach(lc, fsplan->fdw_exprs)
+ 	{
+ 		Node	   *param_expr = (Node *) lfirst(lc);
+ 		Oid			typefnoid;
+ 		bool		isvarlena;
+ 
+ 		getTypeOutputInfo(exprType(param_expr), &typefnoid, &isvarlena);
+ 		fmgr_info(typefnoid, &dpstate->param_flinfo[i]);
+ 		i++;
+ 	}
+ 
+ 	/*
+ 	 * Prepare remote-parameter expressions for evaluation.  (Note: in
+ 	 * practice, we expect that all these expressions will be just Params, so
+ 	 * we could possibly do something more efficient than using the full
+ 	 * expression-eval machinery for this.  But probably there would be little
+ 	 * benefit, and it'd require postgres_fdw to know more than is desirable
+ 	 * about Param evaluation.)
+ 	 */
+ 	dpstate->param_exprs = (List *)
+ 		ExecInitExpr((Expr *) fsplan->fdw_exprs,
+ 					 (PlanState *) node);
+ 
+ 	/*
+ 	 * Allocate buffer for text form of query parameters, if any.
+ 	 */
+ 	if (numParams > 0)
+ 		dpstate->param_values = (const char **) palloc0(numParams * sizeof(char *));
+ 	else
+ 		dpstate->param_values = NULL;
+ }
+ 
+ /*
+  * postgresIterateDMLPushdown
+  *		Get the result of a pushed-down update/delete operation on a foreign table
+  */
+ static TupleTableSlot *
+ postgresIterateDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 
+ 	/*
+ 	 * If this is the first call after Begin, execute the statement.
+ 	 */
+ 	if (dpstate->num_tuples == -1)
+ 		execute_dml_stmt(node);
+ 
+ 	/*
+ 	 * If the given query doesn't specify RETURNING, just return an empty slot.
+ 	 */
+ 	if (!resultRelInfo->ri_projectReturning)
+ 	{
+ 		TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 		Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 		Assert(!dpstate->has_returning);
+ 
+ 		/* Increment the command es_processed count if necessary. */
+ 		if (dpstate->set_processed)
+ 			estate->es_processed += dpstate->num_tuples;
+ 
+ 		/* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
+ 		if (node->ss.ps.instrument)
+ 			instr->ntuples += dpstate->num_tuples;
+ 
+ 		return ExecClearTuple(slot);
+ 	}
+ 
+ 	/*
+ 	 * Get the next returning result.
+ 	 */
+ 	return get_returning_result(node);
+ }
+ 
+ /*
+  * postgresEndDMLPushdown
+  *		Finish a pushed-down update/delete operation on a foreign table
+  */
+ static void
+ postgresEndDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 
+ 	/* if dpstate is NULL, we are in EXPLAIN; nothing to do */
+ 	if (dpstate == NULL)
+ 		return;
+ 
+ 	/* Clean up */
+ 	if (dpstate->result)
+ 		PQclear(dpstate->result);
+ 
+ 	/* Release remote connection */
+ 	ReleaseConnection(dpstate->conn);
+ 	dpstate->conn = NULL;
+ 
+ 	/* MemoryContexts will be deleted automatically. */
+ }
+ 
+ /*
   * postgresIsForeignRelUpdatable
   *		Determine whether a foreign table supports INSERT, UPDATE and/or
   *		DELETE.
***************
*** 1919,1924 **** postgresExplainForeignModify(ModifyTableState *mtstate,
--- 2319,2343 ----
  	}
  }
  
+ /*
+  * postgresExplainDMLPushdown
+  *		Produce extra output for EXPLAIN of a ForeignScan for a pushed-down
+  *		update/delete operation on a foreign table
+  */
+ static void
+ postgresExplainDMLPushdown(ForeignScanState *node, ExplainState *es)
+ {
+ 	List	   *fdw_private;
+ 	char	   *sql;
+ 
+ 	if (es->verbose)
+ 	{
+ 		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
+ 		sql = strVal(list_nth(fdw_private, FdwDmlPushdownPrivateUpdateSql));
+ 		ExplainPropertyText("Remote SQL", sql, es);
+ 	}
+ }
+ 
  
  /*
   * estimate_path_cost_size
***************
*** 2510,2527 **** convert_prep_stmt_params(PgFdwModifyState *fmstate,
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(PgFdwModifyState *fmstate,
! 					   TupleTableSlot *slot, PGresult *res)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, 0,
! 											fmstate->rel,
! 											fmstate->attinmeta,
! 											fmstate->retrieved_attrs,
! 											fmstate->temp_cxt);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
--- 2929,2951 ----
   * have PG_TRY blocks to ensure this happens.
   */
  static void
! store_returning_result(TupleTableSlot *slot,
! 					   PGresult *res,
! 					   int row,
! 					   Relation rel,
! 					   AttInMetadata *attinmeta,
! 					   List *retrieved_attrs,
! 					   MemoryContext temp_context)
  {
  	PG_TRY();
  	{
  		HeapTuple	newtup;
  
! 		newtup = make_tuple_from_result_row(res, row,
! 											rel,
! 											attinmeta,
! 											retrieved_attrs,
! 											temp_context);
  		/* tuple will be deleted when it is cleared from the slot */
  		ExecStoreTuple(newtup, slot, InvalidBuffer, true);
  	}
***************
*** 2535,2540 **** store_returning_result(PgFdwModifyState *fmstate,
--- 2959,3183 ----
  }
  
  /*
+  * Check to see whether it's safe to push an UPDATE/DELETE command down.
+  *
+  * Conditions checked here:
+  *
+  * 1. If there are any local joins needed, we mustn't push the command down,
+  * because that breaks execution of the joins.
+  *
+  * 2. If there are any quals that can't be evaluated remotely, we mustn't push
+  * the command down, because that breaks evaluation of the quals.
+  *
+  * 3. If the target relation has any row-level local triggers, we mustn't push
+  * the command down, because that breaks execution of the triggers.
+  *
+  * 4. For UPDATE, if it is unsafe to evaluate on the remote server any
+  * expressions to assign to the target columns, we can't push the command down.
+  */
+ static bool
+ dml_is_pushdown_safe(PlannerInfo *root,
+ 					 ModifyTable *plan,
+ 					 Index resultRelation,
+ 					 int subplan_index,
+ 					 Relation rel,
+ 					 List *targetAttrs)
+ {
+ 	CmdType		operation = plan->operation;
+ 	RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	ListCell   *lc;
+ 
+ 	Assert(operation == CMD_UPDATE || operation == CMD_DELETE);
+ 
+ 	/* Check point 1 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (relation_has_row_level_triggers(rel, operation))
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(subplan->targetlist,
+ 											attnum);
+ 
+ 		if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 			return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ /*
+  * relation_has_row_level_triggers
+  *		Determine if relation has any row-level triggers for a given operation.
+  */
+ static bool
+ relation_has_row_level_triggers(Relation rel, CmdType operation)
+ {
+ 	bool		result = false;
+ 
+ 	Assert(rel != NULL);
+ 
+ 	if (rel->trigdesc == NULL)
+ 		return result;
+ 
+ 	switch (operation)
+ 	{
+ 		case CMD_INSERT:
+ 			result = (rel->trigdesc->trig_insert_after_row ||
+ 					  rel->trigdesc->trig_insert_before_row);
+ 			break;
+ 		case CMD_UPDATE:
+ 			result = (rel->trigdesc->trig_update_after_row ||
+ 					  rel->trigdesc->trig_update_before_row);
+ 			break;
+ 		case CMD_DELETE:
+ 			result = (rel->trigdesc->trig_delete_after_row ||
+ 					  rel->trigdesc->trig_delete_before_row);
+ 			break;
+ 		default:
+ 			elog(ERROR, "unexpected operation: %d", (int) operation);
+ 			break;
+ 	}
+ 	return result;
+ }
+ 
+ /*
+  * Execute a pushed-down UPDATE/DELETE statement.
+  */
+ static void
+ execute_dml_stmt(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	ExprContext *econtext = node->ss.ps.ps_ExprContext;
+ 	int			numParams = dpstate->numParams;
+ 	const char **values = dpstate->param_values;
+ 
+ 	/*
+ 	 * Construct array of query parameter values in text format.  We do the
+ 	 * conversions in the short-lived per-tuple context, so as not to cause a
+ 	 * memory leak over repeated scans.
+ 	 */
+ 	if (numParams > 0)
+ 	{
+ 		int			nestlevel;
+ 		MemoryContext oldcontext;
+ 		int			i;
+ 		ListCell   *lc;
+ 
+ 		oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
+ 
+ 		nestlevel = set_transmission_modes();
+ 
+ 		i = 0;
+ 		foreach(lc, dpstate->param_exprs)
+ 		{
+ 			ExprState  *expr_state = (ExprState *) lfirst(lc);
+ 			Datum		expr_value;
+ 			bool		isNull;
+ 
+ 			/* Evaluate the parameter expression */
+ 			expr_value = ExecEvalExpr(expr_state, econtext, &isNull, NULL);
+ 
+ 			/*
+ 			 * Get string representation of each parameter value by invoking
+ 			 * type-specific output function, unless the value is null.
+ 			 */
+ 			if (isNull)
+ 				values[i] = NULL;
+ 			else
+ 				values[i] = OutputFunctionCall(&dpstate->param_flinfo[i],
+ 											   expr_value);
+ 			i++;
+ 		}
+ 
+ 		reset_transmission_modes(nestlevel);
+ 
+ 		MemoryContextSwitchTo(oldcontext);
+ 	}
+ 
+ 	/*
+ 	 * Notice that we pass NULL for paramTypes, thus forcing the remote server
+ 	 * to infer types for all parameters.  Since we explicitly cast every
+ 	 * parameter (see deparse.c), the "inference" is trivial and will produce
+ 	 * the desired result.  This allows us to avoid assuming that the remote
+ 	 * server has the same OIDs we do for the parameters' types.
+ 	 *
+ 	 * We don't use a PG_TRY block here, so be careful not to throw error
+ 	 * without releasing the PGresult.
+ 	 */
+ 	dpstate->result = PQexecParams(dpstate->conn, dpstate->query,
+ 								   numParams, NULL, values, NULL, NULL, 0);
+ 	if (PQresultStatus(dpstate->result) !=
+ 		(dpstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 		pgfdw_report_error(ERROR, dpstate->result, dpstate->conn, true,
+ 						   dpstate->query);
+ 
+ 	/* Get the number of rows affected. */
+ 	if (dpstate->has_returning)
+ 		dpstate->num_tuples = PQntuples(dpstate->result);
+ 	else
+ 		dpstate->num_tuples = atoi(PQcmdTuples(dpstate->result));
+ }
+ 
+ /*
+  * Get the result of an UPDATE/DELETE RETURNING.
+  */
+ static TupleTableSlot *
+ get_returning_result(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 	MemoryContext oldcontext;
+ 
+ 	Assert(resultRelInfo->ri_projectReturning);
+ 
+ 	/* If we didn't get any tuples, must be end of data. */
+ 	if (dpstate->next_tuple >= dpstate->num_tuples)
+ 		return ExecClearTuple(slot);
+ 
+ 	/* Increment the command es_processed count if necessary. */
+ 	if (dpstate->set_processed)
+ 		estate->es_processed += 1;
+ 
+ 	/* OK, we'll store RETURNING tuples. */
+ 	if (!dpstate->has_returning)
+ 		ExecStoreAllNullTuple(slot);
+ 	else
+ 	{
+ 		oldcontext = MemoryContextSwitchTo(dpstate->batch_cxt);
+ 
+ 		/* Fetch the next tuple. */
+ 		store_returning_result(slot,
+ 							   dpstate->result,
+ 							   dpstate->next_tuple,
+ 							   dpstate->rel,
+ 							   dpstate->attinmeta,
+ 							   dpstate->retrieved_attrs,
+ 							   dpstate->temp_cxt);
+ 
+ 		MemoryContextSwitchTo(oldcontext);
+ 	}
+ 	dpstate->next_tuple++;
+ 
+ 	/* Set tuple for later evaluation of the RETURNING list. */
+ 	resultRelInfo->ri_projectReturning->pi_exprContext->ecxt_scantuple = slot;
+ 
+ 	return slot;
+ }
+ 
+ /*
   * postgresAnalyzeForeignTable
   *		Test whether analyzing this foreign table is supported
   */
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 103,112 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 103,126 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*targetlist,
+ 									   List *targetAttrs,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 399,418 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
--- 399,425 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;    -- can't be pushed down
+ UPDATE ft2 SET c7 = DEFAULT WHERE c1 % 10 = 0 AND date(c4) = '1970-01-01'::date;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
***************
*** 728,733 **** UPDATE rem1 SET f2 = 'testo';
--- 735,824 ----
  -- Test returning a system attribute
  INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ 
+ 
+ -- Test update-pushdown functionality
+ 
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_before ON rem1;
+ 
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_after ON rem1;
+ 
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ 
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_update ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_update ON rem1;
+ 
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_after_delete ON rem1;
+ 
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 471,476 ****
--- 471,485 ----
     extension that's listed in the foreign server's <literal>extensions</>
     option.  Operators and functions in such clauses must
     be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, or no row-level local <literal>BEFORE</> or
+    <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, and <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 888,894 **** ExplainNode(PlanState *planstate, List *ancestors,
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			pname = sname = "Foreign Scan";
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
--- 888,912 ----
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			sname = "Foreign Scan";
! 			switch (((ForeignScan *) plan)->operation)
! 			{
! 				case CMD_SELECT:
! 					pname = "Foreign Scan";
! 					operation = "Select";
! 					break;
! 				case CMD_UPDATE:
! 					pname = "Foreign Update";
! 					operation = "Update";
! 					break;
! 				case CMD_DELETE:
! 					pname = "Foreign Delete";
! 					operation = "Delete";
! 					break;
! 				default:
! 					pname = "???";
! 					break;
! 			}
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
***************
*** 1624,1629 **** show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
--- 1642,1652 ----
  		return;
  	if (IsA(plan, RecursiveUnion))
  		return;
+ 	/* Likewise for ForeignScan in case of pushed-down UPDATE/DELETE */
+ 	if (IsA(plan, ForeignScan) &&
+ 		(((ForeignScan *) plan)->operation == CMD_UPDATE ||
+ 		 ((ForeignScan *) plan)->operation == CMD_DELETE))
+ 		return;
  
  	/* Set up deparsing context */
  	context = set_deparse_context_planstate(es->deparse_cxt,
***************
*** 2212,2219 **** show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es)
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (fdwroutine->ExplainForeignScan != NULL)
! 		fdwroutine->ExplainForeignScan(fsstate, es);
  }
  
  /*
--- 2235,2250 ----
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (((ForeignScan *) fsstate->ss.ps.plan)->operation != CMD_SELECT)
! 	{
! 		if (fdwroutine->ExplainDMLPushdown != NULL)
! 			fdwroutine->ExplainDMLPushdown(fsstate, es);
! 	}
! 	else
! 	{
! 		if (fdwroutine->ExplainForeignScan != NULL)
! 			fdwroutine->ExplainForeignScan(fsstate, es);
! 	}
  }
  
  /*
***************
*** 2599,2606 **** show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
  			}
  		}
  
! 		/* Give FDW a chance */
! 		if (fdwroutine && fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
--- 2630,2639 ----
  			}
  		}
  
! 		/* Give FDW a chance if needed */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			fdwroutine &&
! 			fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1011,1020 **** InitPlan(QueryDesc *queryDesc, int eflags)
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(Relation resultRel, CmdType operation)
  {
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
  
  	switch (resultRel->rd_rel->relkind)
  	{
--- 1011,1022 ----
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
  {
+ 	Relation	resultRel = resultRelInfo->ri_RelationDesc;
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
+ 	bool		allow_pushdown;
  
  	switch (resultRel->rd_rel->relkind)
  	{
***************
*** 1083,1096 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  		case RELKIND_FOREIGN_TABLE:
  			/* Okay only if the FDW supports it */
  			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
  			switch (operation)
  			{
  				case CMD_INSERT:
! 					if (fdwroutine->ExecForeignInsert == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 							errmsg("cannot insert into foreign table \"%s\"",
! 								   RelationGetRelationName(resultRel))));
  					if (fdwroutine->IsForeignRelUpdatable != NULL &&
  						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
  						ereport(ERROR,
--- 1085,1107 ----
  		case RELKIND_FOREIGN_TABLE:
  			/* Okay only if the FDW supports it */
  			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
+ 			allow_pushdown = ((fdwroutine->BeginDMLPushdown != NULL) &&
+ 							  (fdwroutine->IterateDMLPushdown != NULL) &&
+ 							  (fdwroutine->EndDMLPushdown != NULL));
  			switch (operation)
  			{
  				case CMD_INSERT:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down insert on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignInsert == NULL)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot insert into foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
  					if (fdwroutine->IsForeignRelUpdatable != NULL &&
  						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
  						ereport(ERROR,
***************
*** 1099,1105 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_UPDATE:
! 					if (fdwroutine->ExecForeignUpdate == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  								 errmsg("cannot update foreign table \"%s\"",
--- 1110,1122 ----
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_UPDATE:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down update on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignUpdate == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  								 errmsg("cannot update foreign table \"%s\"",
***************
*** 1112,1118 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_DELETE:
! 					if (fdwroutine->ExecForeignDelete == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  							errmsg("cannot delete from foreign table \"%s\"",
--- 1129,1141 ----
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_DELETE:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down delete on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignDelete == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  							errmsg("cannot delete from foreign table \"%s\"",
***************
*** 1245,1250 **** InitResultRelInfo(ResultRelInfo *resultRelInfo,
--- 1268,1274 ----
  	else
  		resultRelInfo->ri_FdwRoutine = NULL;
  	resultRelInfo->ri_FdwState = NULL;
+ 	resultRelInfo->ri_FdwPushdown = false;
  	resultRelInfo->ri_ConstraintExprs = NULL;
  	resultRelInfo->ri_junkFilter = NULL;
  	resultRelInfo->ri_projectReturning = NULL;
*** a/src/backend/executor/nodeForeignscan.c
--- b/src/backend/executor/nodeForeignscan.c
***************
*** 48,54 **** ForeignNext(ForeignScanState *node)
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
--- 48,57 ----
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	if (plan->operation != CMD_SELECT)
! 		slot = node->fdwroutine->IterateDMLPushdown(node);
! 	else
! 		slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
***************
*** 226,232 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
--- 229,238 ----
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	if (node->operation != CMD_SELECT)
! 		fdwroutine->BeginDMLPushdown(scanstate, eflags);
! 	else
! 		fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
***************
*** 240,247 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
  	/* Let the FDW shut down */
! 	node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
--- 246,258 ----
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
+ 	ForeignScan *plan = (ForeignScan *) node->ss.ps.plan;
+ 
  	/* Let the FDW shut down */
! 	if (plan->operation != CMD_SELECT)
! 		node->fdwroutine->EndDMLPushdown(node);
! 	else
! 		node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
*** a/src/backend/executor/nodeModifyTable.c
--- b/src/backend/executor/nodeModifyTable.c
***************
*** 1357,1362 **** ExecModifyTable(ModifyTableState *node)
--- 1357,1383 ----
  				break;
  		}
  
+ 		if (resultRelInfo->ri_FdwPushdown && resultRelInfo->ri_projectReturning)
+ 		{
+ 			ProjectionInfo *projectReturning = resultRelInfo->ri_projectReturning;
+ 			ExprContext *econtext = projectReturning->pi_exprContext;
+ 
+ 			/*
+ 			 * Reset per-tuple memory context to free any expression evaluation
+ 			 * storage allocated in the previous cycle.
+ 			 */
+ 			ResetExprContext(econtext);
+ 
+ 			/* Make any needed join variables available to ExecProject */
+ 			econtext->ecxt_outertuple = planSlot;
+ 
+ 			/* Compute the RETURNING expressions */
+ 			slot = ExecProject(resultRelInfo->ri_projectReturning, NULL);
+ 
+ 			estate->es_result_relation_info = saved_resultRelInfo;
+ 			return slot;
+ 		}
+ 
  		EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
  		slot = planSlot;
  
***************
*** 1536,1545 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  	{
  		subplan = (Plan *) lfirst(l);
  
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo->ri_RelationDesc, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
--- 1557,1569 ----
  	{
  		subplan = (Plan *) lfirst(l);
  
+ 		/* Initialize the FdwPushdown flag */
+ 		resultRelInfo->ri_FdwPushdown = list_nth_int(node->fdwPushdowns, i);
+ 
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
***************
*** 1560,1566 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
--- 1584,1591 ----
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
***************
*** 1731,1743 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1756,1777 ----
  		erm = ExecFindRowMark(estate, rc->rti, false);
  
  		/* build ExecAuxRowMark for each subplan */
+ 		resultRelInfo = mtstate->resultRelInfo;
  		for (i = 0; i < nplans; i++)
  		{
  			ExecAuxRowMark *aerm;
  
+ 			/* ignore subplan if the FDW pushes the command down */
+ 			if (resultRelInfo->ri_FdwPushdown)
+ 			{
+ 				resultRelInfo++;
+ 				continue;
+ 			}
+ 
  			subplan = mtstate->mt_plans[i]->plan;
  			aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
  			mtstate->mt_arowmarks[i] = lappend(mtstate->mt_arowmarks[i], aerm);
+ 			resultRelInfo++;
  		}
  	}
  
***************
*** 1793,1798 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1827,1839 ----
  			{
  				JunkFilter *j;
  
+ 				/* ignore subplan if the FDW pushes the command down */
+ 				if (resultRelInfo->ri_FdwPushdown)
+ 				{
+ 					resultRelInfo++;
+ 					continue;
+ 				}
+ 
  				subplan = mtstate->mt_plans[i]->plan;
  				if (operation == CMD_INSERT || operation == CMD_UPDATE)
  					ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
***************
*** 1887,1893 **** ExecEndModifyTable(ModifyTableState *node)
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
--- 1928,1935 ----
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 186,191 **** _copyModifyTable(const ModifyTable *from)
--- 186,192 ----
  	COPY_NODE_FIELD(withCheckOptionLists);
  	COPY_NODE_FIELD(returningLists);
  	COPY_NODE_FIELD(fdwPrivLists);
+ 	COPY_NODE_FIELD(fdwPushdowns);
  	COPY_NODE_FIELD(rowMarks);
  	COPY_SCALAR_FIELD(epqParam);
  	COPY_SCALAR_FIELD(onConflictAction);
***************
*** 645,650 **** _copyForeignScan(const ForeignScan *from)
--- 646,652 ----
  	/*
  	 * copy remainder of node
  	 */
+ 	COPY_SCALAR_FIELD(operation);
  	COPY_SCALAR_FIELD(fs_server);
  	COPY_NODE_FIELD(fdw_exprs);
  	COPY_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 340,345 **** _outModifyTable(StringInfo str, const ModifyTable *node)
--- 340,346 ----
  	WRITE_NODE_FIELD(withCheckOptionLists);
  	WRITE_NODE_FIELD(returningLists);
  	WRITE_NODE_FIELD(fdwPrivLists);
+ 	WRITE_NODE_FIELD(fdwPushdowns);
  	WRITE_NODE_FIELD(rowMarks);
  	WRITE_INT_FIELD(epqParam);
  	WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
***************
*** 591,596 **** _outForeignScan(StringInfo str, const ForeignScan *node)
--- 592,598 ----
  
  	_outScanInfo(str, (const Scan *) node);
  
+ 	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_OID_FIELD(fs_server);
  	WRITE_NODE_FIELD(fdw_exprs);
  	WRITE_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/readfuncs.c
--- b/src/backend/nodes/readfuncs.c
***************
*** 1471,1476 **** _readModifyTable(void)
--- 1471,1477 ----
  	READ_NODE_FIELD(withCheckOptionLists);
  	READ_NODE_FIELD(returningLists);
  	READ_NODE_FIELD(fdwPrivLists);
+ 	READ_NODE_FIELD(fdwPushdowns);
  	READ_NODE_FIELD(rowMarks);
  	READ_INT_FIELD(epqParam);
  	READ_ENUM_FIELD(onConflictAction, OnConflictAction);
*** a/src/backend/optimizer/plan/createplan.c
--- b/src/backend/optimizer/plan/createplan.c
***************
*** 3768,3773 **** make_foreignscan(List *qptlist,
--- 3768,3774 ----
  	plan->lefttree = outer_plan;
  	plan->righttree = NULL;
  	node->scan.scanrelid = scanrelid;
+ 	node->operation = CMD_SELECT;
  	/* fs_server will be filled in by create_foreignscan_plan */
  	node->fs_server = InvalidOid;
  	node->fdw_exprs = fdw_exprs;
***************
*** 5043,5048 **** make_modifytable(PlannerInfo *root,
--- 5044,5050 ----
  	Plan	   *plan = &node->plan;
  	double		total_size;
  	List	   *fdw_private_list;
+ 	List	   *fdwpushdown_list;
  	ListCell   *subnode;
  	ListCell   *lc;
  	int			i;
***************
*** 5123,5134 **** make_modifytable(PlannerInfo *root,
--- 5125,5138 ----
  	 * construct private plan data, and accumulate it all into a list.
  	 */
  	fdw_private_list = NIL;
+ 	fdwpushdown_list = NIL;
  	i = 0;
  	foreach(lc, resultRelations)
  	{
  		Index		rti = lfirst_int(lc);
  		FdwRoutine *fdwroutine;
  		List	   *fdw_private;
+ 		bool		fdwpushdown;
  
  		/*
  		 * If possible, we want to get the FdwRoutine from our RelOptInfo for
***************
*** 5156,5161 **** make_modifytable(PlannerInfo *root,
--- 5160,5173 ----
  		}
  
  		if (fdwroutine != NULL &&
+ 			fdwroutine->PlanDMLPushdown != NULL)
+ 			fdwpushdown = fdwroutine->PlanDMLPushdown(root, node, rti, i);
+ 		else
+ 			fdwpushdown = false;
+ 		fdwpushdown_list = lappend_int(fdwpushdown_list, fdwpushdown);
+ 
+ 		if (!fdwpushdown &&
+ 			fdwroutine != NULL &&
  			fdwroutine->PlanForeignModify != NULL)
  			fdw_private = fdwroutine->PlanForeignModify(root, node, rti, i);
  		else
***************
*** 5164,5169 **** make_modifytable(PlannerInfo *root,
--- 5176,5182 ----
  		i++;
  	}
  	node->fdwPrivLists = fdw_private_list;
+ 	node->fdwPushdowns = fdwpushdown_list;
  
  	return node;
  }
*** a/src/include/executor/executor.h
--- b/src/include/executor/executor.h
***************
*** 184,190 **** extern void ExecutorEnd(QueryDesc *queryDesc);
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(Relation resultRel, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
--- 184,190 ----
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
*** a/src/include/foreign/fdwapi.h
--- b/src/include/foreign/fdwapi.h
***************
*** 91,96 **** typedef TupleTableSlot *(*ExecForeignDelete_function) (EState *estate,
--- 91,108 ----
  typedef void (*EndForeignModify_function) (EState *estate,
  													   ResultRelInfo *rinfo);
  
+ typedef bool (*PlanDMLPushdown_function) (PlannerInfo *root,
+ 										  ModifyTable *plan,
+ 										  Index resultRelation,
+ 										  int subplan_index);
+ 
+ typedef void (*BeginDMLPushdown_function) (ForeignScanState *node,
+ 										   int eflags);
+ 
+ typedef TupleTableSlot *(*IterateDMLPushdown_function) (ForeignScanState *node);
+ 
+ typedef void (*EndDMLPushdown_function) (ForeignScanState *node);
+ 
  typedef int (*IsForeignRelUpdatable_function) (Relation rel);
  
  typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
***************
*** 110,115 **** typedef void (*ExplainForeignModify_function) (ModifyTableState *mtstate,
--- 122,130 ----
  														   int subplan_index,
  													struct ExplainState *es);
  
+ typedef void (*ExplainDMLPushdown_function) (ForeignScanState *node,
+ 													struct ExplainState *es);
+ 
  typedef int (*AcquireSampleRowsFunc) (Relation relation, int elevel,
  											   HeapTuple *rows, int targrows,
  												  double *totalrows,
***************
*** 161,166 **** typedef struct FdwRoutine
--- 176,185 ----
  	ExecForeignUpdate_function ExecForeignUpdate;
  	ExecForeignDelete_function ExecForeignDelete;
  	EndForeignModify_function EndForeignModify;
+ 	PlanDMLPushdown_function PlanDMLPushdown;
+ 	BeginDMLPushdown_function BeginDMLPushdown;
+ 	IterateDMLPushdown_function IterateDMLPushdown;
+ 	EndDMLPushdown_function EndDMLPushdown;
  	IsForeignRelUpdatable_function IsForeignRelUpdatable;
  
  	/* Functions for SELECT FOR UPDATE/SHARE row locking */
***************
*** 171,176 **** typedef struct FdwRoutine
--- 190,196 ----
  	/* Support functions for EXPLAIN */
  	ExplainForeignScan_function ExplainForeignScan;
  	ExplainForeignModify_function ExplainForeignModify;
+ 	ExplainDMLPushdown_function ExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	AnalyzeForeignTable_function AnalyzeForeignTable;
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 311,316 **** typedef struct JunkFilter
--- 311,317 ----
   *		TrigInstrument			optional runtime measurements for triggers
   *		FdwRoutine				FDW callback functions, if foreign table
   *		FdwState				available to save private state of FDW
+  *		FdwPushdown				true when the command is pushed down
   *		WithCheckOptions		list of WithCheckOption's to be checked
   *		WithCheckOptionExprs	list of WithCheckOption expr states
   *		ConstraintExprs			array of constraint-checking expr states
***************
*** 334,339 **** typedef struct ResultRelInfo
--- 335,341 ----
  	Instrumentation *ri_TrigInstrument;
  	struct FdwRoutine *ri_FdwRoutine;
  	void	   *ri_FdwState;
+ 	bool		ri_FdwPushdown;
  	List	   *ri_WithCheckOptions;
  	List	   *ri_WithCheckOptionExprs;
  	List	  **ri_ConstraintExprs;
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
***************
*** 188,193 **** typedef struct ModifyTable
--- 188,194 ----
  	List	   *withCheckOptionLists;	/* per-target-table WCO lists */
  	List	   *returningLists; /* per-target-table RETURNING tlists */
  	List	   *fdwPrivLists;	/* per-target-table FDW private data lists */
+ 	List	   *fdwPushdowns;	/* per-target-table FDW pushdown flags */
  	List	   *rowMarks;		/* PlanRowMarks (non-locking only) */
  	int			epqParam;		/* ID of Param for EvalPlanQual re-eval */
  	OnConflictAction onConflictAction;	/* ON CONFLICT action */
***************
*** 530,535 **** typedef struct WorkTableScan
--- 531,537 ----
  typedef struct ForeignScan
  {
  	Scan		scan;
+ 	CmdType		operation;		/* SELECT/UPDATE/DELETE */
  	Oid			fs_server;		/* OID of foreign server */
  	List	   *fdw_exprs;		/* expressions that FDW may evaluate */
  	List	   *fdw_private;	/* private data for FDW */

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 1003,1008 **** deparseReturningList(StringInfo buf, PlannerInfo *root,
--- 1003,1009 ----
  					 List **retrieved_attrs)
  {
  	Bitmapset  *attrs_used = NULL;
+ 	bool		has_returning = false;
  
  	if (trig_after_row)
  	{
***************
*** 1021,1031 **** deparseReturningList(StringInfo buf, PlannerInfo *root,
--- 1022,1072 ----
  					   &attrs_used);
  	}
  
+ 	/*
+ 	 * Check to see whether the remote query has a RETURNING clause.
+ 	 *
+ 	 * XXX be careful to keep this in sync with deparseTargetList.
+ 	 */
  	if (attrs_used != NULL)
  	{
+ 		if (bms_is_member(SelfItemPointerAttributeNumber - FirstLowInvalidHeapAttributeNumber,
+ 						  attrs_used))
+ 			has_returning = true;
+ 		else
+ 		{
+ 			TupleDesc	tupdesc = RelationGetDescr(rel);
+ 			bool		have_wholerow;
+ 			int			i;
+ 
+ 			/* If there's a whole-row reference, we'll need all the columns. */
+ 			have_wholerow = bms_is_member(0 - FirstLowInvalidHeapAttributeNumber,
+ 										  attrs_used);
+ 
+ 			for (i = 1; i <= tupdesc->natts; i++)
+ 			{
+ 				Form_pg_attribute attr = tupdesc->attrs[i - 1];
+ 
+ 				/* Ignore dropped attributes. */
+ 				if (attr->attisdropped)
+ 					continue;
+ 
+ 				if (have_wholerow ||
+ 					bms_is_member(i - FirstLowInvalidHeapAttributeNumber,
+ 								  attrs_used))
+ 				{
+ 					has_returning = true;
+ 					break;
+ 				}
+ 			}
+ 		}
+ 	}
+ 
+ 	if (has_returning != false)
+ 	{
  		appendStringInfoString(buf, " RETURNING ");
  		deparseTargetList(buf, root, rtindex, rel, attrs_used,
  						  retrieved_attrs);
+ 		Assert(*retrieved_attrs != NIL);
  	}
  	else
  		*retrieved_attrs = NIL;
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 2408,2413 **** SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
--- 2408,2466 ----
   1104 | 204 | ddd                | 
  (819 rows)
  
+ EXPLAIN (verbose, costs off)
+ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+                                                                                            QUERY PLAN                                                                                            
+ -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Insert on public.ft2
+    Output: (tableoid)::regclass
+    Remote SQL: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6, c7, c8) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+    ->  Result
+          Output: 9999, 999, NULL::integer, 'foo'::text, NULL::timestamp with time zone, NULL::timestamp without time zone, NULL::character varying, 'ft2       '::character(10), NULL::user_enum
+ (5 rows)
+ 
+ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+  tableoid 
+ ----------
+  ft2
+ (1 row)
+ 
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+                                                     QUERY PLAN                                                     
+ -------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: (tableoid)::regclass
+    Remote SQL: UPDATE "S 1"."T 1" SET c3 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, 'bar'::text, c4, c5, c6, c7, c8, ctid
+          Remote SQL: SELECT "C 1", c2, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
+ (6 rows)
+ 
+ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+  tableoid 
+ ----------
+  ft2
+ (1 row)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+                                      QUERY PLAN                                     
+ ------------------------------------------------------------------------------------
+  Delete on public.ft2
+    Output: (tableoid)::regclass
+    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: ctid
+          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
+ (6 rows)
+ 
+ DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+  tableoid 
+ ----------
+  ft2
+ (1 row)
+ 
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 413,418 **** EXPLAIN (verbose, costs off)
--- 413,427 ----
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+ EXPLAIN (verbose, costs off)
+ DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+ DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
*** a/src/backend/executor/nodeModifyTable.c
--- b/src/backend/executor/nodeModifyTable.c
***************
*** 308,313 **** ExecInsert(ModifyTableState *mtstate,
--- 308,319 ----
  		/* FDW might have changed tuple */
  		tuple = ExecMaterializeSlot(slot);
  
+ 		/*
+ 		 * AFTER ROW Triggers or RETURNING expressions might reference the
+ 		 * tableoid column, so initialize t_tableOid before evaluating them.
+ 		 */
+ 		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
+ 
  		newId = InvalidOid;
  	}
  	else
***************
*** 561,566 **** ExecDelete(ItemPointer tupleid,
--- 567,574 ----
  	}
  	else if (resultRelInfo->ri_FdwRoutine)
  	{
+ 		HeapTuple	tuple;
+ 
  		/*
  		 * delete from foreign table: let the FDW do it
  		 *
***************
*** 579,584 **** ExecDelete(ItemPointer tupleid,
--- 587,601 ----
  
  		if (slot == NULL)		/* "do nothing" */
  			return NULL;
+ 
+ 		/*
+ 		 * RETURNING expressions might reference the tableoid column, so
+ 		 * initialize t_tableOid before evaluating them.
+ 		 */
+ 		if (slot->tts_isempty)
+ 			ExecStoreAllNullTuple(slot);
+ 		tuple = ExecMaterializeSlot(slot);
+ 		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
  	}
  	else
  	{
***************
*** 838,843 **** ExecUpdate(ItemPointer tupleid,
--- 855,866 ----
  
  		/* FDW might have changed tuple */
  		tuple = ExecMaterializeSlot(slot);
+ 
+ 		/*
+ 		 * AFTER ROW Triggers or RETURNING expressions might reference the
+ 		 * tableoid column, so initialize t_tableOid before evaluating them.
+ 		 */
+ 		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
  	}
  	else
  	{

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 816,822 **** deparseTargetList(StringInfo buf,
   *
   * If params is not NULL, it receives a list of Params and other-relation Vars
   * used in the clauses; these values must be transmitted to the remote server
!  * as parameter values.
   *
   * If params is NULL, we're generating the query for EXPLAIN purposes,
   * so Params and other-relation Vars should be replaced by dummy values.
--- 816,822 ----
   *
   * If params is not NULL, it receives a list of Params and other-relation Vars
   * used in the clauses; these values must be transmitted to the remote server
!  * as parameter values.  Caller is responsible for initializing it to empty.
   *
   * If params is NULL, we're generating the query for EXPLAIN purposes,
   * so Params and other-relation Vars should be replaced by dummy values.
***************
*** 833,841 **** appendWhereClause(StringInfo buf,
  	int			nestlevel;
  	ListCell   *lc;
  
- 	if (params)
- 		*params = NIL;			/* initialize result list to empty */
- 
  	/* Set up context struct for recursion */
  	context.root = root;
  	context.foreignrel = baserel;
--- 833,838 ----
***************
*** 971,976 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 968,1030 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*targetlist,
+ 						   List *targetAttrs,
+ 						   List	*remote_conds,
+ 						   List **params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	deparse_expr_cxt context;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	if (params_list)
+ 		*params_list = NIL;		/* initialize result list to empty */
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = params_list;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfoString(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 993,998 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 1047,1082 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*remote_conds,
+ 						   List	**params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 
+ 	if (params_list)
+ 		*params_list = NIL;		/* initialize result list to empty */
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 1314,1320 **** INSERT INTO ft2 (c1,c2,c3)
--- 1314,1339 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (3 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1424,1430 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1443,1449 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1445,1460 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1464,1477 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1565,1571 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1582,1588 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2408,2413 **** SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
--- 2425,2498 ----
   1104 | 204 | ddd                | 
  (819 rows)
  
+ INSERT INTO ft2 (c1,c2,c3)
+   VALUES (1201,1201,'aaa'), (1202,1202,'bbb'), (1203,1203,'ccc') RETURNING *;
+   c1  |  c2  | c3  | c4 | c5 | c6 |     c7     | c8 
+ ------+------+-----+----+----+----+------------+----
+  1201 | 1201 | aaa |    |    |    | ft2        | 
+  1202 | 1202 | bbb |    |    |    | ft2        | 
+  1203 | 1203 | ccc |    |    |    | ft2        | 
+ (3 rows)
+ 
+ INSERT INTO ft2 (c1,c2,c3) VALUES (1204,1204,'ddd'), (1205,1205,'eee');
+ PREPARE mt1(int, int, text) AS UPDATE ft2 SET c2 = c2 + $2, c3 = c3 || $3 WHERE c1 % 10 = $1;            -- can be pushed down
+ EXPLAIN (verbose, costs off) EXECUTE mt1(1, 0, '_update1');
+                                                      QUERY PLAN                                                     
+ --------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 0), c3 = (c3 || '_update1'::text) WHERE ((("C 1" % 10) = 1))
+ (3 rows)
+ 
+ EXECUTE mt1(1, 0, '_update1');
+ PREPARE mt2(int) AS DELETE FROM ft2 WHERE c1 = $1 RETURNING c1, c2, c3;             -- can be pushed down
+ EXPLAIN (verbose, costs off) EXECUTE mt2(1201);
+                                          QUERY PLAN                                         
+ --------------------------------------------------------------------------------------------
+  Delete on public.ft2
+    Output: c1, c2, c3
+    ->  Foreign Delete on public.ft2
+          Remote SQL: DELETE FROM "S 1"."T 1" WHERE (("C 1" = 1201)) RETURNING "C 1", c2, c3
+ (4 rows)
+ 
+ EXECUTE mt2(1201);
+   c1  |  c2  |     c3      
+ ------+------+-------------
+  1201 | 1201 | aaa_update1
+ (1 row)
+ 
+ PREPARE mt3(int) AS DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft2.c2 > $1 RETURNING ft2.*;     -- can't be pushed down
+ EXPLAIN (verbose, costs off) EXECUTE mt3(1201);
+                                             QUERY PLAN                                             
+ ---------------------------------------------------------------------------------------------------
+  Delete on public.ft2
+    Output: ft2.c1, ft2.c2, ft2.c3, ft2.c4, ft2.c5, ft2.c6, ft2.c7, ft2.c8
+    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+    ->  Hash Join
+          Output: ft2.ctid, ft1.*
+          Hash Cond: (ft1.c1 = ft2.c2)
+          ->  Foreign Scan on public.ft1
+                Output: ft1.*, ft1.c1
+                Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1"
+          ->  Hash
+                Output: ft2.ctid, ft2.c2
+                ->  Foreign Scan on public.ft2
+                      Output: ft2.ctid, ft2.c2
+                      Remote SQL: SELECT c2, ctid FROM "S 1"."T 1" WHERE ((c2 > 1201)) FOR UPDATE
+ (14 rows)
+ 
+ EXECUTE mt3(1201);
+   c1  |  c2  | c3  | c4 | c5 | c6 |     c7     | c8 
+ ------+------+-----+----+----+----+------------+----
+  1202 | 1202 | bbb |    |    |    | ft2        | 
+  1203 | 1203 | ccc |    |    |    | ft2        | 
+  1204 | 1204 | ddd |    |    |    | ft2        | 
+  1205 | 1205 | eee |    |    |    | ft2        | 
+ (4 rows)
+ 
+ DEALLOCATE mt1;
+ DEALLOCATE mt2;
+ DEALLOCATE mt3;
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
***************
*** 2553,2560 **** DETAIL:  Failing row contains (1111, -2, null, null, null, null, ft1       , nul
  CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6, c7, c8) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
! DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2638,2645 ----
  CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6, c7, c8) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
! DETAIL:  Failing row contains (1, -1, 00001_update1_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2713,2719 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2798,2804 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2852,2859 **** DETAIL:  Failing row contains (1111, -2, null, null, null, null, ft1       , nul
  CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6, c7, c8) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
! DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
--- 2937,2944 ----
  CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6, c7, c8) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
! DETAIL:  Failing row contains (1, -1, 00001_update1_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
***************
*** 3246,3251 **** NOTICE:  NEW: (13,"test triggered !")
--- 3331,3529 ----
   (0,27)
  (1 row)
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ -- Test DML pushdown functionality
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_before ON rem1;
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_after ON rem1;
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_update ON rem1;
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                   QUERY PLAN                                   
+ -------------------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_update ON rem1;
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                                QUERY PLAN                               
+ ------------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_after_delete ON rem1;
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
***************
*** 3715,3720 **** fetch from c;
--- 3993,4048 ----
  update bar set f2 = null where current of c;
  ERROR:  WHERE CURRENT OF is not supported for this table type
  rollback;
+ explain (verbose, costs off)
+ delete from foo where f1 < 5 returning *;
+                                    QUERY PLAN                                   
+ --------------------------------------------------------------------------------
+  Delete on public.foo
+    Output: foo.f1, foo.f2
+    Delete on public.foo
+    Foreign Delete on public.foo2
+    ->  Index Scan using i_foo_f1 on public.foo
+          Output: foo.ctid
+          Index Cond: (foo.f1 < 5)
+    ->  Foreign Delete on public.foo2
+          Remote SQL: DELETE FROM public.loct1 WHERE ((f1 < 5)) RETURNING f1, f2
+ (9 rows)
+ 
+ delete from foo where f1 < 5 returning *;
+  f1 | f2 
+ ----+----
+   1 |  1
+   3 |  3
+   0 |  0
+   2 |  2
+   4 |  4
+ (5 rows)
+ 
+ explain (verbose, costs off)
+ update bar set f2 = f2 + 100 returning *;
+                                   QUERY PLAN                                  
+ ------------------------------------------------------------------------------
+  Update on public.bar
+    Output: bar.f1, bar.f2
+    Update on public.bar
+    Foreign Update on public.bar2
+    ->  Seq Scan on public.bar
+          Output: bar.f1, (bar.f2 + 100), bar.ctid
+    ->  Foreign Update on public.bar2
+          Remote SQL: UPDATE public.loct2 SET f2 = (f2 + 100) RETURNING f1, f2
+ (8 rows)
+ 
+ update bar set f2 = f2 + 100 returning *;
+  f1 | f2  
+ ----+-----
+   1 | 311
+   2 | 322
+   6 | 266
+   3 | 333
+   4 | 344
+   7 | 277
+ (6 rows)
+ 
  drop table foo cascade;
  NOTICE:  drop cascades to foreign table foo2
  drop table bar cascade;
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 32,37 ****
--- 32,38 ----
  #include "optimizer/restrictinfo.h"
  #include "optimizer/var.h"
  #include "parser/parsetree.h"
+ #include "rewrite/rewriteHandler.h"
  #include "utils/builtins.h"
  #include "utils/guc.h"
  #include "utils/lsyscache.h"
***************
*** 57,63 **** PG_MODULE_MAGIC;
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
--- 58,65 ----
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) List of restriction clauses that can be executed remotely
!  * 3) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
***************
*** 67,72 **** enum FdwScanPrivateIndex
--- 69,76 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
+ 	/* List of restriction clauses that can be executed remotely */
+ 	FdwScanPrivateRemoteConds,
  	/* Integer list of attribute numbers retrieved by the SELECT */
  	FdwScanPrivateRetrievedAttrs
  };
***************
*** 94,99 **** enum FdwModifyPrivateIndex
--- 98,125 ----
  };
  
  /*
+  * Similarly, this enum describes what's kept in the fdw_private list for
+  * a ForeignScan node that has pushed down an UPDATE/DELETE to the remote
+  * server.  We store:
+  *
+  * 1) UPDATE/DELETE statement text to be sent to the remote server
+  * 2) Boolean flag showing if the remote query has a RETURNING clause
+  * 3) Integer list of attribute numbers retrieved by RETURNING, if any
+  * 4) Boolean flag showing if we set the command es_processed
+  */
+ enum FdwDmlPushdownPrivateIndex
+ {
+ 	/* SQL statement to execute remotely (as a String node) */
+ 	FdwDmlPushdownPrivateUpdateSql,
+ 	/* has-returning flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateHasReturning,
+ 	/* Integer list of attribute numbers retrieved by RETURNING */
+ 	FdwDmlPushdownPrivateRetrievedAttrs,
+ 	/* set-processed flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateSetProcessed
+ };
+ 
+ /*
   * Execution state of a foreign scan using postgres_fdw.
   */
  typedef struct PgFdwScanState
***************
*** 156,161 **** typedef struct PgFdwModifyState
--- 182,217 ----
  } PgFdwModifyState;
  
  /*
+  * Execution state of a pushed-down update/delete operation.
+  */
+ typedef struct PgFdwDmlPushdownState
+ {
+ 	Relation	rel;			/* relcache entry for the foreign table */
+ 	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
+ 
+ 	/* extracted fdw_private data */
+ 	char	   *query;			/* text of UPDATE/DELETE command */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
+ 	List	   *retrieved_attrs;	/* attr numbers retrieved by RETURNING */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 
+ 	/* for remote query execution */
+ 	PGconn	   *conn;			/* connection for the scan */
+ 	int			numParams;		/* number of parameters passed to query */
+ 	FmgrInfo   *param_flinfo;	/* output conversion functions for them */
+ 	List	   *param_exprs;	/* executable expressions for param values */
+ 	const char **param_values;	/* textual values of query parameters */
+ 
+ 	/* for storing result tuples */
+ 	PGresult   *result;			/* result for query */
+ 	int			num_tuples;		/* # of result tuples */
+ 	int			next_tuple;		/* index of next one to return */
+ 
+ 	/* working memory contexts */
+ 	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
+ } PgFdwDmlPushdownState;
+ 
+ /*
   * Workspace for analyzing a foreign table.
   */
  typedef struct PgFdwAnalyzeState
***************
*** 247,252 **** static TupleTableSlot *postgresExecForeignDelete(EState *estate,
--- 303,315 ----
  static void postgresEndForeignModify(EState *estate,
  						 ResultRelInfo *resultRelInfo);
  static int	postgresIsForeignRelUpdatable(Relation rel);
+ static bool postgresPlanDMLPushdown(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index);
+ static void postgresBeginDMLPushdown(ForeignScanState *node, int eflags);
+ static TupleTableSlot *postgresIterateDMLPushdown(ForeignScanState *node);
+ static void postgresEndDMLPushdown(ForeignScanState *node);
  static void postgresExplainForeignScan(ForeignScanState *node,
  						   ExplainState *es);
  static void postgresExplainForeignModify(ModifyTableState *mtstate,
***************
*** 254,259 **** static void postgresExplainForeignModify(ModifyTableState *mtstate,
--- 317,324 ----
  							 List *fdw_private,
  							 int subplan_index,
  							 ExplainState *es);
+ static void postgresExplainDMLPushdown(ForeignScanState *node,
+ 						   ExplainState *es);
  static bool postgresAnalyzeForeignTable(Relation relation,
  							AcquireSampleRowsFunc *func,
  							BlockNumber *totalpages);
***************
*** 290,295 **** static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
--- 355,368 ----
  						 TupleTableSlot *slot);
  static void store_returning_result(PgFdwModifyState *fmstate,
  					   TupleTableSlot *slot, PGresult *res);
+ static bool dml_is_pushdown_safe(PlannerInfo *root,
+ 								 ModifyTable *plan,
+ 								 Index resultRelation,
+ 								 int subplan_index,
+ 								 Relation rel,
+ 								 List *targetAttrs);
+ static void execute_dml_stmt(ForeignScanState *node);
+ static TupleTableSlot *get_returning_data(ForeignScanState *node);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 332,341 **** postgres_fdw_handler(PG_FUNCTION_ARGS)
--- 405,419 ----
  	routine->ExecForeignDelete = postgresExecForeignDelete;
  	routine->EndForeignModify = postgresEndForeignModify;
  	routine->IsForeignRelUpdatable = postgresIsForeignRelUpdatable;
+ 	routine->PlanDMLPushdown = postgresPlanDMLPushdown;
+ 	routine->BeginDMLPushdown = postgresBeginDMLPushdown;
+ 	routine->IterateDMLPushdown = postgresIterateDMLPushdown;
+ 	routine->EndDMLPushdown = postgresEndDMLPushdown;
  
  	/* Support functions for EXPLAIN */
  	routine->ExplainForeignScan = postgresExplainForeignScan;
  	routine->ExplainForeignModify = postgresExplainForeignModify;
+ 	routine->ExplainDMLPushdown = postgresExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	routine->AnalyzeForeignTable = postgresAnalyzeForeignTable;
***************
*** 1067,1073 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make2(makeString(sql.data),
  							 retrieved_attrs);
  
  	/*
--- 1145,1152 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make3(makeString(sql.data),
! 							 remote_conds,
  							 retrieved_attrs);
  
  	/*
***************
*** 1363,1375 **** postgresAddForeignUpdateTargets(Query *parsetree,
  /*
   * postgresPlanForeignModify
   *		Plan an insert/update/delete operation on a foreign table
-  *
-  * Note: currently, the plan tree generated for UPDATE/DELETE will always
-  * include a ForeignScan that retrieves ctids (using SELECT FOR UPDATE)
-  * and then the ModifyTable node will have to execute individual remote
-  * UPDATE/DELETE commands.  If there are no local conditions or joins
-  * needed, it'd be better to let the scan node do UPDATE/DELETE RETURNING
-  * and then do nothing at ModifyTable.  Room for future optimization ...
   */
  static List *
  postgresPlanForeignModify(PlannerInfo *root,
--- 1442,1447 ----
***************
*** 1882,1887 **** postgresIsForeignRelUpdatable(Relation rel)
--- 1954,2274 ----
  }
  
  /*
+  * postgresPlanDMLPushdown
+  *		Consider pushing down a foreign table modification to the remote server
+  */
+ static bool
+ postgresPlanDMLPushdown(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index)
+ {
+ 	CmdType		operation = plan->operation;
+ 	RangeTblEntry *rte = planner_rt_fetch(resultRelation, root);
+ 	Relation	rel;
+ 	StringInfoData sql;
+ 	List	   *targetAttrs = NIL;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 	ForeignScan *fscan;
+ 	List	   *remote_conds;
+ 	List	   *params_list = NIL;
+ 
+ 	/*
+ 	 * We don't currently support pushing down an insert to the remote server
+ 	 */
+ 	if (operation == CMD_INSERT)
+ 		return false;
+ 
+ 	initStringInfo(&sql);
+ 
+ 	/*
+ 	 * Core code already has some lock on each rel being planned, so we can
+ 	 * use NoLock here.
+ 	 */
+ 	rel = heap_open(rte->relid, NoLock);
+ 
+ 	/*
+ 	 * In an UPDATE, we transmit only columns that were explicitly targets
+ 	 * of the UPDATE, so as to avoid unnecessary data transmission.
+ 	 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		int			col;
+ 
+ 		col = -1;
+ 		while ((col = bms_next_member(rte->updatedCols, col)) >= 0)
+ 		{
+ 			/* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
+ 			AttrNumber	attno = col + FirstLowInvalidHeapAttributeNumber;
+ 
+ 			if (attno <= InvalidAttrNumber)		/* shouldn't happen */
+ 				elog(ERROR, "system-column update is not supported");
+ 			targetAttrs = lappend_int(targetAttrs, attno);
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Ok, check to see whether the query is safe to push down.
+ 	 */
+ 	if (!dml_is_pushdown_safe(root, plan,
+ 							  resultRelation,
+ 							  subplan_index,
+ 							  rel, targetAttrs))
+ 	{
+ 		heap_close(rel, NoLock);
+ 		return false;
+ 	}
+ 
+ 	/*
+ 	 * Ok, modify subplan to push down the query.
+ 	 */
+ 	fscan = (ForeignScan *) list_nth(plan->plans, subplan_index);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	switch (operation)
+ 	{
+ 		case CMD_UPDATE:
+ 			deparsePushedDownUpdateSql(&sql, root, resultRelation, rel,
+ 									   ((Plan *) fscan)->targetlist,
+ 									   targetAttrs,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		case CMD_DELETE:
+ 			deparsePushedDownDeleteSql(&sql, root, resultRelation, rel,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		default:
+ 			elog(ERROR, "unexpected operation: %d", (int) operation);
+ 			break;
+ 	}
+ 
+ 	/*
+ 	 * Update the operation info.
+ 	 */
+ 	fscan->operation = operation;
+ 
+ 	/*
+ 	 * Update the fdw_exprs list that will be available to the executor.
+ 	 */
+ 	fscan->fdw_exprs = params_list;
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwDmlPushdownPrivateIndex, above.
+ 	 */
+ 	fscan->fdw_private = list_make4(makeString(sql.data),
+ 									makeInteger((retrieved_attrs != NIL)),
+ 									retrieved_attrs,
+ 									makeInteger(plan->canSetTag));
+ 
+ 	/*
+ 	 * RETURNING expressions might reference the tableoid column, so initialize
+ 	 * t_tableOid before evaluating them (see ForeignNext).
+ 	 */
+ 	Assert(fscan->fsSystemCol);
+ 
+ 	heap_close(rel, NoLock);
+ 	return true;
+ }
+ 
+ /*
+  * postgresBeginDMLPushdown
+  *		Initiate pushing down a foreign table modification to the remote server
+  */
+ static void
+ postgresBeginDMLPushdown(ForeignScanState *node, int eflags)
+ {
+ 	ForeignScan *fsplan = (ForeignScan *) node->ss.ps.plan;
+ 	EState	   *estate = node->ss.ps.state;
+ 	PgFdwDmlPushdownState *dpstate;
+ 	RangeTblEntry *rte;
+ 	Oid			userid;
+ 	ForeignTable *table;
+ 	ForeignServer *server;
+ 	UserMapping *user;
+ 	int			numParams;
+ 	int			i;
+ 	ListCell   *lc;
+ 
+ 	/*
+ 	 * Do nothing in EXPLAIN (no ANALYZE) case.  node->fdw_state stays NULL.
+ 	 */
+ 	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
+ 		return;
+ 
+ 	/*
+ 	 * We'll save private state in node->fdw_state.
+ 	 */
+ 	dpstate = (PgFdwDmlPushdownState *) palloc0(sizeof(PgFdwDmlPushdownState));
+ 	node->fdw_state = (void *) dpstate;
+ 
+ 	/*
+ 	 * Identify which user to do the remote access as.  This should match what
+ 	 * ExecCheckRTEPerms() does.
+ 	 */
+ 	rte = rt_fetch(fsplan->scan.scanrelid, estate->es_range_table);
+ 	userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
+ 
+ 	/* Get info about foreign table. */
+ 	dpstate->rel = node->ss.ss_currentRelation;
+ 	table = GetForeignTable(RelationGetRelid(dpstate->rel));
+ 	server = GetForeignServer(table->serverid);
+ 	user = GetUserMapping(userid, server->serverid);
+ 
+ 	/*
+ 	 * Get connection to the foreign server.  Connection manager will
+ 	 * establish new connection if necessary.
+ 	 */
+ 	dpstate->conn = GetConnection(server, user, false);
+ 
+ 	/* Initialize state variable */
+ 	dpstate->num_tuples = -1;		/* -1 means not set yet */
+ 
+ 	/* Get private info created by planner functions. */
+ 	dpstate->query = strVal(list_nth(fsplan->fdw_private,
+ 									 FdwDmlPushdownPrivateUpdateSql));
+ 	dpstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateHasReturning));
+ 	dpstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 										FdwDmlPushdownPrivateRetrievedAttrs);
+ 	dpstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateSetProcessed));
+ 
+ 	/* Create context for per-tuple temp workspace. */
+ 	dpstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
+ 											  "postgres_fdw temporary data",
+ 											  ALLOCSET_SMALL_MINSIZE,
+ 											  ALLOCSET_SMALL_INITSIZE,
+ 											  ALLOCSET_SMALL_MAXSIZE);
+ 
+ 	/* Prepare for input conversion of RETURNING results. */
+ 	if (dpstate->has_returning)
+ 		dpstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(dpstate->rel));
+ 
+ 	/* Prepare for output conversion of parameters used in remote query. */
+ 	numParams = list_length(fsplan->fdw_exprs);
+ 	dpstate->numParams = numParams;
+ 	dpstate->param_flinfo = (FmgrInfo *) palloc0(sizeof(FmgrInfo) * numParams);
+ 
+ 	i = 0;
+ 	foreach(lc, fsplan->fdw_exprs)
+ 	{
+ 		Node	   *param_expr = (Node *) lfirst(lc);
+ 		Oid			typefnoid;
+ 		bool		isvarlena;
+ 
+ 		getTypeOutputInfo(exprType(param_expr), &typefnoid, &isvarlena);
+ 		fmgr_info(typefnoid, &dpstate->param_flinfo[i]);
+ 		i++;
+ 	}
+ 
+ 	/*
+ 	 * Prepare remote-parameter expressions for evaluation.  (Note: in
+ 	 * practice, we expect that all these expressions will be just Params, so
+ 	 * we could possibly do something more efficient than using the full
+ 	 * expression-eval machinery for this.  But probably there would be little
+ 	 * benefit, and it'd require postgres_fdw to know more than is desirable
+ 	 * about Param evaluation.)
+ 	 */
+ 	dpstate->param_exprs = (List *)
+ 		ExecInitExpr((Expr *) fsplan->fdw_exprs,
+ 					 (PlanState *) node);
+ 
+ 	/*
+ 	 * Allocate buffer for text form of query parameters, if any.
+ 	 */
+ 	if (numParams > 0)
+ 		dpstate->param_values = (const char **) palloc0(numParams * sizeof(char *));
+ 	else
+ 		dpstate->param_values = NULL;
+ }
+ 
+ /*
+  * postgresIterateDMLPushdown
+  *		Execute pushing down a foreign table modification to the remote server
+  */
+ static TupleTableSlot *
+ postgresIterateDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 
+ 	/*
+ 	 * If this is the first call after Begin, execute the statement.
+ 	 */
+ 	if (dpstate->num_tuples == -1)
+ 		execute_dml_stmt(node);
+ 
+ 	/*
+ 	 * If the local query doesn't specify RETURNING, just clear tuple slot.
+ 	 */
+ 	if (!resultRelInfo->ri_projectReturning)
+ 	{
+ 		TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 		Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 		Assert(!dpstate->has_returning);
+ 
+ 		/* Increment the command es_processed count if necessary. */
+ 		if (dpstate->set_processed)
+ 			estate->es_processed += dpstate->num_tuples;
+ 
+ 		/* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
+ 		if (instr)
+ 			instr->tuplecount += dpstate->num_tuples;
+ 
+ 		return ExecClearTuple(slot);
+ 	}
+ 
+ 	/*
+ 	 * Get the next RETURNING tuple.
+ 	 */
+ 	return get_returning_data(node);
+ }
+ 
+ /*
+  * postgresEndDMLPushdown
+  *		Finish pushing down a foreign table modification to the remote server
+  */
+ static void
+ postgresEndDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 
+ 	/* if dpstate is NULL, we are in EXPLAIN; nothing to do */
+ 	if (dpstate == NULL)
+ 		return;
+ 
+ 	/* Release PGresult */
+ 	if (dpstate->result)
+ 		PQclear(dpstate->result);
+ 
+ 	/* Release remote connection */
+ 	ReleaseConnection(dpstate->conn);
+ 	dpstate->conn = NULL;
+ 
+ 	/* MemoryContexts will be deleted automatically. */
+ }
+ 
+ /*
   * postgresExplainForeignScan
   *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
   */
***************
*** 1919,1924 **** postgresExplainForeignModify(ModifyTableState *mtstate,
--- 2306,2330 ----
  	}
  }
  
+ /*
+  * postgresExplainDMLPushdown
+  *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
+  *		that has pushed down an UPDATE/DELETE to the remote server
+  */
+ static void
+ postgresExplainDMLPushdown(ForeignScanState *node, ExplainState *es)
+ {
+ 	List	   *fdw_private;
+ 	char	   *sql;
+ 
+ 	if (es->verbose)
+ 	{
+ 		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
+ 		sql = strVal(list_nth(fdw_private, FdwDmlPushdownPrivateUpdateSql));
+ 		ExplainPropertyText("Remote SQL", sql, es);
+ 	}
+ }
+ 
  
  /*
   * estimate_path_cost_size
***************
*** 2535,2540 **** store_returning_result(PgFdwModifyState *fmstate,
--- 2941,3134 ----
  }
  
  /*
+  * Check to see whether it's safe to push down an UPDATE/DELETE to the remote
+  * server
+  *
+  * Conditions checked here:
+  *
+  * 1. If there are any local joins needed, we mustn't push the command down,
+  * because that breaks execution of the joins.
+  *
+  * 2. If there are any quals that can't be evaluated remotely, we mustn't push
+  * the command down, because that breaks evaluation of the quals.
+  *
+  * 3. If the target relation has any row-level local triggers, we mustn't push
+  * the command down, because that breaks execution of the triggers.
+  *
+  * 4. We can't push an UPDATE down, if any expressions to assign to the target
+  * columns are unsafe to evaluate on the remote server.
+  */
+ static bool
+ dml_is_pushdown_safe(PlannerInfo *root,
+ 					 ModifyTable *plan,
+ 					 Index resultRelation,
+ 					 int subplan_index,
+ 					 Relation rel,
+ 					 List *targetAttrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	CmdType		operation = plan->operation;
+ 	ListCell   *lc;
+ 
+ 	Assert(operation == CMD_UPDATE || operation == CMD_DELETE);
+ 
+ 	/* Check point 1 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (relation_has_row_triggers(rel, operation))
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(subplan->targetlist,
+ 											attnum);
+ 
+ 		if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 			return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ /*
+  * Execute the pushed-down UPDATE/DELETE statement.
+  */
+ static void
+ execute_dml_stmt(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	ExprContext *econtext = node->ss.ps.ps_ExprContext;
+ 	int			numParams = dpstate->numParams;
+ 	const char **values = dpstate->param_values;
+ 
+ 	/*
+ 	 * Construct array of query parameter values in text format.
+ 	 */
+ 	if (numParams > 0)
+ 	{
+ 		int			nestlevel;
+ 		int			i;
+ 		ListCell   *lc;
+ 
+ 		nestlevel = set_transmission_modes();
+ 
+ 		i = 0;
+ 		foreach(lc, dpstate->param_exprs)
+ 		{
+ 			ExprState  *expr_state = (ExprState *) lfirst(lc);
+ 			Datum		expr_value;
+ 			bool		isNull;
+ 
+ 			/* Evaluate the parameter expression */
+ 			expr_value = ExecEvalExpr(expr_state, econtext, &isNull, NULL);
+ 
+ 			/*
+ 			 * Get string representation of each parameter value by invoking
+ 			 * type-specific output function, unless the value is null.
+ 			 */
+ 			if (isNull)
+ 				values[i] = NULL;
+ 			else
+ 				values[i] = OutputFunctionCall(&dpstate->param_flinfo[i],
+ 											   expr_value);
+ 			i++;
+ 		}
+ 
+ 		reset_transmission_modes(nestlevel);
+ 	}
+ 
+ 	/*
+ 	 * Notice that we pass NULL for paramTypes, thus forcing the remote server
+ 	 * to infer types for all parameters.  Since we explicitly cast every
+ 	 * parameter (see deparse.c), the "inference" is trivial and will produce
+ 	 * the desired result.  This allows us to avoid assuming that the remote
+ 	 * server has the same OIDs we do for the parameters' types.
+ 	 *
+ 	 * We don't use a PG_TRY block here, so be careful not to throw error
+ 	 * without releasing the PGresult.
+ 	 */
+ 	dpstate->result = PQexecParams(dpstate->conn, dpstate->query,
+ 								   numParams, NULL, values, NULL, NULL, 0);
+ 	if (PQresultStatus(dpstate->result) !=
+ 		(dpstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 		pgfdw_report_error(ERROR, dpstate->result, dpstate->conn, true,
+ 						   dpstate->query);
+ 
+ 	/* Get the number of rows affected. */
+ 	if (dpstate->has_returning)
+ 		dpstate->num_tuples = PQntuples(dpstate->result);
+ 	else
+ 		dpstate->num_tuples = atoi(PQcmdTuples(dpstate->result));
+ }
+ 
+ /*
+  * Get the result of a RETURNING clause.
+  */
+ static TupleTableSlot *
+ get_returning_data(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 
+ 	Assert(resultRelInfo->ri_projectReturning);
+ 
+ 	/* If we didn't get any tuples, must be end of data. */
+ 	if (dpstate->next_tuple >= dpstate->num_tuples)
+ 		return ExecClearTuple(slot);
+ 
+ 	/* Increment the command es_processed count if necessary. */
+ 	if (dpstate->set_processed)
+ 		estate->es_processed += 1;
+ 
+ 	/*
+ 	 * Store a RETURNING tuple.  Note that if the local query is of the form
+ 	 * e.g., UPDATE/DELETE .. RETURNING 1, we have has_returning=false, so
+ 	 * just emit a dummy tuple in that case.
+ 	 */
+ 	if (!dpstate->has_returning)
+ 		ExecStoreAllNullTuple(slot);
+ 	else
+ 	{
+ 		PG_TRY();
+ 		{
+ 			HeapTuple	newtup;
+ 
+ 			newtup = make_tuple_from_result_row(dpstate->result,
+ 												dpstate->next_tuple,
+ 												dpstate->rel,
+ 												dpstate->attinmeta,
+ 												dpstate->retrieved_attrs,
+ 												dpstate->temp_cxt);
+ 			ExecStoreTuple(newtup, slot, InvalidBuffer, false);
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			if (dpstate->result)
+ 				PQclear(dpstate->result);
+ 			PG_RE_THROW();
+ 		}
+ 		PG_END_TRY();
+ 	}
+ 	dpstate->next_tuple++;
+ 
+ 	/* Make slot available for evaluation of the local query RETURNING list. */
+ 	resultRelInfo->ri_projectReturning->pi_exprContext->ecxt_scantuple = slot;
+ 
+ 	return slot;
+ }
+ 
+ /*
   * postgresAnalyzeForeignTable
   *		Test whether analyzing this foreign table is supported
   */
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 103,112 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 103,126 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*targetlist,
+ 									   List *targetAttrs,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 399,419 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
--- 399,439 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  
+ INSERT INTO ft2 (c1,c2,c3)
+   VALUES (1201,1201,'aaa'), (1202,1202,'bbb'), (1203,1203,'ccc') RETURNING *;
+ INSERT INTO ft2 (c1,c2,c3) VALUES (1204,1204,'ddd'), (1205,1205,'eee');
+ PREPARE mt1(int, int, text) AS UPDATE ft2 SET c2 = c2 + $2, c3 = c3 || $3 WHERE c1 % 10 = $1;            -- can be pushed down
+ EXPLAIN (verbose, costs off) EXECUTE mt1(1, 0, '_update1');
+ EXECUTE mt1(1, 0, '_update1');
+ PREPARE mt2(int) AS DELETE FROM ft2 WHERE c1 = $1 RETURNING c1, c2, c3;             -- can be pushed down
+ EXPLAIN (verbose, costs off) EXECUTE mt2(1201);
+ EXECUTE mt2(1201);
+ PREPARE mt3(int) AS DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft2.c2 > $1 RETURNING ft2.*;     -- can't be pushed down
+ EXPLAIN (verbose, costs off) EXECUTE mt3(1201);
+ EXECUTE mt3(1201);
+ DEALLOCATE mt1;
+ DEALLOCATE mt2;
+ DEALLOCATE mt3;
+ 
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
***************
*** 728,733 **** UPDATE rem1 SET f2 = 'testo';
--- 748,837 ----
  -- Test returning a system attribute
  INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ 
+ 
+ -- Test DML pushdown functionality
+ 
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_before ON rem1;
+ 
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_after ON rem1;
+ 
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ 
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_update ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_update ON rem1;
+ 
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_after_delete ON rem1;
+ 
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
***************
*** 859,864 **** fetch from c;
--- 963,975 ----
  update bar set f2 = null where current of c;
  rollback;
  
+ explain (verbose, costs off)
+ delete from foo where f1 < 5 returning *;
+ delete from foo where f1 < 5 returning *;
+ explain (verbose, costs off)
+ update bar set f2 = f2 + 100 returning *;
+ update bar set f2 = f2 + 100 returning *;
+ 
  drop table foo cascade;
  drop table bar cascade;
  drop table loct1;
*** a/doc/src/sgml/fdwhandler.sgml
--- b/doc/src/sgml/fdwhandler.sgml
***************
*** 664,669 **** IsForeignRelUpdatable (Relation rel);
--- 664,793 ----
       updatability for display in the <literal>information_schema</> views.)
      </para>
  
+     <para>
+ <programlisting>
+ bool
+ PlanDMLPushdown (PlannerInfo *root,
+                  ModifyTable *plan,
+                  Index resultRelation,
+                  int subplan_index);
+ </programlisting>
+ 
+      Check to see whether a foreign table modification is safe to push down
+      to the remote server.  If so, return <literal>true</> after performing
+      planning actions needed for that.  Otherwise, return <literal>false</>.
+      This optional function is called during query planning.
+      The parameters are the same as for <function>PlanForeignModify</>.
+      If this function succeeds in pushing down the table modification
+      to the remote server, <function>BeginDMLPushdown</>,
+      <function>IterateDMLPushdown</>, and <function>EndDMLPushdown</> will
+      be called at the execution stage, instead.  Otherwise, the table
+      modification will be performed using the above table-updating functions.
+     </para>
+ 
+     <para>
+      To push down the table modification to the remote server, this function
+      must rewrite the target subplan with a <structname>ForeignScan</> plan
+      node that performs the table modification.  The <structfield>operation</>
+      field of the <structname>ForeignScan</> must be set to the
+      <literal>CmdType</> enumeration appropriately; that is,
+      <literal>CMD_UPDATE</> for <command>UPDATE</>,
+      <literal>CMD_INSERT</> for <command>INSERT</>, and
+      <literal>CMD_DELETE</> for <command>DELETE</>.
+     </para>
+ 
+     <para>
+      See <xref linkend="fdw-planning"> for additional information.
+     </para>
+ 
+     <para>
+      If the <function>PlanDMLPushdown</> pointer is set to
+      <literal>NULL</>, no attempts to push down the foreign table modification
+      to the remote server are taken.
+     </para>
+ 
+     <para>
+ <programlisting>
+ void
+ BeginDMLPushdown (ForeignScanState *node,
+                   int eflags);
+ </programlisting>
+ 
+      Begin pushing down a foreign table modification to the remote server.
+      This routine is called during executor startup.  It should perform any
+      initialization needed prior to the actual table modification (that
+      should be done upon the first call to <function>IterateDMLPushdown</>).
+      The <structname>ForeignScanState</> node has already been created, but
+      its <structfield>fdw_state</> field is still NULL.  Information about
+      the table to update is accessible through the
+      <structname>ForeignScanState</> node (in particular, from the underlying
+      <structname>ForeignScan</> plan node, which contains any FDW-private
+      information provided by <function>PlanDMLPushdown</>).
+      <literal>eflags</> contains flag bits describing the executor's
+      operating mode for this plan node.
+     </para>
+ 
+     <para>
+      Note that when <literal>(eflags &amp; EXEC_FLAG_EXPLAIN_ONLY)</> is
+      true, this function should not perform any externally-visible actions;
+      it should only do the minimum required to make the node state valid
+      for <function>ExplainDMLPushdown</> and <function>EndDMLPushdown</>.
+     </para>
+ 
+     <para>
+      If the <function>BeginDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to push down the foreign table modification
+      to the remote server will fail with an error message.
+     </para>
+ 
+     <para>
+ <programlisting>
+ TupleTableSlot *
+ IterateForeignScan (ForeignScanState *node);
+ </programlisting>
+ 
+      When the local query has a <literal>RETURNING</> clause, return one row
+      containing the data that was actually inserted, updated, or deleted, in
+      a tuple table slot (the node's <structfield>ScanTupleSlot</> should be
+      used for this purpose).  Return NULL if no more rows are available.
+      When the query doesn't have the clause, return NULL.  Note that this is
+      called in a short-lived memory context that will be reset between
+      invocations.  Create a memory context in <function>BeginDMLPushdown</>
+      if you need longer-lived storage, or use the <structfield>es_query_cxt</>
+      of the node's <structname>EState</>.
+     </para>
+ 
+     <para>
+      The data in the returned slot is used only if the local query has
+      a <literal>RETURNING</> clause.  The FDW could choose to optimize away
+      returning some or all columns depending on the contents of the
+      <literal>RETURNING</> clause.  Regardless, some slot must be returned to
+      indicate success, or the query's reported row count will be wrong.
+     </para>
+ 
+     <para>
+      If the <function>IterateDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to push down the foreign table modification
+      to the remote server will fail with an error message.
+     </para>
+ 
+     <para>
+ <programlisting>
+ void
+ EndDMLPushdown (ForeignScanState *node);
+ </programlisting>
+ 
+      End the table update and release resources.  It is normally not important
+      to release palloc'd memory, but for example open files and connections
+      to remote servers should be cleaned up.
+     </para>
+ 
+     <para>
+      If the <function>EndDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to push down the foreign table modification
+      to the remote server will fail with an error message.
+     </para>
+ 
     </sect2>
  
     <sect2 id="fdw-callbacks-row-locking">
***************
*** 848,853 **** ExplainForeignModify (ModifyTableState *mtstate,
--- 972,1000 ----
       <command>EXPLAIN</>.
      </para>
  
+     <para>
+ <programlisting>
+ void
+ ExplainDMLPushdown (ForeignScanState *node,
+                     ExplainState *es);
+ </programlisting>
+ 
+      Print additional <command>EXPLAIN</> output for a foreign table update
+      that has been pushed down to the remote server.
+      This function can call <function>ExplainPropertyText</> and
+      related functions to add fields to the <command>EXPLAIN</> output.
+      The flag fields in <literal>es</> can be used to determine what to
+      print, and the state of the <structname>ForeignScanState</> node
+      can be inspected to provide run-time statistics in the <command>EXPLAIN
+      ANALYZE</> case.
+     </para>
+ 
+     <para>
+      If the <function>ExplainDMLPushdown</> pointer is set to
+      <literal>NULL</>, no additional information is printed during
+      <command>EXPLAIN</>.
+     </para>
+ 
     </sect2>
  
     <sect2 id="fdw-callbacks-analyze">
***************
*** 1068,1074 **** GetForeignServerByName(const char *name, bool missing_ok);
      <para>
       The FDW callback functions <function>GetForeignRelSize</>,
       <function>GetForeignPaths</>, <function>GetForeignPlan</>,
!      <function>PlanForeignModify</>, and <function>GetForeignJoinPaths</>
       must fit into the workings of the <productname>PostgreSQL</> planner.
       Here are some notes about what they must do.
      </para>
--- 1215,1222 ----
      <para>
       The FDW callback functions <function>GetForeignRelSize</>,
       <function>GetForeignPaths</>, <function>GetForeignPlan</>,
!      <function>PlanForeignModify</>, <function>PlanDMLPushdown</>, and
!      <function>GetForeignJoinPaths</>
       must fit into the workings of the <productname>PostgreSQL</> planner.
       Here are some notes about what they must do.
      </para>
***************
*** 1228,1237 **** GetForeignServerByName(const char *name, bool missing_ok);
  
      <para>
       When planning an <command>UPDATE</> or <command>DELETE</>,
!      <function>PlanForeignModify</> can look up the <structname>RelOptInfo</>
!      struct for the foreign table and make use of the
!      <literal>baserel-&gt;fdw_private</> data previously created by the
!      scan-planning functions.  However, in <command>INSERT</> the target
       table is not scanned so there is no <structname>RelOptInfo</> for it.
       The <structname>List</> returned by <function>PlanForeignModify</> has
       the same restrictions as the <structfield>fdw_private</> list of a
--- 1376,1386 ----
  
      <para>
       When planning an <command>UPDATE</> or <command>DELETE</>,
!      <function>PlanForeignModify</> and <function>PlanDMLPushdown</> can
!      look up the <structname>RelOptInfo</> struct for the foreign table
!      and make use of the <literal>baserel-&gt;fdw_private</> data previously
!      created by the scan-planning functions.
!      However, in <command>INSERT</> the target
       table is not scanned so there is no <structname>RelOptInfo</> for it.
       The <structname>List</> returned by <function>PlanForeignModify</> has
       the same restrictions as the <structfield>fdw_private</> list of a
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 471,476 ****
--- 471,485 ----
     extension that's listed in the foreign server's <literal>extensions</>
     option.  Operators and functions in such clauses must
     be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, or no row-level local <literal>BEFORE</> or
+    <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, or <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 888,894 **** ExplainNode(PlanState *planstate, List *ancestors,
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			pname = sname = "Foreign Scan";
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
--- 888,916 ----
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			sname = "Foreign Scan";
! 			switch (((ForeignScan *) plan)->operation)
! 			{
! 				case CMD_SELECT:
! 					pname = "Foreign Scan";
! 					operation = "Select";
! 					break;
! 				case CMD_INSERT:
! 					pname = "Foreign Insert";
! 					operation = "Insert";
! 					break;
! 				case CMD_UPDATE:
! 					pname = "Foreign Update";
! 					operation = "Update";
! 					break;
! 				case CMD_DELETE:
! 					pname = "Foreign Delete";
! 					operation = "Delete";
! 					break;
! 				default:
! 					pname = "???";
! 					break;
! 			}
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
***************
*** 1624,1629 **** show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
--- 1646,1657 ----
  		return;
  	if (IsA(plan, RecursiveUnion))
  		return;
+ 	/* Likewise for ForeignScan that has pushed down INSERT/UPDATE/DELETE */
+ 	if (IsA(plan, ForeignScan) &&
+ 		(((ForeignScan *) plan)->operation == CMD_INSERT ||
+ 		 ((ForeignScan *) plan)->operation == CMD_UPDATE ||
+ 		 ((ForeignScan *) plan)->operation == CMD_DELETE))
+ 		return;
  
  	/* Set up deparsing context */
  	context = set_deparse_context_planstate(es->deparse_cxt,
***************
*** 2212,2219 **** show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es)
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (fdwroutine->ExplainForeignScan != NULL)
! 		fdwroutine->ExplainForeignScan(fsstate, es);
  }
  
  /*
--- 2240,2255 ----
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (((ForeignScan *) fsstate->ss.ps.plan)->operation != CMD_SELECT)
! 	{
! 		if (fdwroutine->ExplainDMLPushdown != NULL)
! 			fdwroutine->ExplainDMLPushdown(fsstate, es);
! 	}
! 	else
! 	{
! 		if (fdwroutine->ExplainForeignScan != NULL)
! 			fdwroutine->ExplainForeignScan(fsstate, es);
! 	}
  }
  
  /*
***************
*** 2599,2606 **** show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
  			}
  		}
  
! 		/* Give FDW a chance */
! 		if (fdwroutine && fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
--- 2635,2644 ----
  			}
  		}
  
! 		/* Give FDW a chance if needed */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			fdwroutine != NULL &&
! 			fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1011,1020 **** InitPlan(QueryDesc *queryDesc, int eflags)
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(Relation resultRel, CmdType operation)
  {
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
  
  	switch (resultRel->rd_rel->relkind)
  	{
--- 1011,1022 ----
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
  {
+ 	Relation	resultRel = resultRelInfo->ri_RelationDesc;
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
+ 	bool		allow_pushdown;
  
  	switch (resultRel->rd_rel->relkind)
  	{
***************
*** 1083,1096 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  		case RELKIND_FOREIGN_TABLE:
  			/* Okay only if the FDW supports it */
  			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
  			switch (operation)
  			{
  				case CMD_INSERT:
! 					if (fdwroutine->ExecForeignInsert == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 							errmsg("cannot insert into foreign table \"%s\"",
! 								   RelationGetRelationName(resultRel))));
  					if (fdwroutine->IsForeignRelUpdatable != NULL &&
  						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
  						ereport(ERROR,
--- 1085,1107 ----
  		case RELKIND_FOREIGN_TABLE:
  			/* Okay only if the FDW supports it */
  			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
+ 			allow_pushdown = ((fdwroutine->BeginDMLPushdown != NULL) &&
+ 							  (fdwroutine->IterateDMLPushdown != NULL) &&
+ 							  (fdwroutine->EndDMLPushdown != NULL));
  			switch (operation)
  			{
  				case CMD_INSERT:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down insert on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignInsert == NULL)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot insert into foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
  					if (fdwroutine->IsForeignRelUpdatable != NULL &&
  						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
  						ereport(ERROR,
***************
*** 1099,1105 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_UPDATE:
! 					if (fdwroutine->ExecForeignUpdate == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  								 errmsg("cannot update foreign table \"%s\"",
--- 1110,1122 ----
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_UPDATE:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down update on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignUpdate == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  								 errmsg("cannot update foreign table \"%s\"",
***************
*** 1112,1118 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_DELETE:
! 					if (fdwroutine->ExecForeignDelete == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  							errmsg("cannot delete from foreign table \"%s\"",
--- 1129,1141 ----
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_DELETE:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down delete on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignDelete == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  							errmsg("cannot delete from foreign table \"%s\"",
***************
*** 1245,1250 **** InitResultRelInfo(ResultRelInfo *resultRelInfo,
--- 1268,1274 ----
  	else
  		resultRelInfo->ri_FdwRoutine = NULL;
  	resultRelInfo->ri_FdwState = NULL;
+ 	resultRelInfo->ri_FdwPushdown = false;
  	resultRelInfo->ri_ConstraintExprs = NULL;
  	resultRelInfo->ri_junkFilter = NULL;
  	resultRelInfo->ri_projectReturning = NULL;
*** a/src/backend/executor/nodeForeignscan.c
--- b/src/backend/executor/nodeForeignscan.c
***************
*** 48,54 **** ForeignNext(ForeignScanState *node)
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
--- 48,57 ----
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	if (plan->operation != CMD_SELECT)
! 		slot = node->fdwroutine->IterateDMLPushdown(node);
! 	else
! 		slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
***************
*** 226,232 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
--- 229,238 ----
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	if (node->operation != CMD_SELECT)
! 		fdwroutine->BeginDMLPushdown(scanstate, eflags);
! 	else
! 		fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
***************
*** 240,247 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
  	/* Let the FDW shut down */
! 	node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
--- 246,258 ----
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
+ 	ForeignScan *plan = (ForeignScan *) node->ss.ps.plan;
+ 
  	/* Let the FDW shut down */
! 	if (plan->operation != CMD_SELECT)
! 		node->fdwroutine->EndDMLPushdown(node);
! 	else
! 		node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
*** a/src/backend/executor/nodeModifyTable.c
--- b/src/backend/executor/nodeModifyTable.c
***************
*** 138,143 **** ExecCheckPlanOutput(Relation resultRel, List *targetList)
--- 138,146 ----
   * tupleSlot: slot holding tuple actually inserted/updated/deleted
   * planSlot: slot holding tuple returned by top subplan node
   *
+  * Note: If tupleSlot is NULL, the FDW should have already provided econtext's
+  * scan tuple.
+  *
   * Returns a slot holding the result tuple
   */
  static TupleTableSlot *
***************
*** 154,160 **** ExecProcessReturning(ProjectionInfo *projectReturning,
  	ResetExprContext(econtext);
  
  	/* Make tuple and any needed join variables available to ExecProject */
! 	econtext->ecxt_scantuple = tupleSlot;
  	econtext->ecxt_outertuple = planSlot;
  
  	/* Compute the RETURNING expressions */
--- 157,166 ----
  	ResetExprContext(econtext);
  
  	/* Make tuple and any needed join variables available to ExecProject */
! 	if (tupleSlot)
! 		econtext->ecxt_scantuple = tupleSlot;
! 	else
! 		Assert(econtext->ecxt_scantuple);
  	econtext->ecxt_outertuple = planSlot;
  
  	/* Compute the RETURNING expressions */
***************
*** 1357,1362 **** ExecModifyTable(ModifyTableState *node)
--- 1363,1384 ----
  				break;
  		}
  
+ 		/*
+ 		 * If ri_FdwPushdown is true, all we need to do here is compute the
+ 		 * RETURNING expressions.
+ 		 */
+ 		if (resultRelInfo->ri_FdwPushdown)
+ 		{
+ 			Assert(resultRelInfo->ri_projectReturning);
+ 
+ 			/* No need to provide scan tuple (see ExecProcessReturning) */
+ 			slot = ExecProcessReturning(resultRelInfo->ri_projectReturning,
+ 										NULL, planSlot);
+ 
+ 			estate->es_result_relation_info = saved_resultRelInfo;
+ 			return slot;
+ 		}
+ 
  		EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
  		slot = planSlot;
  
***************
*** 1536,1545 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  	{
  		subplan = (Plan *) lfirst(l);
  
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo->ri_RelationDesc, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
--- 1558,1570 ----
  	{
  		subplan = (Plan *) lfirst(l);
  
+ 		/* Initialize the FdwPushdown flag */
+ 		resultRelInfo->ri_FdwPushdown = list_nth_int(node->fdwPushdowns, i);
+ 
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
***************
*** 1560,1566 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
--- 1585,1592 ----
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
***************
*** 1731,1743 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1757,1781 ----
  		erm = ExecFindRowMark(estate, rc->rti, false);
  
  		/* build ExecAuxRowMark for each subplan */
+ 		resultRelInfo = mtstate->resultRelInfo;
  		for (i = 0; i < nplans; i++)
  		{
  			ExecAuxRowMark *aerm;
  
+ 			/*
+ 			 * ignore subplan if the FDW pushes the command down to the remote
+ 			 * server
+ 			 */
+ 			if (resultRelInfo->ri_FdwPushdown)
+ 			{
+ 				resultRelInfo++;
+ 				continue;
+ 			}
+ 
  			subplan = mtstate->mt_plans[i]->plan;
  			aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
  			mtstate->mt_arowmarks[i] = lappend(mtstate->mt_arowmarks[i], aerm);
+ 			resultRelInfo++;
  		}
  	}
  
***************
*** 1798,1803 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1836,1851 ----
  					ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
  										subplan->targetlist);
  
+ 				/*
+ 				 * ignore subplan if the FDW pushes the command down to the
+ 				 * remote server
+ 				 */
+ 				if (resultRelInfo->ri_FdwPushdown)
+ 				{
+ 					resultRelInfo++;
+ 					continue;
+ 				}
+ 
  				j = ExecInitJunkFilter(subplan->targetlist,
  							resultRelInfo->ri_RelationDesc->rd_att->tdhasoid,
  									   ExecInitExtraTupleSlot(estate));
***************
*** 1887,1893 **** ExecEndModifyTable(ModifyTableState *node)
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
--- 1935,1942 ----
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 186,191 **** _copyModifyTable(const ModifyTable *from)
--- 186,192 ----
  	COPY_NODE_FIELD(withCheckOptionLists);
  	COPY_NODE_FIELD(returningLists);
  	COPY_NODE_FIELD(fdwPrivLists);
+ 	COPY_NODE_FIELD(fdwPushdowns);
  	COPY_NODE_FIELD(rowMarks);
  	COPY_SCALAR_FIELD(epqParam);
  	COPY_SCALAR_FIELD(onConflictAction);
***************
*** 645,650 **** _copyForeignScan(const ForeignScan *from)
--- 646,652 ----
  	/*
  	 * copy remainder of node
  	 */
+ 	COPY_SCALAR_FIELD(operation);
  	COPY_SCALAR_FIELD(fs_server);
  	COPY_NODE_FIELD(fdw_exprs);
  	COPY_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 340,345 **** _outModifyTable(StringInfo str, const ModifyTable *node)
--- 340,346 ----
  	WRITE_NODE_FIELD(withCheckOptionLists);
  	WRITE_NODE_FIELD(returningLists);
  	WRITE_NODE_FIELD(fdwPrivLists);
+ 	WRITE_NODE_FIELD(fdwPushdowns);
  	WRITE_NODE_FIELD(rowMarks);
  	WRITE_INT_FIELD(epqParam);
  	WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
***************
*** 591,596 **** _outForeignScan(StringInfo str, const ForeignScan *node)
--- 592,598 ----
  
  	_outScanInfo(str, (const Scan *) node);
  
+ 	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_OID_FIELD(fs_server);
  	WRITE_NODE_FIELD(fdw_exprs);
  	WRITE_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/readfuncs.c
--- b/src/backend/nodes/readfuncs.c
***************
*** 1471,1476 **** _readModifyTable(void)
--- 1471,1477 ----
  	READ_NODE_FIELD(withCheckOptionLists);
  	READ_NODE_FIELD(returningLists);
  	READ_NODE_FIELD(fdwPrivLists);
+ 	READ_NODE_FIELD(fdwPushdowns);
  	READ_NODE_FIELD(rowMarks);
  	READ_INT_FIELD(epqParam);
  	READ_ENUM_FIELD(onConflictAction, OnConflictAction);
*** a/src/backend/optimizer/plan/createplan.c
--- b/src/backend/optimizer/plan/createplan.c
***************
*** 3768,3773 **** make_foreignscan(List *qptlist,
--- 3768,3774 ----
  	plan->lefttree = outer_plan;
  	plan->righttree = NULL;
  	node->scan.scanrelid = scanrelid;
+ 	node->operation = CMD_SELECT;
  	/* fs_server will be filled in by create_foreignscan_plan */
  	node->fs_server = InvalidOid;
  	node->fdw_exprs = fdw_exprs;
***************
*** 5043,5048 **** make_modifytable(PlannerInfo *root,
--- 5044,5050 ----
  	Plan	   *plan = &node->plan;
  	double		total_size;
  	List	   *fdw_private_list;
+ 	List	   *fdwpushdown_list;
  	ListCell   *subnode;
  	ListCell   *lc;
  	int			i;
***************
*** 5123,5134 **** make_modifytable(PlannerInfo *root,
--- 5125,5138 ----
  	 * construct private plan data, and accumulate it all into a list.
  	 */
  	fdw_private_list = NIL;
+ 	fdwpushdown_list = NIL;
  	i = 0;
  	foreach(lc, resultRelations)
  	{
  		Index		rti = lfirst_int(lc);
  		FdwRoutine *fdwroutine;
  		List	   *fdw_private;
+ 		bool		fdwpushdown;
  
  		/*
  		 * If possible, we want to get the FdwRoutine from our RelOptInfo for
***************
*** 5156,5161 **** make_modifytable(PlannerInfo *root,
--- 5160,5173 ----
  		}
  
  		if (fdwroutine != NULL &&
+ 			fdwroutine->PlanDMLPushdown != NULL)
+ 			fdwpushdown = fdwroutine->PlanDMLPushdown(root, node, rti, i);
+ 		else
+ 			fdwpushdown = false;
+ 		fdwpushdown_list = lappend_int(fdwpushdown_list, fdwpushdown);
+ 
+ 		if (!fdwpushdown &&
+ 			fdwroutine != NULL &&
  			fdwroutine->PlanForeignModify != NULL)
  			fdw_private = fdwroutine->PlanForeignModify(root, node, rti, i);
  		else
***************
*** 5164,5169 **** make_modifytable(PlannerInfo *root,
--- 5176,5182 ----
  		i++;
  	}
  	node->fdwPrivLists = fdw_private_list;
+ 	node->fdwPushdowns = fdwpushdown_list;
  
  	return node;
  }
*** a/src/backend/rewrite/rewriteHandler.c
--- b/src/backend/rewrite/rewriteHandler.c
***************
*** 2530,2535 **** relation_is_updatable(Oid reloid,
--- 2530,2571 ----
  
  
  /*
+  * relation_has_row_triggers - does relation have row level triggers for event?
+  */
+ bool
+ relation_has_row_triggers(Relation rel, CmdType event)
+ {
+ 	TriggerDesc *trigDesc = rel->trigdesc;
+ 
+ 	switch (event)
+ 	{
+ 		case CMD_INSERT:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_insert_after_row ||
+ 				 trigDesc->trig_insert_before_row))
+ 				return true;
+ 			break;
+ 		case CMD_UPDATE:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_update_after_row ||
+ 				 trigDesc->trig_update_before_row))
+ 				return true;
+ 			break;
+ 		case CMD_DELETE:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_delete_after_row ||
+ 				 trigDesc->trig_delete_before_row))
+ 				return true;
+ 			break;
+ 		default:
+ 			elog(ERROR, "unrecognized CmdType: %d", (int) event);
+ 			break;
+ 	}
+ 	return false;
+ }
+ 
+ 
+ /*
   * adjust_view_column_set - map a set of column numbers according to targetlist
   *
   * This is used with simply-updatable views to map column-permissions sets for
*** a/src/include/executor/executor.h
--- b/src/include/executor/executor.h
***************
*** 184,190 **** extern void ExecutorEnd(QueryDesc *queryDesc);
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(Relation resultRel, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
--- 184,190 ----
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
*** a/src/include/foreign/fdwapi.h
--- b/src/include/foreign/fdwapi.h
***************
*** 93,98 **** typedef void (*EndForeignModify_function) (EState *estate,
--- 93,110 ----
  
  typedef int (*IsForeignRelUpdatable_function) (Relation rel);
  
+ typedef bool (*PlanDMLPushdown_function) (PlannerInfo *root,
+ 										  ModifyTable *plan,
+ 										  Index resultRelation,
+ 										  int subplan_index);
+ 
+ typedef void (*BeginDMLPushdown_function) (ForeignScanState *node,
+ 										   int eflags);
+ 
+ typedef TupleTableSlot *(*IterateDMLPushdown_function) (ForeignScanState *node);
+ 
+ typedef void (*EndDMLPushdown_function) (ForeignScanState *node);
+ 
  typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
  												LockClauseStrength strength);
  
***************
*** 110,115 **** typedef void (*ExplainForeignModify_function) (ModifyTableState *mtstate,
--- 122,130 ----
  														   int subplan_index,
  													struct ExplainState *es);
  
+ typedef void (*ExplainDMLPushdown_function) (ForeignScanState *node,
+ 													struct ExplainState *es);
+ 
  typedef int (*AcquireSampleRowsFunc) (Relation relation, int elevel,
  											   HeapTuple *rows, int targrows,
  												  double *totalrows,
***************
*** 162,167 **** typedef struct FdwRoutine
--- 177,186 ----
  	ExecForeignDelete_function ExecForeignDelete;
  	EndForeignModify_function EndForeignModify;
  	IsForeignRelUpdatable_function IsForeignRelUpdatable;
+ 	PlanDMLPushdown_function PlanDMLPushdown;
+ 	BeginDMLPushdown_function BeginDMLPushdown;
+ 	IterateDMLPushdown_function IterateDMLPushdown;
+ 	EndDMLPushdown_function EndDMLPushdown;
  
  	/* Functions for SELECT FOR UPDATE/SHARE row locking */
  	GetForeignRowMarkType_function GetForeignRowMarkType;
***************
*** 171,176 **** typedef struct FdwRoutine
--- 190,196 ----
  	/* Support functions for EXPLAIN */
  	ExplainForeignScan_function ExplainForeignScan;
  	ExplainForeignModify_function ExplainForeignModify;
+ 	ExplainDMLPushdown_function ExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	AnalyzeForeignTable_function AnalyzeForeignTable;
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 311,316 **** typedef struct JunkFilter
--- 311,317 ----
   *		TrigInstrument			optional runtime measurements for triggers
   *		FdwRoutine				FDW callback functions, if foreign table
   *		FdwState				available to save private state of FDW
+  *		FdwPushdown				true when the command is pushed down
   *		WithCheckOptions		list of WithCheckOption's to be checked
   *		WithCheckOptionExprs	list of WithCheckOption expr states
   *		ConstraintExprs			array of constraint-checking expr states
***************
*** 334,339 **** typedef struct ResultRelInfo
--- 335,341 ----
  	Instrumentation *ri_TrigInstrument;
  	struct FdwRoutine *ri_FdwRoutine;
  	void	   *ri_FdwState;
+ 	bool		ri_FdwPushdown;
  	List	   *ri_WithCheckOptions;
  	List	   *ri_WithCheckOptionExprs;
  	List	  **ri_ConstraintExprs;
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
***************
*** 188,193 **** typedef struct ModifyTable
--- 188,194 ----
  	List	   *withCheckOptionLists;	/* per-target-table WCO lists */
  	List	   *returningLists; /* per-target-table RETURNING tlists */
  	List	   *fdwPrivLists;	/* per-target-table FDW private data lists */
+ 	List	   *fdwPushdowns;	/* per-target-table FDW pushdown flags */
  	List	   *rowMarks;		/* PlanRowMarks (non-locking only) */
  	int			epqParam;		/* ID of Param for EvalPlanQual re-eval */
  	OnConflictAction onConflictAction;	/* ON CONFLICT action */
***************
*** 530,535 **** typedef struct WorkTableScan
--- 531,537 ----
  typedef struct ForeignScan
  {
  	Scan		scan;
+ 	CmdType		operation;		/* SELECT/INSERT/UPDATE/DELETE */
  	Oid			fs_server;		/* OID of foreign server */
  	List	   *fdw_exprs;		/* expressions that FDW may evaluate */
  	List	   *fdw_private;	/* private data for FDW */
*** a/src/include/rewrite/rewriteHandler.h
--- b/src/include/rewrite/rewriteHandler.h
***************
*** 29,33 **** extern const char *view_query_is_auto_updatable(Query *viewquery,
--- 29,34 ----
  extern int relation_is_updatable(Oid reloid,
  					  bool include_triggers,
  					  Bitmapset *include_cols);
+ extern bool relation_has_row_triggers(Relation rel, CmdType event);
  
  #endif   /* REWRITEHANDLER_H */

diff --git a/contrib/postgres_fdw/deparse.c b/contrib/postgres_fdw/deparse.c
index e59af2c..12a1031 100644
--- a/contrib/postgres_fdw/deparse.c
+++ b/contrib/postgres_fdw/deparse.c
@@ -110,6 +110,7 @@ static void deparseTargetList(StringInfo buf,
 				  PlannerInfo *root,
 				  Index rtindex,
 				  Relation rel,
+				  bool is_returning,
 				  Bitmapset *attrs_used,
 				  List **retrieved_attrs);
 static void deparseReturningList(StringInfo buf, PlannerInfo *root,
@@ -724,7 +725,7 @@ deparseSelectSql(StringInfo buf,
 	 * Construct SELECT list
 	 */
 	appendStringInfoString(buf, "SELECT ");
-	deparseTargetList(buf, root, baserel->relid, rel, attrs_used,
+	deparseTargetList(buf, root, baserel->relid, rel, false, attrs_used,
 					  retrieved_attrs);
 
 	/*
@@ -738,7 +739,8 @@ deparseSelectSql(StringInfo buf,
 
 /*
  * Emit a target list that retrieves the columns specified in attrs_used.
- * This is used for both SELECT and RETURNING targetlists.
+ * This is used for both SELECT and RETURNING targetlists; the is_returning
+ * parameter is true only for a RETURNING targetlist.
  *
  * The tlist text is appended to buf, and we also create an integer List
  * of the columns being retrieved, which is returned to *retrieved_attrs.
@@ -748,6 +750,7 @@ deparseTargetList(StringInfo buf,
 				  PlannerInfo *root,
 				  Index rtindex,
 				  Relation rel,
+				  bool is_returning,
 				  Bitmapset *attrs_used,
 				  List **retrieved_attrs)
 {
@@ -777,6 +780,8 @@ deparseTargetList(StringInfo buf,
 		{
 			if (!first)
 				appendStringInfoString(buf, ", ");
+			else if (is_returning)
+				appendStringInfoString(buf, " RETURNING ");
 			first = false;
 
 			deparseColumnRef(buf, rtindex, i, root);
@@ -794,6 +799,8 @@ deparseTargetList(StringInfo buf,
 	{
 		if (!first)
 			appendStringInfoString(buf, ", ");
+		else if (is_returning)
+			appendStringInfoString(buf, " RETURNING ");
 		first = false;
 
 		appendStringInfoString(buf, "ctid");
@@ -803,7 +810,7 @@ deparseTargetList(StringInfo buf,
 	}
 
 	/* Don't generate bad syntax if no undropped columns */
-	if (first)
+	if (first && !is_returning)
 		appendStringInfoString(buf, "NULL");
 }
 
@@ -1022,11 +1029,8 @@ deparseReturningList(StringInfo buf, PlannerInfo *root,
 	}
 
 	if (attrs_used != NULL)
-	{
-		appendStringInfoString(buf, " RETURNING ");
-		deparseTargetList(buf, root, rtindex, rel, attrs_used,
+		deparseTargetList(buf, root, rtindex, rel, true, attrs_used,
 						  retrieved_attrs);
-	}
 	else
 		*retrieved_attrs = NIL;
 }
diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index b471c67..b0d12ac 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -2408,6 +2408,59 @@ SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  1104 | 204 | ddd                | 
 (819 rows)
 
+EXPLAIN (verbose, costs off)
+INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+                                                                                           QUERY PLAN                                                                                            
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Insert on public.ft2
+   Output: (tableoid)::regclass
+   Remote SQL: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6, c7, c8) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+   ->  Result
+         Output: 9999, 999, NULL::integer, 'foo'::text, NULL::timestamp with time zone, NULL::timestamp without time zone, NULL::character varying, 'ft2       '::character(10), NULL::user_enum
+(5 rows)
+
+INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+ tableoid 
+----------
+ ft2
+(1 row)
+
+EXPLAIN (verbose, costs off)
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+                                                    QUERY PLAN                                                     
+-------------------------------------------------------------------------------------------------------------------
+ Update on public.ft2
+   Output: (tableoid)::regclass
+   Remote SQL: UPDATE "S 1"."T 1" SET c3 = $2 WHERE ctid = $1
+   ->  Foreign Scan on public.ft2
+         Output: c1, c2, NULL::integer, 'bar'::text, c4, c5, c6, c7, c8, ctid
+         Remote SQL: SELECT "C 1", c2, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
+(6 rows)
+
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+ tableoid 
+----------
+ ft2
+(1 row)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+                                     QUERY PLAN                                     
+------------------------------------------------------------------------------------
+ Delete on public.ft2
+   Output: (tableoid)::regclass
+   Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1
+   ->  Foreign Scan on public.ft2
+         Output: ctid
+         Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
+(6 rows)
+
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+ tableoid 
+----------
+ ft2
+(1 row)
+
 -- Test that trigger on remote table works as expected
 CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
 BEGIN
diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql
index 73fa9f6..4b13654 100644
--- a/contrib/postgres_fdw/sql/postgres_fdw.sql
+++ b/contrib/postgres_fdw/sql/postgres_fdw.sql
@@ -413,6 +413,15 @@ EXPLAIN (verbose, costs off)
 DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
 DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
 SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
+EXPLAIN (verbose, costs off)
+INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+EXPLAIN (verbose, costs off)
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+EXPLAIN (verbose, costs off)
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
 
 -- Test that trigger on remote table works as expected
 CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 46299fc..27051e8 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -308,6 +308,12 @@ ExecInsert(ModifyTableState *mtstate,
 		/* FDW might have changed tuple */
 		tuple = ExecMaterializeSlot(slot);
 
+		/*
+		 * AFTER ROW Triggers or RETURNING expressions might reference the
+		 * tableoid column, so initialize t_tableOid before evaluating them.
+		 */
+		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
+
 		newId = InvalidOid;
 	}
 	else
@@ -561,6 +567,8 @@ ExecDelete(ItemPointer tupleid,
 	}
 	else if (resultRelInfo->ri_FdwRoutine)
 	{
+		HeapTuple	tuple;
+
 		/*
 		 * delete from foreign table: let the FDW do it
 		 *
@@ -579,6 +587,15 @@ ExecDelete(ItemPointer tupleid,
 
 		if (slot == NULL)		/* "do nothing" */
 			return NULL;
+
+		/*
+		 * RETURNING expressions might reference the tableoid column, so
+		 * initialize t_tableOid before evaluating them.
+		 */
+		if (slot->tts_isempty)
+			ExecStoreAllNullTuple(slot);
+		tuple = ExecMaterializeSlot(slot);
+		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
 	}
 	else
 	{
@@ -838,6 +855,12 @@ ExecUpdate(ItemPointer tupleid,
 
 		/* FDW might have changed tuple */
 		tuple = ExecMaterializeSlot(slot);
+
+		/*
+		 * AFTER ROW Triggers or RETURNING expressions might reference the
+		 * tableoid column, so initialize t_tableOid before evaluating them.
+		 */
+		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
 	}
 	else
 	{

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 823,829 **** deparseTargetList(StringInfo buf,
   *
   * If params is not NULL, it receives a list of Params and other-relation Vars
   * used in the clauses; these values must be transmitted to the remote server
!  * as parameter values.
   *
   * If params is NULL, we're generating the query for EXPLAIN purposes,
   * so Params and other-relation Vars should be replaced by dummy values.
--- 823,829 ----
   *
   * If params is not NULL, it receives a list of Params and other-relation Vars
   * used in the clauses; these values must be transmitted to the remote server
!  * as parameter values.  Caller is responsible for initializing it to empty.
   *
   * If params is NULL, we're generating the query for EXPLAIN purposes,
   * so Params and other-relation Vars should be replaced by dummy values.
***************
*** 840,848 **** appendWhereClause(StringInfo buf,
  	int			nestlevel;
  	ListCell   *lc;
  
- 	if (params)
- 		*params = NIL;			/* initialize result list to empty */
- 
  	/* Set up context struct for recursion */
  	context.root = root;
  	context.foreignrel = baserel;
--- 840,845 ----
***************
*** 978,983 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 975,1044 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*targetlist,
+ 						   List *targetAttrs,
+ 						   List	*remote_conds,
+ 						   List **params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	deparse_expr_cxt context;
+ 	int			nestlevel;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	if (params_list)
+ 		*params_list = NIL;		/* initialize result list to empty */
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = params_list;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	/* Make sure any constants in the exprs are printed portably */
+ 	nestlevel = set_transmission_modes();
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfoString(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 
+ 	reset_transmission_modes(nestlevel);
+ 
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 1000,1005 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 1061,1097 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*remote_conds,
+ 						   List	**params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 
+ 	if (params_list)
+ 		*params_list = NIL;		/* initialize result list to empty */
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 
+ 	if (remote_conds)
+ 		appendWhereClause(buf, root, baserel, remote_conds,
+ 						  true, params_list);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 1314,1320 **** INSERT INTO ft2 (c1,c2,c3)
--- 1314,1339 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (3 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1424,1430 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1443,1449 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1445,1460 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1464,1477 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1565,1571 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1582,1588 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2427,2441 **** INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
!                                                     QUERY PLAN                                                     
! -------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
     Output: (tableoid)::regclass
!    Remote SQL: UPDATE "S 1"."T 1" SET c3 = $2 WHERE ctid = $1
!    ->  Foreign Scan on public.ft2
!          Output: c1, c2, NULL::integer, 'bar'::text, c4, c5, c6, c7, c8, ctid
!          Remote SQL: SELECT "C 1", c2, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
! (6 rows)
  
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
--- 2444,2456 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
!                                      QUERY PLAN                                     
! ------------------------------------------------------------------------------------
   Update on public.ft2
     Output: (tableoid)::regclass
!    ->  Foreign Update on public.ft2
!          Remote SQL: UPDATE "S 1"."T 1" SET c3 = 'bar'::text WHERE (("C 1" = 9999))
! (4 rows)
  
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
***************
*** 2445,2459 **** UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  
  EXPLAIN (verbose, costs off)
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
!                                      QUERY PLAN                                     
! ------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: (tableoid)::regclass
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
--- 2460,2472 ----
  
  EXPLAIN (verbose, costs off)
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
!                              QUERY PLAN                             
! --------------------------------------------------------------------
   Delete on public.ft2
     Output: (tableoid)::regclass
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE (("C 1" = 9999))
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
***************
*** 2607,2613 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2620,2626 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2766,2772 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2779,2785 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2906,2912 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
--- 2919,2925 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
***************
*** 3299,3304 **** NOTICE:  NEW: (13,"test triggered !")
--- 3312,3510 ----
   (0,27)
  (1 row)
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ -- Test DML pushdown functionality
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_before ON rem1;
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_after ON rem1;
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_update ON rem1;
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                   QUERY PLAN                                   
+ -------------------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_update ON rem1;
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                                QUERY PLAN                               
+ ------------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_after_delete ON rem1;
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
***************
*** 3768,3773 **** fetch from c;
--- 3974,4029 ----
  update bar set f2 = null where current of c;
  ERROR:  WHERE CURRENT OF is not supported for this table type
  rollback;
+ explain (verbose, costs off)
+ delete from foo where f1 < 5 returning *;
+                                    QUERY PLAN                                   
+ --------------------------------------------------------------------------------
+  Delete on public.foo
+    Output: foo.f1, foo.f2
+    Delete on public.foo
+    Foreign Delete on public.foo2
+    ->  Index Scan using i_foo_f1 on public.foo
+          Output: foo.ctid
+          Index Cond: (foo.f1 < 5)
+    ->  Foreign Delete on public.foo2
+          Remote SQL: DELETE FROM public.loct1 WHERE ((f1 < 5)) RETURNING f1, f2
+ (9 rows)
+ 
+ delete from foo where f1 < 5 returning *;
+  f1 | f2 
+ ----+----
+   1 |  1
+   3 |  3
+   0 |  0
+   2 |  2
+   4 |  4
+ (5 rows)
+ 
+ explain (verbose, costs off)
+ update bar set f2 = f2 + 100 returning *;
+                                   QUERY PLAN                                  
+ ------------------------------------------------------------------------------
+  Update on public.bar
+    Output: bar.f1, bar.f2
+    Update on public.bar
+    Foreign Update on public.bar2
+    ->  Seq Scan on public.bar
+          Output: bar.f1, (bar.f2 + 100), bar.ctid
+    ->  Foreign Update on public.bar2
+          Remote SQL: UPDATE public.loct2 SET f2 = (f2 + 100) RETURNING f1, f2
+ (8 rows)
+ 
+ update bar set f2 = f2 + 100 returning *;
+  f1 | f2  
+ ----+-----
+   1 | 311
+   2 | 322
+   6 | 266
+   3 | 333
+   4 | 344
+   7 | 277
+ (6 rows)
+ 
  drop table foo cascade;
  NOTICE:  drop cascades to foreign table foo2
  drop table bar cascade;
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 57,63 **** PG_MODULE_MAGIC;
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
--- 57,64 ----
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) List of restriction clauses that can be executed remotely
!  * 3) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
***************
*** 67,72 **** enum FdwScanPrivateIndex
--- 68,75 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
+ 	/* List of restriction clauses that can be executed remotely */
+ 	FdwScanPrivateRemoteConds,
  	/* Integer list of attribute numbers retrieved by the SELECT */
  	FdwScanPrivateRetrievedAttrs
  };
***************
*** 94,99 **** enum FdwModifyPrivateIndex
--- 97,124 ----
  };
  
  /*
+  * Similarly, this enum describes what's kept in the fdw_private list for
+  * a ForeignScan node that has pushed down an UPDATE/DELETE to the remote
+  * server.  We store:
+  *
+  * 1) UPDATE/DELETE statement text to be sent to the remote server
+  * 2) Boolean flag showing if the remote query has a RETURNING clause
+  * 3) Integer list of attribute numbers retrieved by RETURNING, if any
+  * 4) Boolean flag showing if we set the command es_processed
+  */
+ enum FdwDmlPushdownPrivateIndex
+ {
+ 	/* SQL statement to execute remotely (as a String node) */
+ 	FdwDmlPushdownPrivateUpdateSql,
+ 	/* has-returning flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateHasReturning,
+ 	/* Integer list of attribute numbers retrieved by RETURNING */
+ 	FdwDmlPushdownPrivateRetrievedAttrs,
+ 	/* set-processed flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateSetProcessed
+ };
+ 
+ /*
   * Execution state of a foreign scan using postgres_fdw.
   */
  typedef struct PgFdwScanState
***************
*** 156,161 **** typedef struct PgFdwModifyState
--- 181,217 ----
  } PgFdwModifyState;
  
  /*
+  * Execution state of a foreign scan that has pushed down a foreign table
+  * modification to the remote server
+  */
+ typedef struct PgFdwDmlPushdownState
+ {
+ 	Relation	rel;			/* relcache entry for the foreign table */
+ 	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
+ 
+ 	/* extracted fdw_private data */
+ 	char	   *query;			/* text of UPDATE/DELETE command */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
+ 	List	   *retrieved_attrs;	/* attr numbers retrieved by RETURNING */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 
+ 	/* for remote query execution */
+ 	PGconn	   *conn;			/* connection for the scan */
+ 	int			numParams;		/* number of parameters passed to query */
+ 	FmgrInfo   *param_flinfo;	/* output conversion functions for them */
+ 	List	   *param_exprs;	/* executable expressions for param values */
+ 	const char **param_values;	/* textual values of query parameters */
+ 
+ 	/* for storing result tuples */
+ 	PGresult   *result;			/* result for query */
+ 	int			num_tuples;		/* # of result tuples */
+ 	int			next_tuple;		/* index of next one to return */
+ 
+ 	/* working memory contexts */
+ 	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
+ } PgFdwDmlPushdownState;
+ 
+ /*
   * Workspace for analyzing a foreign table.
   */
  typedef struct PgFdwAnalyzeState
***************
*** 247,252 **** static TupleTableSlot *postgresExecForeignDelete(EState *estate,
--- 303,315 ----
  static void postgresEndForeignModify(EState *estate,
  						 ResultRelInfo *resultRelInfo);
  static int	postgresIsForeignRelUpdatable(Relation rel);
+ static bool postgresPlanDMLPushdown(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index);
+ static void postgresBeginDMLPushdown(ForeignScanState *node, int eflags);
+ static TupleTableSlot *postgresIterateDMLPushdown(ForeignScanState *node);
+ static void postgresEndDMLPushdown(ForeignScanState *node);
  static void postgresExplainForeignScan(ForeignScanState *node,
  						   ExplainState *es);
  static void postgresExplainForeignModify(ModifyTableState *mtstate,
***************
*** 254,259 **** static void postgresExplainForeignModify(ModifyTableState *mtstate,
--- 317,324 ----
  							 List *fdw_private,
  							 int subplan_index,
  							 ExplainState *es);
+ static void postgresExplainDMLPushdown(ForeignScanState *node,
+ 						   ExplainState *es);
  static bool postgresAnalyzeForeignTable(Relation relation,
  							AcquireSampleRowsFunc *func,
  							BlockNumber *totalpages);
***************
*** 290,295 **** static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
--- 355,362 ----
  						 TupleTableSlot *slot);
  static void store_returning_result(PgFdwModifyState *fmstate,
  					   TupleTableSlot *slot, PGresult *res);
+ static void execute_dml_stmt(ForeignScanState *node);
+ static TupleTableSlot *get_returning_data(ForeignScanState *node);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 332,341 **** postgres_fdw_handler(PG_FUNCTION_ARGS)
--- 399,413 ----
  	routine->ExecForeignDelete = postgresExecForeignDelete;
  	routine->EndForeignModify = postgresEndForeignModify;
  	routine->IsForeignRelUpdatable = postgresIsForeignRelUpdatable;
+ 	routine->PlanDMLPushdown = postgresPlanDMLPushdown;
+ 	routine->BeginDMLPushdown = postgresBeginDMLPushdown;
+ 	routine->IterateDMLPushdown = postgresIterateDMLPushdown;
+ 	routine->EndDMLPushdown = postgresEndDMLPushdown;
  
  	/* Support functions for EXPLAIN */
  	routine->ExplainForeignScan = postgresExplainForeignScan;
  	routine->ExplainForeignModify = postgresExplainForeignModify;
+ 	routine->ExplainDMLPushdown = postgresExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	routine->AnalyzeForeignTable = postgresAnalyzeForeignTable;
***************
*** 1067,1073 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make2(makeString(sql.data),
  							 retrieved_attrs);
  
  	/*
--- 1139,1146 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make3(makeString(sql.data),
! 							 remote_conds,
  							 retrieved_attrs);
  
  	/*
***************
*** 1363,1375 **** postgresAddForeignUpdateTargets(Query *parsetree,
  /*
   * postgresPlanForeignModify
   *		Plan an insert/update/delete operation on a foreign table
-  *
-  * Note: currently, the plan tree generated for UPDATE/DELETE will always
-  * include a ForeignScan that retrieves ctids (using SELECT FOR UPDATE)
-  * and then the ModifyTable node will have to execute individual remote
-  * UPDATE/DELETE commands.  If there are no local conditions or joins
-  * needed, it'd be better to let the scan node do UPDATE/DELETE RETURNING
-  * and then do nothing at ModifyTable.  Room for future optimization ...
   */
  static List *
  postgresPlanForeignModify(PlannerInfo *root,
--- 1436,1441 ----
***************
*** 1882,1887 **** postgresIsForeignRelUpdatable(Relation rel)
--- 1948,2286 ----
  }
  
  /*
+  * postgresPlanDMLPushdown
+  *		Consider pushing down a foreign table modification to the remote server
+  *
+  * Decide whether the table modification is safe to push down to the remote end,
+  * and if so, modify subplan so as to do that.
+  *
+  * Conditions checked here:
+  *
+  * 1. The table modification must be an update or delete.
+  *
+  * 2. It's unsafe to push down the command if there are any local joins needed.
+  *
+  * 3. It's unsafe to push down the command if there are any quals that can't be
+  *    evaluated remotely.
+  *
+  * 4. We can't push down an UPDATE, if any expressions to assign to the target
+  *    columns are unsafe to evaluate on the remote end.
+  */
+ static bool
+ postgresPlanDMLPushdown(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index)
+ {
+ 	CmdType		operation = plan->operation;
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	RangeTblEntry *rte = planner_rt_fetch(resultRelation, root);
+ 	Relation	rel;
+ 	StringInfoData sql;
+ 	ForeignScan *fscan;
+ 	List	   *targetAttrs = NIL;
+ 	List	   *remote_conds;
+ 	List	   *params_list = NIL;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 
+ 	/*
+ 	 * Decide whether the table modification is safe to push down to the remote
+ 	 * server.
+ 	 */
+ 
+ 	/* Check point 1 */
+ 	if (operation == CMD_INSERT)
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 		int			col;
+ 
+ 		/*
+ 		 * We transmit only columns that were explicitly targets of the UPDATE,
+ 		 * so as to avoid unnecessary data transmission.
+ 		 */
+ 		col = -1;
+ 		while ((col = bms_next_member(rte->updatedCols, col)) >= 0)
+ 		{
+ 			/* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
+ 			AttrNumber	attno = col + FirstLowInvalidHeapAttributeNumber;
+ 			TargetEntry *tle;
+ 
+ 			if (attno <= InvalidAttrNumber)		/* shouldn't happen */
+ 				elog(ERROR, "system-column update is not supported");
+ 
+ 			tle = get_tle_by_resno(subplan->targetlist, attno);
+ 
+ 			if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 				return false;
+ 
+ 			targetAttrs = lappend_int(targetAttrs, attno);
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Ok, modify subplan so as to push down the command to the remote server.
+ 	 */
+ 	fscan = (ForeignScan *) subplan;
+ 
+ 	initStringInfo(&sql);
+ 
+ 	/*
+ 	 * Core code already has some lock on each rel being planned, so we can
+ 	 * use NoLock here.
+ 	 */
+ 	rel = heap_open(rte->relid, NoLock);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	switch (operation)
+ 	{
+ 		case CMD_UPDATE:
+ 			deparsePushedDownUpdateSql(&sql, root, resultRelation, rel,
+ 									   ((Plan *) fscan)->targetlist,
+ 									   targetAttrs,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		case CMD_DELETE:
+ 			deparsePushedDownDeleteSql(&sql, root, resultRelation, rel,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		default:
+ 			elog(ERROR, "unexpected operation: %d", (int) operation);
+ 			break;
+ 	}
+ 
+ 	/*
+ 	 * Update the operation info.
+ 	 */
+ 	fscan->operation = operation;
+ 
+ 	/*
+ 	 * Update the fdw_exprs list that will be available to the executor.
+ 	 */
+ 	fscan->fdw_exprs = params_list;
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwDmlPushdownPrivateIndex, above.
+ 	 */
+ 	fscan->fdw_private = list_make4(makeString(sql.data),
+ 									makeInteger((retrieved_attrs != NIL)),
+ 									retrieved_attrs,
+ 									makeInteger(plan->canSetTag));
+ 
+ 	heap_close(rel, NoLock);
+ 	return true;
+ }
+ 
+ /*
+  * postgresBeginDMLPushdown
+  *		Initiate pushing down a foreign table modification to the remote server
+  */
+ static void
+ postgresBeginDMLPushdown(ForeignScanState *node, int eflags)
+ {
+ 	ForeignScan *fsplan = (ForeignScan *) node->ss.ps.plan;
+ 	EState	   *estate = node->ss.ps.state;
+ 	PgFdwDmlPushdownState *dpstate;
+ 	RangeTblEntry *rte;
+ 	Oid			userid;
+ 	ForeignTable *table;
+ 	ForeignServer *server;
+ 	UserMapping *user;
+ 	int			numParams;
+ 	int			i;
+ 	ListCell   *lc;
+ 
+ 	/*
+ 	 * Do nothing in EXPLAIN (no ANALYZE) case.  node->fdw_state stays NULL.
+ 	 */
+ 	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
+ 		return;
+ 
+ 	/*
+ 	 * We'll save private state in node->fdw_state.
+ 	 */
+ 	dpstate = (PgFdwDmlPushdownState *) palloc0(sizeof(PgFdwDmlPushdownState));
+ 	node->fdw_state = (void *) dpstate;
+ 
+ 	/*
+ 	 * Identify which user to do the remote access as.  This should match what
+ 	 * ExecCheckRTEPerms() does.
+ 	 */
+ 	rte = rt_fetch(fsplan->scan.scanrelid, estate->es_range_table);
+ 	userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
+ 
+ 	/* Get info about foreign table. */
+ 	dpstate->rel = node->ss.ss_currentRelation;
+ 	table = GetForeignTable(RelationGetRelid(dpstate->rel));
+ 	server = GetForeignServer(table->serverid);
+ 	user = GetUserMapping(userid, server->serverid);
+ 
+ 	/*
+ 	 * Get connection to the foreign server.  Connection manager will
+ 	 * establish new connection if necessary.
+ 	 */
+ 	dpstate->conn = GetConnection(server, user, false);
+ 
+ 	/* Initialize state variable */
+ 	dpstate->num_tuples = -1;		/* -1 means not set yet */
+ 
+ 	/* Get private info created by planner functions. */
+ 	dpstate->query = strVal(list_nth(fsplan->fdw_private,
+ 									 FdwDmlPushdownPrivateUpdateSql));
+ 	dpstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateHasReturning));
+ 	dpstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 										FdwDmlPushdownPrivateRetrievedAttrs);
+ 	dpstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateSetProcessed));
+ 
+ 	/* Create context for per-tuple temp workspace. */
+ 	dpstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
+ 											  "postgres_fdw temporary data",
+ 											  ALLOCSET_SMALL_MINSIZE,
+ 											  ALLOCSET_SMALL_INITSIZE,
+ 											  ALLOCSET_SMALL_MAXSIZE);
+ 
+ 	/* Prepare for input conversion of RETURNING results. */
+ 	if (dpstate->has_returning)
+ 		dpstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(dpstate->rel));
+ 
+ 	/* Prepare for output conversion of parameters used in remote query. */
+ 	numParams = list_length(fsplan->fdw_exprs);
+ 	dpstate->numParams = numParams;
+ 	dpstate->param_flinfo = (FmgrInfo *) palloc0(sizeof(FmgrInfo) * numParams);
+ 
+ 	i = 0;
+ 	foreach(lc, fsplan->fdw_exprs)
+ 	{
+ 		Node	   *param_expr = (Node *) lfirst(lc);
+ 		Oid			typefnoid;
+ 		bool		isvarlena;
+ 
+ 		getTypeOutputInfo(exprType(param_expr), &typefnoid, &isvarlena);
+ 		fmgr_info(typefnoid, &dpstate->param_flinfo[i]);
+ 		i++;
+ 	}
+ 
+ 	/*
+ 	 * Prepare remote-parameter expressions for evaluation.  (Note: in
+ 	 * practice, we expect that all these expressions will be just Params, so
+ 	 * we could possibly do something more efficient than using the full
+ 	 * expression-eval machinery for this.  But probably there would be little
+ 	 * benefit, and it'd require postgres_fdw to know more than is desirable
+ 	 * about Param evaluation.)
+ 	 */
+ 	dpstate->param_exprs = (List *)
+ 		ExecInitExpr((Expr *) fsplan->fdw_exprs,
+ 					 (PlanState *) node);
+ 
+ 	/*
+ 	 * Allocate buffer for text form of query parameters, if any.
+ 	 */
+ 	if (numParams > 0)
+ 		dpstate->param_values = (const char **) palloc0(numParams * sizeof(char *));
+ 	else
+ 		dpstate->param_values = NULL;
+ }
+ 
+ /*
+  * postgresIterateDMLPushdown
+  *		Execute pushing down a foreign table modification to the remote server
+  */
+ static TupleTableSlot *
+ postgresIterateDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 
+ 	/*
+ 	 * If this is the first call after Begin, execute the statement.
+ 	 */
+ 	if (dpstate->num_tuples == -1)
+ 		execute_dml_stmt(node);
+ 
+ 	/*
+ 	 * If the local query doesn't specify RETURNING, just clear tuple slot.
+ 	 */
+ 	if (!resultRelInfo->ri_projectReturning)
+ 	{
+ 		TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 		Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 		Assert(!dpstate->has_returning);
+ 
+ 		/* Increment the command es_processed count if necessary. */
+ 		if (dpstate->set_processed)
+ 			estate->es_processed += dpstate->num_tuples;
+ 
+ 		/* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
+ 		if (instr)
+ 			instr->tuplecount += dpstate->num_tuples;
+ 
+ 		return ExecClearTuple(slot);
+ 	}
+ 
+ 	/*
+ 	 * Get the next RETURNING tuple.
+ 	 */
+ 	return get_returning_data(node);
+ }
+ 
+ /*
+  * postgresEndDMLPushdown
+  *		Finish pushing down a foreign table modification to the remote server
+  */
+ static void
+ postgresEndDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 
+ 	/* if dpstate is NULL, we are in EXPLAIN; nothing to do */
+ 	if (dpstate == NULL)
+ 		return;
+ 
+ 	/* Release PGresult */
+ 	if (dpstate->result)
+ 		PQclear(dpstate->result);
+ 
+ 	/* Release remote connection */
+ 	ReleaseConnection(dpstate->conn);
+ 	dpstate->conn = NULL;
+ 
+ 	/* MemoryContexts will be deleted automatically. */
+ }
+ 
+ /*
   * postgresExplainForeignScan
   *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
   */
***************
*** 1919,1924 **** postgresExplainForeignModify(ModifyTableState *mtstate,
--- 2318,2342 ----
  	}
  }
  
+ /*
+  * postgresExplainDMLPushdown
+  *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
+  *		that has pushed down an UPDATE/DELETE to the remote server
+  */
+ static void
+ postgresExplainDMLPushdown(ForeignScanState *node, ExplainState *es)
+ {
+ 	List	   *fdw_private;
+ 	char	   *sql;
+ 
+ 	if (es->verbose)
+ 	{
+ 		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
+ 		sql = strVal(list_nth(fdw_private, FdwDmlPushdownPrivateUpdateSql));
+ 		ExplainPropertyText("Remote SQL", sql, es);
+ 	}
+ }
+ 
  
  /*
   * estimate_path_cost_size
***************
*** 2535,2540 **** store_returning_result(PgFdwModifyState *fmstate,
--- 2953,3087 ----
  }
  
  /*
+  * Execute a pushed-down UPDATE/DELETE statement.
+  */
+ static void
+ execute_dml_stmt(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	ExprContext *econtext = node->ss.ps.ps_ExprContext;
+ 	int			numParams = dpstate->numParams;
+ 	const char **values = dpstate->param_values;
+ 
+ 	/*
+ 	 * Construct array of query parameter values in text format.
+ 	 */
+ 	if (numParams > 0)
+ 	{
+ 		int			nestlevel;
+ 		int			i;
+ 		ListCell   *lc;
+ 
+ 		nestlevel = set_transmission_modes();
+ 
+ 		i = 0;
+ 		foreach(lc, dpstate->param_exprs)
+ 		{
+ 			ExprState  *expr_state = (ExprState *) lfirst(lc);
+ 			Datum		expr_value;
+ 			bool		isNull;
+ 
+ 			/* Evaluate the parameter expression */
+ 			expr_value = ExecEvalExpr(expr_state, econtext, &isNull, NULL);
+ 
+ 			/*
+ 			 * Get string representation of each parameter value by invoking
+ 			 * type-specific output function, unless the value is null.
+ 			 */
+ 			if (isNull)
+ 				values[i] = NULL;
+ 			else
+ 				values[i] = OutputFunctionCall(&dpstate->param_flinfo[i],
+ 											   expr_value);
+ 			i++;
+ 		}
+ 
+ 		reset_transmission_modes(nestlevel);
+ 	}
+ 
+ 	/*
+ 	 * Notice that we pass NULL for paramTypes, thus forcing the remote server
+ 	 * to infer types for all parameters.  Since we explicitly cast every
+ 	 * parameter (see deparse.c), the "inference" is trivial and will produce
+ 	 * the desired result.  This allows us to avoid assuming that the remote
+ 	 * server has the same OIDs we do for the parameters' types.
+ 	 *
+ 	 * We don't use a PG_TRY block here, so be careful not to throw error
+ 	 * without releasing the PGresult.
+ 	 */
+ 	dpstate->result = PQexecParams(dpstate->conn, dpstate->query,
+ 								   numParams, NULL, values, NULL, NULL, 0);
+ 	if (PQresultStatus(dpstate->result) !=
+ 		(dpstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 		pgfdw_report_error(ERROR, dpstate->result, dpstate->conn, true,
+ 						   dpstate->query);
+ 
+ 	/* Get the number of rows affected. */
+ 	if (dpstate->has_returning)
+ 		dpstate->num_tuples = PQntuples(dpstate->result);
+ 	else
+ 		dpstate->num_tuples = atoi(PQcmdTuples(dpstate->result));
+ }
+ 
+ /*
+  * Get the result of a RETURNING clause.
+  */
+ static TupleTableSlot *
+ get_returning_data(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 
+ 	Assert(resultRelInfo->ri_projectReturning);
+ 
+ 	/* If we didn't get any tuples, must be end of data. */
+ 	if (dpstate->next_tuple >= dpstate->num_tuples)
+ 		return ExecClearTuple(slot);
+ 
+ 	/* Increment the command es_processed count if necessary. */
+ 	if (dpstate->set_processed)
+ 		estate->es_processed += 1;
+ 
+ 	/*
+ 	 * Store a RETURNING tuple.  Note that if the local query is of the form
+ 	 * e.g., UPDATE/DELETE .. RETURNING 1, we have has_returning=false, so
+ 	 * just emit a dummy tuple in that case.
+ 	 */
+ 	if (!dpstate->has_returning)
+ 		ExecStoreAllNullTuple(slot);
+ 	else
+ 	{
+ 		PG_TRY();
+ 		{
+ 			HeapTuple	newtup;
+ 
+ 			newtup = make_tuple_from_result_row(dpstate->result,
+ 												dpstate->next_tuple,
+ 												dpstate->rel,
+ 												dpstate->attinmeta,
+ 												dpstate->retrieved_attrs,
+ 												dpstate->temp_cxt);
+ 			ExecStoreTuple(newtup, slot, InvalidBuffer, false);
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			if (dpstate->result)
+ 				PQclear(dpstate->result);
+ 			PG_RE_THROW();
+ 		}
+ 		PG_END_TRY();
+ 	}
+ 	dpstate->next_tuple++;
+ 
+ 	/* Make slot available for evaluation of the local query RETURNING list. */
+ 	resultRelInfo->ri_projectReturning->pi_exprContext->ecxt_scantuple = slot;
+ 
+ 	return slot;
+ }
+ 
+ /*
   * postgresAnalyzeForeignTable
   *		Test whether analyzing this foreign table is supported
   */
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 103,112 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 103,126 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*targetlist,
+ 									   List *targetAttrs,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 399,416 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  EXPLAIN (verbose, costs off)
--- 399,420 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  EXPLAIN (verbose, costs off)
***************
*** 737,742 **** UPDATE rem1 SET f2 = 'testo';
--- 741,830 ----
  -- Test returning a system attribute
  INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ 
+ 
+ -- Test DML pushdown functionality
+ 
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_before ON rem1;
+ 
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_after ON rem1;
+ 
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ 
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_update ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_update ON rem1;
+ 
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_after_delete ON rem1;
+ 
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
***************
*** 868,873 **** fetch from c;
--- 956,968 ----
  update bar set f2 = null where current of c;
  rollback;
  
+ explain (verbose, costs off)
+ delete from foo where f1 < 5 returning *;
+ delete from foo where f1 < 5 returning *;
+ explain (verbose, costs off)
+ update bar set f2 = f2 + 100 returning *;
+ update bar set f2 = f2 + 100 returning *;
+ 
  drop table foo cascade;
  drop table bar cascade;
  drop table loct1;
*** a/doc/src/sgml/fdwhandler.sgml
--- b/doc/src/sgml/fdwhandler.sgml
***************
*** 664,669 **** IsForeignRelUpdatable (Relation rel);
--- 664,807 ----
       updatability for display in the <literal>information_schema</> views.)
      </para>
  
+     <para>
+ <programlisting>
+ bool
+ PlanDMLPushdown (PlannerInfo *root,
+                  ModifyTable *plan,
+                  Index resultRelation,
+                  int subplan_index);
+ </programlisting>
+ 
+      Decide whether it is safe to execute a foreign table update directly
+      on the remote server.  If so, return <literal>true</> after performing
+      planning actions needed for that.  Otherwise, return <literal>false</>.
+      This function is executed just before <function>PlanForeignModify</>
+      is called.  If this function succeeds, <function>PlanForeignModify</>
+      won't be executed, and <function>BeginDMLPushdown</>,
+      <function>IterateDMLPushdown</> and <function>EndDMLPushdown</> will
+      be called at the execution stage, instead.  Otherwise, the table update
+      will be executed using the table-updating functions described above.
+      The parameters are the same as for <function>PlanForeignModify</>.
+     </para>
+ 
+     <para>
+      To execute the table update directly on the remote server, this function
+      must rewrite the target subplan with a <structname>ForeignScan</> plan
+      node that executes the table update directly on the remote server.  The
+      <structfield>operation</> field of the <structname>ForeignScan</> must
+      be set to the <literal>CmdType</> enumeration appropriately; that is,
+      <literal>CMD_INSERT</> for <command>INSERT</>,
+      <literal>CMD_UPDATE</> for <command>UPDATE</>, and
+      <literal>CMD_DELETE</> for <command>DELETE</>.
+     </para>
+ 
+     <para>
+      See <xref linkend="fdw-planning"> for additional information.
+     </para>
+ 
+     <para>
+      If the <function>PlanDMLPushdown</> pointer is set to
+      <literal>NULL</>, no attempts to execute the table update directly on
+      the remote server are taken.
+     </para>
+ 
+     <para>
+ <programlisting>
+ void
+ BeginDMLPushdown (ForeignScanState *node,
+                   int eflags);
+ </programlisting>
+ 
+      Begin executing a foreign table update directly on the remote server.
+      This is called during executor startup.  It should perform any
+      initialization needed prior to the actual table update (that should be
+      done upon the first call to <function>IterateDMLPushdown</>).
+      The <structname>ForeignScanState</> node has already been created, but
+      its <structfield>fdw_state</> field is still NULL.  Information about
+      the table to update is accessible through the
+      <structname>ForeignScanState</> node (in particular, from the underlying
+      <structname>ForeignScan</> plan node, which contains any FDW-private
+      information provided by <function>PlanDMLPushdown</>).
+      <literal>eflags</> contains flag bits describing the executor's
+      operating mode for this plan node.
+     </para>
+ 
+     <para>
+      Note that when <literal>(eflags &amp; EXEC_FLAG_EXPLAIN_ONLY)</> is
+      true, this function should not perform any externally-visible actions;
+      it should only do the minimum required to make the node state valid
+      for <function>ExplainDMLPushdown</> and <function>EndDMLPushdown</>.
+     </para>
+ 
+     <para>
+      If the <function>BeginDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
+     <para>
+ <programlisting>
+ TupleTableSlot *
+ IterateDMLPushdown (ForeignScanState *node);
+ </programlisting>
+ 
+      When the <command>INSERT</>, <command>UPDATE</> or <command>DELETE</>
+      query doesn't have a <literal>RETURNING</> clause, just return NULL
+      after the actual table update directly executed on the remote server.
+      When the query has the clause, fetch one result containing the data
+      needed for the <literal>RETURNING</> calculation, returning it in a
+      tuple table slot (the node's <structfield>ScanTupleSlot</> should be
+      used for this purpose).  The data that was actually inserted, updated
+      or deleted must be provided to
+      <literal>rinfo-&gt;ri_projectReturning</>.
+      Return NULL if no more rows are available.
+      Note that this is called in a short-lived memory context that will be
+      reset between invocations.  Create a memory context in
+      <function>BeginDMLPushdown</> if you need longer-lived storage, or use
+      the <structfield>es_query_cxt</> of the node's <structname>EState</>.
+     </para>
+ 
+     <para>
+      The rows returned must match the <structfield>fdw_scan_tlist</> target
+      list if one was supplied, otherwise they must match the row type of the
+      foreign table being updated.  If you choose to optimize away fetching
+      columns that are not needed for the <literal>RETURNING</> calculation,
+      you should insert nulls in those column positions, or else generate a
+      <structfield>fdw_scan_tlist</> list with those columns omitted.
+     </para>
+ 
+     <para>
+      Whether the query has the clause or not, the query's reported row count 
+      must be incremented by the FDW itself.  When the query doesn't has the
+      clause, the FDW must also increment the row count for the
+      <structname>ForeignScanState</> node in the <command>EXPLAIN ANALYZE</>
+      case.
+     </para>
+ 
+     <para>
+      If the <function>IterateDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
+     <para>
+ <programlisting>
+ void
+ EndDMLPushdown (ForeignScanState *node);
+ </programlisting>
+ 
+      End the table update and release resources.  It is normally not important
+      to release palloc'd memory, but for example open files and connections
+      to remote servers should be cleaned up.
+     </para>
+ 
+     <para>
+      If the <function>EndDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
     </sect2>
  
     <sect2 id="fdw-callbacks-row-locking">
***************
*** 848,853 **** ExplainForeignModify (ModifyTableState *mtstate,
--- 986,1014 ----
       <command>EXPLAIN</>.
      </para>
  
+     <para>
+ <programlisting>
+ void
+ ExplainDMLPushdown (ForeignScanState *node,
+                     ExplainState *es);
+ </programlisting>
+ 
+      Print additional <command>EXPLAIN</> output for a foreign table update
+      that is executed directly on the remote server.
+      This function can call <function>ExplainPropertyText</> and
+      related functions to add fields to the <command>EXPLAIN</> output.
+      The flag fields in <literal>es</> can be used to determine what to
+      print, and the state of the <structname>ForeignScanState</> node
+      can be inspected to provide run-time statistics in the <command>EXPLAIN
+      ANALYZE</> case.
+     </para>
+ 
+     <para>
+      If the <function>ExplainDMLPushdown</> pointer is set to
+      <literal>NULL</>, no additional information is printed during
+      <command>EXPLAIN</>.
+     </para>
+ 
     </sect2>
  
     <sect2 id="fdw-callbacks-analyze">
***************
*** 1068,1074 **** GetForeignServerByName(const char *name, bool missing_ok);
      <para>
       The FDW callback functions <function>GetForeignRelSize</>,
       <function>GetForeignPaths</>, <function>GetForeignPlan</>,
!      <function>PlanForeignModify</>, and <function>GetForeignJoinPaths</>
       must fit into the workings of the <productname>PostgreSQL</> planner.
       Here are some notes about what they must do.
      </para>
--- 1229,1236 ----
      <para>
       The FDW callback functions <function>GetForeignRelSize</>,
       <function>GetForeignPaths</>, <function>GetForeignPlan</>,
!      <function>PlanForeignModify</>, <function>GetForeignJoinPaths</>, and
!      <function>PlanDMLPushdown</>
       must fit into the workings of the <productname>PostgreSQL</> planner.
       Here are some notes about what they must do.
      </para>
***************
*** 1228,1236 **** GetForeignServerByName(const char *name, bool missing_ok);
  
      <para>
       When planning an <command>UPDATE</> or <command>DELETE</>,
!      <function>PlanForeignModify</> can look up the <structname>RelOptInfo</>
!      struct for the foreign table and make use of the
!      <literal>baserel-&gt;fdw_private</> data previously created by the
       scan-planning functions.  However, in <command>INSERT</> the target
       table is not scanned so there is no <structname>RelOptInfo</> for it.
       The <structname>List</> returned by <function>PlanForeignModify</> has
--- 1390,1398 ----
  
      <para>
       When planning an <command>UPDATE</> or <command>DELETE</>,
!      <function>PlanForeignModify</> and <function>PlanDMLPushdown</> can look
!      up the <structname>RelOptInfo</> struct for the foreign table and make use
!      of the <literal>baserel-&gt;fdw_private</> data previously created by the
       scan-planning functions.  However, in <command>INSERT</> the target
       table is not scanned so there is no <structname>RelOptInfo</> for it.
       The <structname>List</> returned by <function>PlanForeignModify</> has
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 471,476 ****
--- 471,485 ----
     extension that's listed in the foreign server's <literal>extensions</>
     option.  Operators and functions in such clauses must
     be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, and no row-level local <literal>BEFORE</> or
+    <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, or <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 888,894 **** ExplainNode(PlanState *planstate, List *ancestors,
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			pname = sname = "Foreign Scan";
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
--- 888,916 ----
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			sname = "Foreign Scan";
! 			switch (((ForeignScan *) plan)->operation)
! 			{
! 				case CMD_SELECT:
! 					pname = "Foreign Scan";
! 					operation = "Select";
! 					break;
! 				case CMD_INSERT:
! 					pname = "Foreign Insert";
! 					operation = "Insert";
! 					break;
! 				case CMD_UPDATE:
! 					pname = "Foreign Update";
! 					operation = "Update";
! 					break;
! 				case CMD_DELETE:
! 					pname = "Foreign Delete";
! 					operation = "Delete";
! 					break;
! 				default:
! 					pname = "???";
! 					break;
! 			}
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
***************
*** 1636,1641 **** show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
--- 1658,1669 ----
  		return;
  	if (IsA(plan, RecursiveUnion))
  		return;
+ 	/* Likewise for ForeignScan that has pushed down INSERT/UPDATE/DELETE */
+ 	if (IsA(plan, ForeignScan) &&
+ 		(((ForeignScan *) plan)->operation == CMD_INSERT ||
+ 		 ((ForeignScan *) plan)->operation == CMD_UPDATE ||
+ 		 ((ForeignScan *) plan)->operation == CMD_DELETE))
+ 		return;
  
  	/* Set up deparsing context */
  	context = set_deparse_context_planstate(es->deparse_cxt,
***************
*** 2224,2231 **** show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es)
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (fdwroutine->ExplainForeignScan != NULL)
! 		fdwroutine->ExplainForeignScan(fsstate, es);
  }
  
  /*
--- 2252,2267 ----
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (((ForeignScan *) fsstate->ss.ps.plan)->operation != CMD_SELECT)
! 	{
! 		if (fdwroutine->ExplainDMLPushdown != NULL)
! 			fdwroutine->ExplainDMLPushdown(fsstate, es);
! 	}
! 	else
! 	{
! 		if (fdwroutine->ExplainForeignScan != NULL)
! 			fdwroutine->ExplainForeignScan(fsstate, es);
! 	}
  }
  
  /*
***************
*** 2611,2618 **** show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
  			}
  		}
  
! 		/* Give FDW a chance */
! 		if (fdwroutine && fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
--- 2647,2656 ----
  			}
  		}
  
! 		/* Give FDW a chance if needed */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			fdwroutine != NULL &&
! 			fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1011,1020 **** InitPlan(QueryDesc *queryDesc, int eflags)
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(Relation resultRel, CmdType operation)
  {
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
  
  	switch (resultRel->rd_rel->relkind)
  	{
--- 1011,1022 ----
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
  {
+ 	Relation	resultRel = resultRelInfo->ri_RelationDesc;
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
+ 	bool		allow_pushdown;
  
  	switch (resultRel->rd_rel->relkind)
  	{
***************
*** 1083,1096 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  		case RELKIND_FOREIGN_TABLE:
  			/* Okay only if the FDW supports it */
  			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
  			switch (operation)
  			{
  				case CMD_INSERT:
! 					if (fdwroutine->ExecForeignInsert == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 							errmsg("cannot insert into foreign table \"%s\"",
! 								   RelationGetRelationName(resultRel))));
  					if (fdwroutine->IsForeignRelUpdatable != NULL &&
  						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
  						ereport(ERROR,
--- 1085,1107 ----
  		case RELKIND_FOREIGN_TABLE:
  			/* Okay only if the FDW supports it */
  			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
+ 			allow_pushdown = ((fdwroutine->BeginDMLPushdown != NULL) &&
+ 							  (fdwroutine->IterateDMLPushdown != NULL) &&
+ 							  (fdwroutine->EndDMLPushdown != NULL));
  			switch (operation)
  			{
  				case CMD_INSERT:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down insert on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignInsert == NULL)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot insert into foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
  					if (fdwroutine->IsForeignRelUpdatable != NULL &&
  						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
  						ereport(ERROR,
***************
*** 1099,1105 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_UPDATE:
! 					if (fdwroutine->ExecForeignUpdate == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  								 errmsg("cannot update foreign table \"%s\"",
--- 1110,1122 ----
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_UPDATE:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down update on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignUpdate == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  								 errmsg("cannot update foreign table \"%s\"",
***************
*** 1112,1118 **** CheckValidResultRel(Relation resultRel, CmdType operation)
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_DELETE:
! 					if (fdwroutine->ExecForeignDelete == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  							errmsg("cannot delete from foreign table \"%s\"",
--- 1129,1141 ----
  							   RelationGetRelationName(resultRel))));
  					break;
  				case CMD_DELETE:
! 					if (resultRelInfo->ri_FdwPushdown && !allow_pushdown)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("cannot push down delete on foreign table \"%s\"",
! 										RelationGetRelationName(resultRel))));
! 					if (!resultRelInfo->ri_FdwPushdown &&
! 						fdwroutine->ExecForeignDelete == NULL)
  						ereport(ERROR,
  								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  							errmsg("cannot delete from foreign table \"%s\"",
***************
*** 1245,1250 **** InitResultRelInfo(ResultRelInfo *resultRelInfo,
--- 1268,1274 ----
  	else
  		resultRelInfo->ri_FdwRoutine = NULL;
  	resultRelInfo->ri_FdwState = NULL;
+ 	resultRelInfo->ri_FdwPushdown = false;
  	resultRelInfo->ri_ConstraintExprs = NULL;
  	resultRelInfo->ri_junkFilter = NULL;
  	resultRelInfo->ri_projectReturning = NULL;
*** a/src/backend/executor/nodeForeignscan.c
--- b/src/backend/executor/nodeForeignscan.c
***************
*** 48,54 **** ForeignNext(ForeignScanState *node)
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
--- 48,57 ----
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	if (plan->operation != CMD_SELECT)
! 		slot = node->fdwroutine->IterateDMLPushdown(node);
! 	else
! 		slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
***************
*** 226,232 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
--- 229,238 ----
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	if (node->operation != CMD_SELECT)
! 		fdwroutine->BeginDMLPushdown(scanstate, eflags);
! 	else
! 		fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
***************
*** 240,247 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
  	/* Let the FDW shut down */
! 	node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
--- 246,258 ----
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
+ 	ForeignScan *plan = (ForeignScan *) node->ss.ps.plan;
+ 
  	/* Let the FDW shut down */
! 	if (plan->operation != CMD_SELECT)
! 		node->fdwroutine->EndDMLPushdown(node);
! 	else
! 		node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
*** a/src/backend/executor/nodeModifyTable.c
--- b/src/backend/executor/nodeModifyTable.c
***************
*** 138,150 **** ExecCheckPlanOutput(Relation resultRel, List *targetList)
   * tupleSlot: slot holding tuple actually inserted/updated/deleted
   * planSlot: slot holding tuple returned by top subplan node
   *
   * Returns a slot holding the result tuple
   */
  static TupleTableSlot *
! ExecProcessReturning(ProjectionInfo *projectReturning,
  					 TupleTableSlot *tupleSlot,
  					 TupleTableSlot *planSlot)
  {
  	ExprContext *econtext = projectReturning->pi_exprContext;
  
  	/*
--- 138,154 ----
   * tupleSlot: slot holding tuple actually inserted/updated/deleted
   * planSlot: slot holding tuple returned by top subplan node
   *
+  * Note: If tupleSlot is NULL, the FDW should have already provided econtext's
+  * scan tuple.
+  *
   * Returns a slot holding the result tuple
   */
  static TupleTableSlot *
! ExecProcessReturning(ResultRelInfo *resultRelInfo,
  					 TupleTableSlot *tupleSlot,
  					 TupleTableSlot *planSlot)
  {
+ 	ProjectionInfo *projectReturning = resultRelInfo->ri_projectReturning;
  	ExprContext *econtext = projectReturning->pi_exprContext;
  
  	/*
***************
*** 154,160 **** ExecProcessReturning(ProjectionInfo *projectReturning,
  	ResetExprContext(econtext);
  
  	/* Make tuple and any needed join variables available to ExecProject */
! 	econtext->ecxt_scantuple = tupleSlot;
  	econtext->ecxt_outertuple = planSlot;
  
  	/* Compute the RETURNING expressions */
--- 158,177 ----
  	ResetExprContext(econtext);
  
  	/* Make tuple and any needed join variables available to ExecProject */
! 	if (tupleSlot)
! 		econtext->ecxt_scantuple = tupleSlot;
! 	else
! 	{
! 		HeapTuple	tuple;
! 
! 		/*
! 		 * RETURNING expressions might reference the tableoid column, so
! 		 * initialize t_tableOid before evaluating them.
! 		 */
! 		Assert(!TupIsNull(econtext->ecxt_scantuple));
! 		tuple = ExecMaterializeSlot(econtext->ecxt_scantuple);
! 		tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
! 	}
  	econtext->ecxt_outertuple = planSlot;
  
  	/* Compute the RETURNING expressions */
***************
*** 496,503 **** ExecInsert(ModifyTableState *mtstate,
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									slot, planSlot);
  
  	return NULL;
  }
--- 513,519 ----
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  	return NULL;
  }
***************
*** 738,745 **** ldelete:;
  			ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);
  		}
  
! 		rslot = ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									 slot, planSlot);
  
  		/*
  		 * Before releasing the target tuple again, make sure rslot has a
--- 754,760 ----
  			ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);
  		}
  
! 		rslot = ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  		/*
  		 * Before releasing the target tuple again, make sure rslot has a
***************
*** 1024,1031 **** lreplace:;
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									slot, planSlot);
  
  	return NULL;
  }
--- 1039,1045 ----
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  	return NULL;
  }
***************
*** 1380,1385 **** ExecModifyTable(ModifyTableState *node)
--- 1394,1414 ----
  				break;
  		}
  
+ 		/*
+ 		 * If ri_FdwPushdown is true, all we need to do here is compute the
+ 		 * RETURNING expressions.
+ 		 */
+ 		if (resultRelInfo->ri_FdwPushdown)
+ 		{
+ 			Assert(resultRelInfo->ri_projectReturning);
+ 
+ 			/* No need to provide scan tuple to ExecProcessReturning. */
+ 			slot = ExecProcessReturning(resultRelInfo, NULL, planSlot);
+ 
+ 			estate->es_result_relation_info = saved_resultRelInfo;
+ 			return slot;
+ 		}
+ 
  		EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
  		slot = planSlot;
  
***************
*** 1559,1568 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  	{
  		subplan = (Plan *) lfirst(l);
  
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo->ri_RelationDesc, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
--- 1588,1600 ----
  	{
  		subplan = (Plan *) lfirst(l);
  
+ 		/* Initialize the FdwPushdown flag */
+ 		resultRelInfo->ri_FdwPushdown = list_nth_int(node->fdwPushdowns, i);
+ 
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
***************
*** 1583,1589 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
--- 1615,1622 ----
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
***************
*** 1754,1766 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1787,1811 ----
  		erm = ExecFindRowMark(estate, rc->rti, false);
  
  		/* build ExecAuxRowMark for each subplan */
+ 		resultRelInfo = mtstate->resultRelInfo;
  		for (i = 0; i < nplans; i++)
  		{
  			ExecAuxRowMark *aerm;
  
+ 			/*
+ 			 * ignore subplan if the FDW pushes down the command to the remote
+ 			 * server
+ 			 */
+ 			if (resultRelInfo->ri_FdwPushdown)
+ 			{
+ 				resultRelInfo++;
+ 				continue;
+ 			}
+ 
  			subplan = mtstate->mt_plans[i]->plan;
  			aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
  			mtstate->mt_arowmarks[i] = lappend(mtstate->mt_arowmarks[i], aerm);
+ 			resultRelInfo++;
  		}
  	}
  
***************
*** 1821,1826 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1866,1881 ----
  					ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
  										subplan->targetlist);
  
+ 				/*
+ 				 * ignore subplan if the FDW pushes down the command to the
+ 				 * remote server
+ 				 */
+ 				if (resultRelInfo->ri_FdwPushdown)
+ 				{
+ 					resultRelInfo++;
+ 					continue;
+ 				}
+ 
  				j = ExecInitJunkFilter(subplan->targetlist,
  							resultRelInfo->ri_RelationDesc->rd_att->tdhasoid,
  									   ExecInitExtraTupleSlot(estate));
***************
*** 1910,1916 **** ExecEndModifyTable(ModifyTableState *node)
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
--- 1965,1972 ----
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 186,191 **** _copyModifyTable(const ModifyTable *from)
--- 186,192 ----
  	COPY_NODE_FIELD(withCheckOptionLists);
  	COPY_NODE_FIELD(returningLists);
  	COPY_NODE_FIELD(fdwPrivLists);
+ 	COPY_NODE_FIELD(fdwPushdowns);
  	COPY_NODE_FIELD(rowMarks);
  	COPY_SCALAR_FIELD(epqParam);
  	COPY_SCALAR_FIELD(onConflictAction);
***************
*** 645,650 **** _copyForeignScan(const ForeignScan *from)
--- 646,652 ----
  	/*
  	 * copy remainder of node
  	 */
+ 	COPY_SCALAR_FIELD(operation);
  	COPY_SCALAR_FIELD(fs_server);
  	COPY_NODE_FIELD(fdw_exprs);
  	COPY_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 340,345 **** _outModifyTable(StringInfo str, const ModifyTable *node)
--- 340,346 ----
  	WRITE_NODE_FIELD(withCheckOptionLists);
  	WRITE_NODE_FIELD(returningLists);
  	WRITE_NODE_FIELD(fdwPrivLists);
+ 	WRITE_NODE_FIELD(fdwPushdowns);
  	WRITE_NODE_FIELD(rowMarks);
  	WRITE_INT_FIELD(epqParam);
  	WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
***************
*** 591,596 **** _outForeignScan(StringInfo str, const ForeignScan *node)
--- 592,598 ----
  
  	_outScanInfo(str, (const Scan *) node);
  
+ 	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_OID_FIELD(fs_server);
  	WRITE_NODE_FIELD(fdw_exprs);
  	WRITE_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/readfuncs.c
--- b/src/backend/nodes/readfuncs.c
***************
*** 1471,1476 **** _readModifyTable(void)
--- 1471,1477 ----
  	READ_NODE_FIELD(withCheckOptionLists);
  	READ_NODE_FIELD(returningLists);
  	READ_NODE_FIELD(fdwPrivLists);
+ 	READ_NODE_FIELD(fdwPushdowns);
  	READ_NODE_FIELD(rowMarks);
  	READ_INT_FIELD(epqParam);
  	READ_ENUM_FIELD(onConflictAction, OnConflictAction);
*** a/src/backend/optimizer/plan/createplan.c
--- b/src/backend/optimizer/plan/createplan.c
***************
*** 3770,3775 **** make_foreignscan(List *qptlist,
--- 3770,3776 ----
  	plan->lefttree = outer_plan;
  	plan->righttree = NULL;
  	node->scan.scanrelid = scanrelid;
+ 	node->operation = CMD_SELECT;
  	/* fs_server will be filled in by create_foreignscan_plan */
  	node->fs_server = InvalidOid;
  	node->fdw_exprs = fdw_exprs;
***************
*** 5046,5051 **** make_modifytable(PlannerInfo *root,
--- 5047,5053 ----
  	Plan	   *plan = &node->plan;
  	double		total_size;
  	List	   *fdw_private_list;
+ 	List	   *fdwpushdown_list;
  	ListCell   *subnode;
  	ListCell   *lc;
  	int			i;
***************
*** 5126,5137 **** make_modifytable(PlannerInfo *root,
--- 5128,5141 ----
  	 * construct private plan data, and accumulate it all into a list.
  	 */
  	fdw_private_list = NIL;
+ 	fdwpushdown_list = NIL;
  	i = 0;
  	foreach(lc, resultRelations)
  	{
  		Index		rti = lfirst_int(lc);
  		FdwRoutine *fdwroutine;
  		List	   *fdw_private;
+ 		bool		fdwpushdown;
  
  		/*
  		 * If possible, we want to get the FdwRoutine from our RelOptInfo for
***************
*** 5158,5164 **** make_modifytable(PlannerInfo *root,
--- 5162,5181 ----
  				fdwroutine = NULL;
  		}
  
+ 		/*
+ 		 * If the target relation has any row-level triggers, we can't push
+ 		 * down the command to the remote server.
+ 		 */
  		if (fdwroutine != NULL &&
+ 			fdwroutine->PlanDMLPushdown != NULL &&
+ 			!has_row_triggers(root, rti, operation))
+ 			fdwpushdown = fdwroutine->PlanDMLPushdown(root, node, rti, i);
+ 		else
+ 			fdwpushdown = false;
+ 		fdwpushdown_list = lappend_int(fdwpushdown_list, fdwpushdown);
+ 
+ 		if (!fdwpushdown &&
+ 			fdwroutine != NULL &&
  			fdwroutine->PlanForeignModify != NULL)
  			fdw_private = fdwroutine->PlanForeignModify(root, node, rti, i);
  		else
***************
*** 5167,5172 **** make_modifytable(PlannerInfo *root,
--- 5184,5190 ----
  		i++;
  	}
  	node->fdwPrivLists = fdw_private_list;
+ 	node->fdwPushdowns = fdwpushdown_list;
  
  	return node;
  }
*** a/src/backend/optimizer/util/plancat.c
--- b/src/backend/optimizer/util/plancat.c
***************
*** 1520,1522 **** has_unique_index(RelOptInfo *rel, AttrNumber attno)
--- 1520,1569 ----
  	}
  	return false;
  }
+ 
+ 
+ /*
+  * has_row_triggers
+  *
+  * Detect whether the specified relation has any row-level triggers for event.
+  */
+ bool
+ has_row_triggers(PlannerInfo *root, Index rti, CmdType event)
+ {
+ 	RangeTblEntry *rte = planner_rt_fetch(rti, root);
+ 	Relation	relation;
+ 	TriggerDesc *trigDesc;
+ 	bool		result = false;
+ 
+ 	/* Assume we already have adequate lock */
+ 	relation = heap_open(rte->relid, NoLock);
+ 
+ 	trigDesc = relation->trigdesc;
+ 	switch (event)
+ 	{
+ 		case CMD_INSERT:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_insert_after_row ||
+ 				 trigDesc->trig_insert_before_row))
+ 				result = true;
+ 			break;
+ 		case CMD_UPDATE:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_update_after_row ||
+ 				 trigDesc->trig_update_before_row))
+ 				result = true;
+ 			break;
+ 		case CMD_DELETE:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_delete_after_row ||
+ 				 trigDesc->trig_delete_before_row))
+ 				result = true;
+ 			break;
+ 		default:
+ 			elog(ERROR, "unrecognized CmdType: %d", (int) event);
+ 			break;
+ 	}
+ 
+ 	heap_close(relation, NoLock);
+ 	return result;
+ }
*** a/src/include/executor/executor.h
--- b/src/include/executor/executor.h
***************
*** 184,190 **** extern void ExecutorEnd(QueryDesc *queryDesc);
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(Relation resultRel, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
--- 184,190 ----
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
*** a/src/include/foreign/fdwapi.h
--- b/src/include/foreign/fdwapi.h
***************
*** 93,98 **** typedef void (*EndForeignModify_function) (EState *estate,
--- 93,110 ----
  
  typedef int (*IsForeignRelUpdatable_function) (Relation rel);
  
+ typedef bool (*PlanDMLPushdown_function) (PlannerInfo *root,
+ 										  ModifyTable *plan,
+ 										  Index resultRelation,
+ 										  int subplan_index);
+ 
+ typedef void (*BeginDMLPushdown_function) (ForeignScanState *node,
+ 										   int eflags);
+ 
+ typedef TupleTableSlot *(*IterateDMLPushdown_function) (ForeignScanState *node);
+ 
+ typedef void (*EndDMLPushdown_function) (ForeignScanState *node);
+ 
  typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
  												LockClauseStrength strength);
  
***************
*** 110,115 **** typedef void (*ExplainForeignModify_function) (ModifyTableState *mtstate,
--- 122,130 ----
  														   int subplan_index,
  													struct ExplainState *es);
  
+ typedef void (*ExplainDMLPushdown_function) (ForeignScanState *node,
+ 													struct ExplainState *es);
+ 
  typedef int (*AcquireSampleRowsFunc) (Relation relation, int elevel,
  											   HeapTuple *rows, int targrows,
  												  double *totalrows,
***************
*** 162,167 **** typedef struct FdwRoutine
--- 177,186 ----
  	ExecForeignDelete_function ExecForeignDelete;
  	EndForeignModify_function EndForeignModify;
  	IsForeignRelUpdatable_function IsForeignRelUpdatable;
+ 	PlanDMLPushdown_function PlanDMLPushdown;
+ 	BeginDMLPushdown_function BeginDMLPushdown;
+ 	IterateDMLPushdown_function IterateDMLPushdown;
+ 	EndDMLPushdown_function EndDMLPushdown;
  
  	/* Functions for SELECT FOR UPDATE/SHARE row locking */
  	GetForeignRowMarkType_function GetForeignRowMarkType;
***************
*** 171,176 **** typedef struct FdwRoutine
--- 190,196 ----
  	/* Support functions for EXPLAIN */
  	ExplainForeignScan_function ExplainForeignScan;
  	ExplainForeignModify_function ExplainForeignModify;
+ 	ExplainDMLPushdown_function ExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	AnalyzeForeignTable_function AnalyzeForeignTable;
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 311,316 **** typedef struct JunkFilter
--- 311,317 ----
   *		TrigInstrument			optional runtime measurements for triggers
   *		FdwRoutine				FDW callback functions, if foreign table
   *		FdwState				available to save private state of FDW
+  *		FdwPushdown				true when the command is pushed down
   *		WithCheckOptions		list of WithCheckOption's to be checked
   *		WithCheckOptionExprs	list of WithCheckOption expr states
   *		ConstraintExprs			array of constraint-checking expr states
***************
*** 334,339 **** typedef struct ResultRelInfo
--- 335,341 ----
  	Instrumentation *ri_TrigInstrument;
  	struct FdwRoutine *ri_FdwRoutine;
  	void	   *ri_FdwState;
+ 	bool		ri_FdwPushdown;
  	List	   *ri_WithCheckOptions;
  	List	   *ri_WithCheckOptionExprs;
  	List	  **ri_ConstraintExprs;
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
***************
*** 188,193 **** typedef struct ModifyTable
--- 188,194 ----
  	List	   *withCheckOptionLists;	/* per-target-table WCO lists */
  	List	   *returningLists; /* per-target-table RETURNING tlists */
  	List	   *fdwPrivLists;	/* per-target-table FDW private data lists */
+ 	List	   *fdwPushdowns;	/* per-target-table FDW pushdown flags */
  	List	   *rowMarks;		/* PlanRowMarks (non-locking only) */
  	int			epqParam;		/* ID of Param for EvalPlanQual re-eval */
  	OnConflictAction onConflictAction;	/* ON CONFLICT action */
***************
*** 530,535 **** typedef struct WorkTableScan
--- 531,537 ----
  typedef struct ForeignScan
  {
  	Scan		scan;
+ 	CmdType		operation;		/* SELECT/INSERT/UPDATE/DELETE */
  	Oid			fs_server;		/* OID of foreign server */
  	List	   *fdw_exprs;		/* expressions that FDW may evaluate */
  	List	   *fdw_private;	/* private data for FDW */
*** a/src/include/optimizer/plancat.h
--- b/src/include/optimizer/plancat.h
***************
*** 55,58 **** extern Selectivity join_selectivity(PlannerInfo *root,
--- 55,60 ----
  				 JoinType jointype,
  				 SpecialJoinInfo *sjinfo);
  
+ extern bool has_row_triggers(PlannerInfo *root, Index rti, CmdType event);
+ 
  #endif   /* PLANCAT_H */

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 110,115 **** static void deparseTargetList(StringInfo buf,
--- 110,116 ----
  				  PlannerInfo *root,
  				  Index rtindex,
  				  Relation rel,
+ 				  bool is_returning,
  				  Bitmapset *attrs_used,
  				  List **retrieved_attrs);
  static void deparseReturningList(StringInfo buf, PlannerInfo *root,
***************
*** 724,730 **** deparseSelectSql(StringInfo buf,
  	 * Construct SELECT list
  	 */
  	appendStringInfoString(buf, "SELECT ");
! 	deparseTargetList(buf, root, baserel->relid, rel, attrs_used,
  					  retrieved_attrs);
  
  	/*
--- 725,731 ----
  	 * Construct SELECT list
  	 */
  	appendStringInfoString(buf, "SELECT ");
! 	deparseTargetList(buf, root, baserel->relid, rel, false, attrs_used,
  					  retrieved_attrs);
  
  	/*
***************
*** 738,744 **** deparseSelectSql(StringInfo buf,
  
  /*
   * Emit a target list that retrieves the columns specified in attrs_used.
!  * This is used for both SELECT and RETURNING targetlists.
   *
   * The tlist text is appended to buf, and we also create an integer List
   * of the columns being retrieved, which is returned to *retrieved_attrs.
--- 739,746 ----
  
  /*
   * Emit a target list that retrieves the columns specified in attrs_used.
!  * This is used for both SELECT and RETURNING targetlists; the is_returning
!  * parameter is true only for a RETURNING targetlist.
   *
   * The tlist text is appended to buf, and we also create an integer List
   * of the columns being retrieved, which is returned to *retrieved_attrs.
***************
*** 748,753 **** deparseTargetList(StringInfo buf,
--- 750,756 ----
  				  PlannerInfo *root,
  				  Index rtindex,
  				  Relation rel,
+ 				  bool is_returning,
  				  Bitmapset *attrs_used,
  				  List **retrieved_attrs)
  {
***************
*** 777,782 **** deparseTargetList(StringInfo buf,
--- 780,787 ----
  		{
  			if (!first)
  				appendStringInfoString(buf, ", ");
+ 			else if (is_returning)
+ 				appendStringInfoString(buf, " RETURNING ");
  			first = false;
  
  			deparseColumnRef(buf, rtindex, i, root);
***************
*** 794,799 **** deparseTargetList(StringInfo buf,
--- 799,806 ----
  	{
  		if (!first)
  			appendStringInfoString(buf, ", ");
+ 		else if (is_returning)
+ 			appendStringInfoString(buf, " RETURNING ");
  		first = false;
  
  		appendStringInfoString(buf, "ctid");
***************
*** 803,809 **** deparseTargetList(StringInfo buf,
  	}
  
  	/* Don't generate bad syntax if no undropped columns */
! 	if (first)
  		appendStringInfoString(buf, "NULL");
  }
  
--- 810,816 ----
  	}
  
  	/* Don't generate bad syntax if no undropped columns */
! 	if (first && !is_returning)
  		appendStringInfoString(buf, "NULL");
  }
  
***************
*** 1022,1032 **** deparseReturningList(StringInfo buf, PlannerInfo *root,
  	}
  
  	if (attrs_used != NULL)
! 	{
! 		appendStringInfoString(buf, " RETURNING ");
! 		deparseTargetList(buf, root, rtindex, rel, attrs_used,
  						  retrieved_attrs);
- 	}
  	else
  		*retrieved_attrs = NIL;
  }
--- 1029,1036 ----
  	}
  
  	if (attrs_used != NULL)
! 		deparseTargetList(buf, root, rtindex, rel, true, attrs_used,
  						  retrieved_attrs);
  	else
  		*retrieved_attrs = NIL;
  }
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 2408,2413 **** SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
--- 2408,2466 ----
   1104 | 204 | ddd                | 
  (819 rows)
  
+ EXPLAIN (verbose, costs off)
+ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+                                                                                            QUERY PLAN                                                                                            
+ -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Insert on public.ft2
+    Output: (tableoid)::regclass
+    Remote SQL: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6, c7, c8) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+    ->  Result
+          Output: 9999, 999, NULL::integer, 'foo'::text, NULL::timestamp with time zone, NULL::timestamp without time zone, NULL::character varying, 'ft2       '::character(10), NULL::user_enum
+ (5 rows)
+ 
+ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+  tableoid 
+ ----------
+  ft2
+ (1 row)
+ 
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+                                                     QUERY PLAN                                                     
+ -------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: (tableoid)::regclass
+    Remote SQL: UPDATE "S 1"."T 1" SET c3 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: c1, c2, NULL::integer, 'bar'::text, c4, c5, c6, c7, c8, ctid
+          Remote SQL: SELECT "C 1", c2, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
+ (6 rows)
+ 
+ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+  tableoid 
+ ----------
+  ft2
+ (1 row)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+                                      QUERY PLAN                                     
+ ------------------------------------------------------------------------------------
+  Delete on public.ft2
+    Output: (tableoid)::regclass
+    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1
+    ->  Foreign Scan on public.ft2
+          Output: ctid
+          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
+ (6 rows)
+ 
+ DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+  tableoid 
+ ----------
+  ft2
+ (1 row)
+ 
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
  BEGIN
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 1614,1619 **** postgresExecForeignInsert(EState *estate,
--- 1614,1620 ----
  	const char **p_values;
  	PGresult   *res;
  	int			n_rows;
+ 	HeapTuple	tuple;
  
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
***************
*** 1654,1659 **** postgresExecForeignInsert(EState *estate,
--- 1655,1667 ----
  
  	MemoryContextReset(fmstate->temp_cxt);
  
+ 	/*
+ 	 * AFTER ROW Triggers or RETURNING expressions might reference the tableoid
+ 	 * column, so initialize t_tableOid before evaluating them.
+ 	 */
+ 	tuple = ExecMaterializeSlot(slot);
+ 	tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
+ 
  	/* Return NULL if nothing was inserted on the remote end */
  	return (n_rows > 0) ? slot : NULL;
  }
***************
*** 1674,1679 **** postgresExecForeignUpdate(EState *estate,
--- 1682,1688 ----
  	const char **p_values;
  	PGresult   *res;
  	int			n_rows;
+ 	HeapTuple	tuple;
  
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
***************
*** 1724,1729 **** postgresExecForeignUpdate(EState *estate,
--- 1733,1745 ----
  
  	MemoryContextReset(fmstate->temp_cxt);
  
+ 	/*
+ 	 * AFTER ROW Triggers or RETURNING expressions might reference the tableoid
+ 	 * column, so initialize t_tableOid before evaluating them.
+ 	 */
+ 	tuple = ExecMaterializeSlot(slot);
+ 	tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
+ 
  	/* Return NULL if nothing was updated on the remote end */
  	return (n_rows > 0) ? slot : NULL;
  }
***************
*** 1744,1749 **** postgresExecForeignDelete(EState *estate,
--- 1760,1766 ----
  	const char **p_values;
  	PGresult   *res;
  	int			n_rows;
+ 	HeapTuple	tuple;
  
  	/* Set up the prepared statement on the remote server, if we didn't yet */
  	if (!fmstate->p_name)
***************
*** 1794,1799 **** postgresExecForeignDelete(EState *estate,
--- 1811,1825 ----
  
  	MemoryContextReset(fmstate->temp_cxt);
  
+ 	/*
+ 	 * RETURNING expressions might reference the tableoid column, so initialize
+ 	 * t_tableOid before evaluating them.
+ 	 */
+ 	if (slot->tts_isempty)
+ 		ExecStoreAllNullTuple(slot);
+ 	tuple = ExecMaterializeSlot(slot);
+ 	tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
+ 
  	/* Return NULL if nothing was deleted on the remote end */
  	return (n_rows > 0) ? slot : NULL;
  }
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 413,418 **** EXPLAIN (verbose, costs off)
--- 413,427 ----
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
+ EXPLAIN (verbose, costs off)
+ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+ EXPLAIN (verbose, costs off)
+ DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+ DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  
  -- Test that trigger on remote table works as expected
  CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$

diff --git a/contrib/postgres_fdw/deparse.c b/contrib/postgres_fdw/deparse.c
index df3d1ee..d778e61 100644
--- a/contrib/postgres_fdw/deparse.c
+++ b/contrib/postgres_fdw/deparse.c
@@ -112,6 +112,7 @@ static void deparseTargetList(StringInfo buf,
 				  PlannerInfo *root,
 				  Index rtindex,
 				  Relation rel,
+				  bool is_returning,
 				  Bitmapset *attrs_used,
 				  List **retrieved_attrs);
 static void deparseReturningList(StringInfo buf, PlannerInfo *root,
@@ -776,7 +777,7 @@ deparseSelectSql(Bitmapset *attrs_used, List **retrieved_attrs,
 	 * Construct SELECT list
 	 */
 	appendStringInfoString(buf, "SELECT ");
-	deparseTargetList(buf, root, foreignrel->relid, rel, attrs_used,
+	deparseTargetList(buf, root, foreignrel->relid, rel, false, attrs_used,
 					  retrieved_attrs);
 
 	/*
@@ -790,7 +791,8 @@ deparseSelectSql(Bitmapset *attrs_used, List **retrieved_attrs,
 
 /*
  * Emit a target list that retrieves the columns specified in attrs_used.
- * This is used for both SELECT and RETURNING targetlists.
+ * This is used for both SELECT and RETURNING targetlists; the is_returning
+ * parameter is true only for a RETURNING targetlist.
  *
  * The tlist text is appended to buf, and we also create an integer List
  * of the columns being retrieved, which is returned to *retrieved_attrs.
@@ -800,6 +802,7 @@ deparseTargetList(StringInfo buf,
 				  PlannerInfo *root,
 				  Index rtindex,
 				  Relation rel,
+				  bool is_returning,
 				  Bitmapset *attrs_used,
 				  List **retrieved_attrs)
 {
@@ -829,6 +832,8 @@ deparseTargetList(StringInfo buf,
 		{
 			if (!first)
 				appendStringInfoString(buf, ", ");
+			else if (is_returning)
+				appendStringInfoString(buf, " RETURNING ");
 			first = false;
 
 			deparseColumnRef(buf, rtindex, i, root);
@@ -846,6 +851,8 @@ deparseTargetList(StringInfo buf,
 	{
 		if (!first)
 			appendStringInfoString(buf, ", ");
+		else if (is_returning)
+			appendStringInfoString(buf, " RETURNING ");
 		first = false;
 
 		appendStringInfoString(buf, "ctid");
@@ -855,7 +862,7 @@ deparseTargetList(StringInfo buf,
 	}
 
 	/* Don't generate bad syntax if no undropped columns */
-	if (first)
+	if (first && !is_returning)
 		appendStringInfoString(buf, "NULL");
 }
 
@@ -1113,11 +1120,8 @@ deparseReturningList(StringInfo buf, PlannerInfo *root,
 	}
 
 	if (attrs_used != NULL)
-	{
-		appendStringInfoString(buf, " RETURNING ");
-		deparseTargetList(buf, root, rtindex, rel, attrs_used,
+		deparseTargetList(buf, root, rtindex, rel, true, attrs_used,
 						  retrieved_attrs);
-	}
 	else
 		*retrieved_attrs = NIL;
 }
diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index 2390e61..f90ab5a 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -2408,6 +2408,59 @@ SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  1104 | 204 | ddd                | 
 (819 rows)
 
+EXPLAIN (verbose, costs off)
+INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+                                                                                           QUERY PLAN                                                                                            
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Insert on public.ft2
+   Output: (tableoid)::regclass
+   Remote SQL: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6, c7, c8) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+   ->  Result
+         Output: 9999, 999, NULL::integer, 'foo'::text, NULL::timestamp with time zone, NULL::timestamp without time zone, NULL::character varying, 'ft2       '::character(10), NULL::user_enum
+(5 rows)
+
+INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+ tableoid 
+----------
+ ft2
+(1 row)
+
+EXPLAIN (verbose, costs off)
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+                                                    QUERY PLAN                                                     
+-------------------------------------------------------------------------------------------------------------------
+ Update on public.ft2
+   Output: (tableoid)::regclass
+   Remote SQL: UPDATE "S 1"."T 1" SET c3 = $2 WHERE ctid = $1
+   ->  Foreign Scan on public.ft2
+         Output: c1, c2, NULL::integer, 'bar'::text, c4, c5, c6, c7, c8, ctid
+         Remote SQL: SELECT "C 1", c2, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
+(6 rows)
+
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+ tableoid 
+----------
+ ft2
+(1 row)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+                                     QUERY PLAN                                     
+------------------------------------------------------------------------------------
+ Delete on public.ft2
+   Output: (tableoid)::regclass
+   Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1
+   ->  Foreign Scan on public.ft2
+         Output: ctid
+         Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
+(6 rows)
+
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+ tableoid 
+----------
+ ft2
+(1 row)
+
 -- Test that trigger on remote table works as expected
 CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
 BEGIN
diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql
index 5c6ead1..f198e8e 100644
--- a/contrib/postgres_fdw/sql/postgres_fdw.sql
+++ b/contrib/postgres_fdw/sql/postgres_fdw.sql
@@ -413,6 +413,15 @@ EXPLAIN (verbose, costs off)
 DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
 DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
 SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
+EXPLAIN (verbose, costs off)
+INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
+EXPLAIN (verbose, costs off)
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+EXPLAIN (verbose, costs off)
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
 
 -- Test that trigger on remote table works as expected
 CREATE OR REPLACE FUNCTION "S 1".F_BRTRIG() RETURNS trigger AS $$
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 46299fc..27051e8 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -308,6 +308,12 @@ ExecInsert(ModifyTableState *mtstate,
 		/* FDW might have changed tuple */
 		tuple = ExecMaterializeSlot(slot);
 
+		/*
+		 * AFTER ROW Triggers or RETURNING expressions might reference the
+		 * tableoid column, so initialize t_tableOid before evaluating them.
+		 */
+		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
+
 		newId = InvalidOid;
 	}
 	else
@@ -561,6 +567,8 @@ ExecDelete(ItemPointer tupleid,
 	}
 	else if (resultRelInfo->ri_FdwRoutine)
 	{
+		HeapTuple	tuple;
+
 		/*
 		 * delete from foreign table: let the FDW do it
 		 *
@@ -579,6 +587,15 @@ ExecDelete(ItemPointer tupleid,
 
 		if (slot == NULL)		/* "do nothing" */
 			return NULL;
+
+		/*
+		 * RETURNING expressions might reference the tableoid column, so
+		 * initialize t_tableOid before evaluating them.
+		 */
+		if (slot->tts_isempty)
+			ExecStoreAllNullTuple(slot);
+		tuple = ExecMaterializeSlot(slot);
+		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
 	}
 	else
 	{
@@ -838,6 +855,12 @@ ExecUpdate(ItemPointer tupleid,
 
 		/* FDW might have changed tuple */
 		tuple = ExecMaterializeSlot(slot);
+
+		/*
+		 * AFTER ROW Triggers or RETURNING expressions might reference the
+		 * tableoid column, so initialize t_tableOid before evaluating them.
+		 */
+		tuple->t_tableOid = RelationGetRelid(resultRelationDesc);
 	}
 	else
 	{

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 1069,1074 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 1069,1134 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*targetlist,
+ 						   List *targetAttrs,
+ 						   List	*remote_conds,
+ 						   List **params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	deparse_expr_cxt context;
+ 	int			nestlevel;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = params_list;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	/* Make sure any constants in the exprs are printed portably */
+ 	nestlevel = set_transmission_modes();
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfoString(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 
+ 	reset_transmission_modes(nestlevel);
+ 
+ 	if (remote_conds)
+ 		appendWhereClause(remote_conds, &context);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 1091,1096 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 1151,1190 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*remote_conds,
+ 						   List	**params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	deparse_expr_cxt context;
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = params_list;
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 
+ 	if (remote_conds)
+ 		appendWhereClause(remote_conds, &context);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 1314,1320 **** INSERT INTO ft2 (c1,c2,c3)
--- 1314,1339 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (3 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1424,1430 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1443,1449 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1445,1460 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1464,1477 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1565,1571 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1582,1588 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2426,2441 **** INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  (1 row)
  
  EXPLAIN (verbose, costs off)
! UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
!                                                     QUERY PLAN                                                     
! -------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
     Output: (tableoid)::regclass
!    Remote SQL: UPDATE "S 1"."T 1" SET c3 = $2 WHERE ctid = $1
!    ->  Foreign Scan on public.ft2
!          Output: c1, c2, NULL::integer, 'bar'::text, c4, c5, c6, c7, c8, ctid
!          Remote SQL: SELECT "C 1", c2, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
! (6 rows)
  
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
--- 2443,2456 ----
  (1 row)
  
  EXPLAIN (verbose, costs off)
! UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;             -- can be pushed down
!                                      QUERY PLAN                                     
! ------------------------------------------------------------------------------------
   Update on public.ft2
     Output: (tableoid)::regclass
!    ->  Foreign Update on public.ft2
!          Remote SQL: UPDATE "S 1"."T 1" SET c3 = 'bar'::text WHERE (("C 1" = 9999))
! (4 rows)
  
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
***************
*** 2444,2459 **** UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  (1 row)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
!                                      QUERY PLAN                                     
! ------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: (tableoid)::regclass
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
--- 2459,2472 ----
  (1 row)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;                       -- can be pushed down
!                              QUERY PLAN                             
! --------------------------------------------------------------------
   Delete on public.ft2
     Output: (tableoid)::regclass
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE (("C 1" = 9999))
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
***************
*** 2607,2613 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2620,2626 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2766,2772 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2779,2785 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2906,2912 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
--- 2919,2925 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
***************
*** 3299,3304 **** NOTICE:  NEW: (13,"test triggered !")
--- 3312,3510 ----
   (0,27)
  (1 row)
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ -- Test DML pushdown functionality
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_before ON rem1;
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_after ON rem1;
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_update ON rem1;
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                   QUERY PLAN                                   
+ -------------------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_update ON rem1;
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                                QUERY PLAN                               
+ ------------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_after_delete ON rem1;
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
***************
*** 3768,3773 **** fetch from c;
--- 3974,4029 ----
  update bar set f2 = null where current of c;
  ERROR:  WHERE CURRENT OF is not supported for this table type
  rollback;
+ explain (verbose, costs off)
+ delete from foo where f1 < 5 returning *;
+                                    QUERY PLAN                                   
+ --------------------------------------------------------------------------------
+  Delete on public.foo
+    Output: foo.f1, foo.f2
+    Delete on public.foo
+    Foreign Delete on public.foo2
+    ->  Index Scan using i_foo_f1 on public.foo
+          Output: foo.ctid
+          Index Cond: (foo.f1 < 5)
+    ->  Foreign Delete on public.foo2
+          Remote SQL: DELETE FROM public.loct1 WHERE ((f1 < 5)) RETURNING f1, f2
+ (9 rows)
+ 
+ delete from foo where f1 < 5 returning *;
+  f1 | f2 
+ ----+----
+   1 |  1
+   3 |  3
+   0 |  0
+   2 |  2
+   4 |  4
+ (5 rows)
+ 
+ explain (verbose, costs off)
+ update bar set f2 = f2 + 100 returning *;
+                                   QUERY PLAN                                  
+ ------------------------------------------------------------------------------
+  Update on public.bar
+    Output: bar.f1, bar.f2
+    Update on public.bar
+    Foreign Update on public.bar2
+    ->  Seq Scan on public.bar
+          Output: bar.f1, (bar.f2 + 100), bar.ctid
+    ->  Foreign Update on public.bar2
+          Remote SQL: UPDATE public.loct2 SET f2 = (f2 + 100) RETURNING f1, f2
+ (8 rows)
+ 
+ update bar set f2 = f2 + 100 returning *;
+  f1 | f2  
+ ----+-----
+   1 | 311
+   2 | 322
+   6 | 266
+   3 | 333
+   4 | 344
+   7 | 277
+ (6 rows)
+ 
  drop table foo cascade;
  NOTICE:  drop cascades to foreign table foo2
  drop table bar cascade;
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 57,63 **** PG_MODULE_MAGIC;
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
--- 57,64 ----
   * planner to executor.  Currently we store:
   *
   * 1) SELECT statement text to be sent to the remote server
!  * 2) List of restriction clauses that can be executed remotely
!  * 3) Integer list of attribute numbers retrieved by the SELECT
   *
   * These items are indexed with the enum FdwScanPrivateIndex, so an item
   * can be fetched with list_nth().  For example, to get the SELECT statement:
***************
*** 67,72 **** enum FdwScanPrivateIndex
--- 68,75 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
+ 	/* List of restriction clauses that can be executed remotely */
+ 	FdwScanPrivateRemoteConds,
  	/* Integer list of attribute numbers retrieved by the SELECT */
  	FdwScanPrivateRetrievedAttrs
  };
***************
*** 94,99 **** enum FdwModifyPrivateIndex
--- 97,124 ----
  };
  
  /*
+  * Similarly, this enum describes what's kept in the fdw_private list for
+  * a ForeignScan node that has pushed down an UPDATE/DELETE to the remote
+  * server.  We store:
+  *
+  * 1) UPDATE/DELETE statement text to be sent to the remote server
+  * 2) Boolean flag showing if the remote query has a RETURNING clause
+  * 3) Integer list of attribute numbers retrieved by RETURNING, if any
+  * 4) Boolean flag showing if we set the command es_processed
+  */
+ enum FdwDmlPushdownPrivateIndex
+ {
+ 	/* SQL statement to execute remotely (as a String node) */
+ 	FdwDmlPushdownPrivateUpdateSql,
+ 	/* has-returning flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateHasReturning,
+ 	/* Integer list of attribute numbers retrieved by RETURNING */
+ 	FdwDmlPushdownPrivateRetrievedAttrs,
+ 	/* set-processed flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateSetProcessed
+ };
+ 
+ /*
   * Execution state of a foreign scan using postgres_fdw.
   */
  typedef struct PgFdwScanState
***************
*** 156,161 **** typedef struct PgFdwModifyState
--- 181,217 ----
  } PgFdwModifyState;
  
  /*
+  * Execution state of a foreign scan that has pushed down a foreign table
+  * modification to the remote server
+  */
+ typedef struct PgFdwDmlPushdownState
+ {
+ 	Relation	rel;			/* relcache entry for the foreign table */
+ 	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
+ 
+ 	/* extracted fdw_private data */
+ 	char	   *query;			/* text of UPDATE/DELETE command */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
+ 	List	   *retrieved_attrs;	/* attr numbers retrieved by RETURNING */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 
+ 	/* for remote query execution */
+ 	PGconn	   *conn;			/* connection for the update */
+ 	int			numParams;		/* number of parameters passed to query */
+ 	FmgrInfo   *param_flinfo;	/* output conversion functions for them */
+ 	List	   *param_exprs;	/* executable expressions for param values */
+ 	const char **param_values;	/* textual values of query parameters */
+ 
+ 	/* for storing result tuples */
+ 	PGresult   *result;			/* result for query */
+ 	int			num_tuples;		/* # of result tuples */
+ 	int			next_tuple;		/* index of next one to return */
+ 
+ 	/* working memory context */
+ 	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
+ } PgFdwDmlPushdownState;
+ 
+ /*
   * Workspace for analyzing a foreign table.
   */
  typedef struct PgFdwAnalyzeState
***************
*** 247,252 **** static TupleTableSlot *postgresExecForeignDelete(EState *estate,
--- 303,315 ----
  static void postgresEndForeignModify(EState *estate,
  						 ResultRelInfo *resultRelInfo);
  static int	postgresIsForeignRelUpdatable(Relation rel);
+ static bool postgresPlanDMLPushdown(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index);
+ static void postgresBeginDMLPushdown(ForeignScanState *node, int eflags);
+ static TupleTableSlot *postgresIterateDMLPushdown(ForeignScanState *node);
+ static void postgresEndDMLPushdown(ForeignScanState *node);
  static void postgresExplainForeignScan(ForeignScanState *node,
  						   ExplainState *es);
  static void postgresExplainForeignModify(ModifyTableState *mtstate,
***************
*** 254,259 **** static void postgresExplainForeignModify(ModifyTableState *mtstate,
--- 317,324 ----
  							 List *fdw_private,
  							 int subplan_index,
  							 ExplainState *es);
+ static void postgresExplainDMLPushdown(ForeignScanState *node,
+ 						   ExplainState *es);
  static bool postgresAnalyzeForeignTable(Relation relation,
  							AcquireSampleRowsFunc *func,
  							BlockNumber *totalpages);
***************
*** 290,295 **** static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
--- 355,362 ----
  						 TupleTableSlot *slot);
  static void store_returning_result(PgFdwModifyState *fmstate,
  					   TupleTableSlot *slot, PGresult *res);
+ static void execute_dml_stmt(ForeignScanState *node);
+ static TupleTableSlot *get_returning_data(ForeignScanState *node);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 332,341 **** postgres_fdw_handler(PG_FUNCTION_ARGS)
--- 399,413 ----
  	routine->ExecForeignDelete = postgresExecForeignDelete;
  	routine->EndForeignModify = postgresEndForeignModify;
  	routine->IsForeignRelUpdatable = postgresIsForeignRelUpdatable;
+ 	routine->PlanDMLPushdown = postgresPlanDMLPushdown;
+ 	routine->BeginDMLPushdown = postgresBeginDMLPushdown;
+ 	routine->IterateDMLPushdown = postgresIterateDMLPushdown;
+ 	routine->EndDMLPushdown = postgresEndDMLPushdown;
  
  	/* Support functions for EXPLAIN */
  	routine->ExplainForeignScan = postgresExplainForeignScan;
  	routine->ExplainForeignModify = postgresExplainForeignModify;
+ 	routine->ExplainDMLPushdown = postgresExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	routine->AnalyzeForeignTable = postgresAnalyzeForeignTable;
***************
*** 1010,1016 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make2(makeString(sql.data),
  							 retrieved_attrs);
  
  	/*
--- 1082,1089 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make3(makeString(sql.data),
! 							 remote_conds,
  							 retrieved_attrs);
  
  	/*
***************
*** 1304,1316 **** postgresAddForeignUpdateTargets(Query *parsetree,
  /*
   * postgresPlanForeignModify
   *		Plan an insert/update/delete operation on a foreign table
-  *
-  * Note: currently, the plan tree generated for UPDATE/DELETE will always
-  * include a ForeignScan that retrieves ctids (using SELECT FOR UPDATE)
-  * and then the ModifyTable node will have to execute individual remote
-  * UPDATE/DELETE commands.  If there are no local conditions or joins
-  * needed, it'd be better to let the scan node do UPDATE/DELETE RETURNING
-  * and then do nothing at ModifyTable.  Room for future optimization ...
   */
  static List *
  postgresPlanForeignModify(PlannerInfo *root,
--- 1377,1382 ----
***************
*** 1821,1826 **** postgresIsForeignRelUpdatable(Relation rel)
--- 1887,2223 ----
  }
  
  /*
+  * postgresPlanDMLPushdown
+  *		Consider pushing down a foreign table modification to the remote server
+  *
+  * Decide whether the table modification is safe to push down to the remote end,
+  * and if so, modify subplan so as to do that.
+  *
+  * Conditions checked here:
+  *
+  * 1. The table modification must be an UPDATE or DELETE.
+  *
+  * 2. It's unsafe to push down the command if there are any local joins needed.
+  *
+  * 3. It's unsafe to push down the command if there are any quals that can't be
+  *    evaluated remotely.
+  *
+  * 4. We can't push down an UPDATE, if any expressions to assign to the target
+  *    columns are unsafe to evaluate on the remote end.
+  */
+ static bool
+ postgresPlanDMLPushdown(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index)
+ {
+ 	CmdType		operation = plan->operation;
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	RangeTblEntry *rte = planner_rt_fetch(resultRelation, root);
+ 	Relation	rel;
+ 	StringInfoData sql;
+ 	ForeignScan *fscan;
+ 	List	   *targetAttrs = NIL;
+ 	List	   *remote_conds;
+ 	List	   *params_list = NIL;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 
+ 	/*
+ 	 * Decide whether the table modification is safe to push down to the remote
+ 	 * server.
+ 	 */
+ 
+ 	/* Check point 1 */
+ 	if (operation == CMD_INSERT)
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 		int			col;
+ 
+ 		/*
+ 		 * We transmit only columns that were explicitly targets of the UPDATE,
+ 		 * so as to avoid unnecessary data transmission.
+ 		 */
+ 		col = -1;
+ 		while ((col = bms_next_member(rte->updatedCols, col)) >= 0)
+ 		{
+ 			/* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
+ 			AttrNumber	attno = col + FirstLowInvalidHeapAttributeNumber;
+ 			TargetEntry *tle;
+ 
+ 			if (attno <= InvalidAttrNumber)		/* shouldn't happen */
+ 				elog(ERROR, "system-column update is not supported");
+ 
+ 			tle = get_tle_by_resno(subplan->targetlist, attno);
+ 
+ 			if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 				return false;
+ 
+ 			targetAttrs = lappend_int(targetAttrs, attno);
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Ok, modify subplan so as to push down the command to the remote server.
+ 	 */
+ 	fscan = (ForeignScan *) subplan;
+ 
+ 	initStringInfo(&sql);
+ 
+ 	/*
+ 	 * Core code already has some lock on each rel being planned, so we can
+ 	 * use NoLock here.
+ 	 */
+ 	rel = heap_open(rte->relid, NoLock);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	switch (operation)
+ 	{
+ 		case CMD_UPDATE:
+ 			deparsePushedDownUpdateSql(&sql, root, resultRelation, rel,
+ 									   ((Plan *) fscan)->targetlist,
+ 									   targetAttrs,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		case CMD_DELETE:
+ 			deparsePushedDownDeleteSql(&sql, root, resultRelation, rel,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		default:
+ 			elog(ERROR, "unexpected operation: %d", (int) operation);
+ 			break;
+ 	}
+ 
+ 	/*
+ 	 * Update the operation info.
+ 	 */
+ 	fscan->operation = operation;
+ 
+ 	/*
+ 	 * Update the fdw_exprs list that will be available to the executor.
+ 	 */
+ 	fscan->fdw_exprs = params_list;
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwDmlPushdownPrivateIndex, above.
+ 	 */
+ 	fscan->fdw_private = list_make4(makeString(sql.data),
+ 									makeInteger((retrieved_attrs != NIL)),
+ 									retrieved_attrs,
+ 									makeInteger(plan->canSetTag));
+ 
+ 	heap_close(rel, NoLock);
+ 	return true;
+ }
+ 
+ /*
+  * postgresBeginDMLPushdown
+  *		Initiate pushing down a foreign table modification to the remote server
+  */
+ static void
+ postgresBeginDMLPushdown(ForeignScanState *node, int eflags)
+ {
+ 	ForeignScan *fsplan = (ForeignScan *) node->ss.ps.plan;
+ 	EState	   *estate = node->ss.ps.state;
+ 	PgFdwDmlPushdownState *dpstate;
+ 	RangeTblEntry *rte;
+ 	Oid			userid;
+ 	ForeignTable *table;
+ 	UserMapping *user;
+ 	int			numParams;
+ 	int			i;
+ 	ListCell   *lc;
+ 
+ 	/*
+ 	 * Do nothing in EXPLAIN (no ANALYZE) case.  node->fdw_state stays NULL.
+ 	 */
+ 	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
+ 		return;
+ 
+ 	/*
+ 	 * We'll save private state in node->fdw_state.
+ 	 */
+ 	dpstate = (PgFdwDmlPushdownState *) palloc0(sizeof(PgFdwDmlPushdownState));
+ 	node->fdw_state = (void *) dpstate;
+ 
+ 	/*
+ 	 * Identify which user to do the remote access as.  This should match what
+ 	 * ExecCheckRTEPerms() does.
+ 	 */
+ 	rte = rt_fetch(fsplan->scan.scanrelid, estate->es_range_table);
+ 	userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
+ 
+ 	/* Get info about foreign table. */
+ 	dpstate->rel = node->ss.ss_currentRelation;
+ 	table = GetForeignTable(RelationGetRelid(dpstate->rel));
+ 	user = GetUserMapping(userid, table->serverid);
+ 
+ 	/*
+ 	 * Get connection to the foreign server.  Connection manager will
+ 	 * establish new connection if necessary.
+ 	 */
+ 	dpstate->conn = GetConnection(user, false);
+ 
+ 	/* Initialize state variable */
+ 	dpstate->num_tuples = -1;		/* -1 means not set yet */
+ 
+ 	/* Get private info created by planner functions. */
+ 	dpstate->query = strVal(list_nth(fsplan->fdw_private,
+ 									 FdwDmlPushdownPrivateUpdateSql));
+ 	dpstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateHasReturning));
+ 	dpstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 										FdwDmlPushdownPrivateRetrievedAttrs);
+ 	dpstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateSetProcessed));
+ 
+ 	/* Create context for per-tuple temp workspace. */
+ 	dpstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
+ 											  "postgres_fdw temporary data",
+ 											  ALLOCSET_SMALL_MINSIZE,
+ 											  ALLOCSET_SMALL_INITSIZE,
+ 											  ALLOCSET_SMALL_MAXSIZE);
+ 
+ 	/* Prepare for input conversion of RETURNING results. */
+ 	if (dpstate->has_returning)
+ 		dpstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(dpstate->rel));
+ 
+ 	/* Prepare for output conversion of parameters used in remote query. */
+ 	numParams = list_length(fsplan->fdw_exprs);
+ 	dpstate->numParams = numParams;
+ 	dpstate->param_flinfo = (FmgrInfo *) palloc0(sizeof(FmgrInfo) * numParams);
+ 
+ 	i = 0;
+ 	foreach(lc, fsplan->fdw_exprs)
+ 	{
+ 		Node	   *param_expr = (Node *) lfirst(lc);
+ 		Oid			typefnoid;
+ 		bool		isvarlena;
+ 
+ 		getTypeOutputInfo(exprType(param_expr), &typefnoid, &isvarlena);
+ 		fmgr_info(typefnoid, &dpstate->param_flinfo[i]);
+ 		i++;
+ 	}
+ 
+ 	/*
+ 	 * Prepare remote-parameter expressions for evaluation.  (Note: in
+ 	 * practice, we expect that all these expressions will be just Params, so
+ 	 * we could possibly do something more efficient than using the full
+ 	 * expression-eval machinery for this.  But probably there would be little
+ 	 * benefit, and it'd require postgres_fdw to know more than is desirable
+ 	 * about Param evaluation.)
+ 	 */
+ 	dpstate->param_exprs = (List *)
+ 		ExecInitExpr((Expr *) fsplan->fdw_exprs,
+ 					 (PlanState *) node);
+ 
+ 	/*
+ 	 * Allocate buffer for text form of query parameters, if any.
+ 	 */
+ 	if (numParams > 0)
+ 		dpstate->param_values = (const char **) palloc0(numParams * sizeof(char *));
+ 	else
+ 		dpstate->param_values = NULL;
+ }
+ 
+ /*
+  * postgresIterateDMLPushdown
+  *		Execute pushing down a foreign table modification to the remote server
+  */
+ static TupleTableSlot *
+ postgresIterateDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 
+ 	/*
+ 	 * If this is the first call after Begin, execute the statement.
+ 	 */
+ 	if (dpstate->num_tuples == -1)
+ 		execute_dml_stmt(node);
+ 
+ 	/*
+ 	 * If the local query doesn't specify RETURNING, just clear tuple slot.
+ 	 */
+ 	if (!resultRelInfo->ri_projectReturning)
+ 	{
+ 		TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 		Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 		Assert(!dpstate->has_returning);
+ 
+ 		/* Increment the command es_processed count if necessary. */
+ 		if (dpstate->set_processed)
+ 			estate->es_processed += dpstate->num_tuples;
+ 
+ 		/* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
+ 		if (instr)
+ 			instr->tuplecount += dpstate->num_tuples;
+ 
+ 		return ExecClearTuple(slot);
+ 	}
+ 
+ 	/*
+ 	 * Get the next RETURNING tuple.
+ 	 */
+ 	return get_returning_data(node);
+ }
+ 
+ /*
+  * postgresEndDMLPushdown
+  *		Finish pushing down a foreign table modification to the remote server
+  */
+ static void
+ postgresEndDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 
+ 	/* if dpstate is NULL, we are in EXPLAIN; nothing to do */
+ 	if (dpstate == NULL)
+ 		return;
+ 
+ 	/* Release PGresult */
+ 	if (dpstate->result)
+ 		PQclear(dpstate->result);
+ 
+ 	/* Release remote connection */
+ 	ReleaseConnection(dpstate->conn);
+ 	dpstate->conn = NULL;
+ 
+ 	/* MemoryContext will be deleted automatically. */
+ }
+ 
+ /*
   * postgresExplainForeignScan
   *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
   */
***************
*** 1858,1863 **** postgresExplainForeignModify(ModifyTableState *mtstate,
--- 2255,2279 ----
  	}
  }
  
+ /*
+  * postgresExplainDMLPushdown
+  *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
+  *		that has pushed down an UPDATE/DELETE to the remote server
+  */
+ static void
+ postgresExplainDMLPushdown(ForeignScanState *node, ExplainState *es)
+ {
+ 	List	   *fdw_private;
+ 	char	   *sql;
+ 
+ 	if (es->verbose)
+ 	{
+ 		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
+ 		sql = strVal(list_nth(fdw_private, FdwDmlPushdownPrivateUpdateSql));
+ 		ExplainPropertyText("Remote SQL", sql, es);
+ 	}
+ }
+ 
  
  /*
   * estimate_path_cost_size
***************
*** 2474,2479 **** store_returning_result(PgFdwModifyState *fmstate,
--- 2890,3028 ----
  }
  
  /*
+  * Execute a pushed-down UPDATE/DELETE statement.
+  */
+ static void
+ execute_dml_stmt(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	ExprContext *econtext = node->ss.ps.ps_ExprContext;
+ 	int			numParams = dpstate->numParams;
+ 	const char **values = dpstate->param_values;
+ 
+ 	/*
+ 	 * Construct array of query parameter values in text format.
+ 	 */
+ 	if (numParams > 0)
+ 	{
+ 		int			nestlevel;
+ 		int			i;
+ 		ListCell   *lc;
+ 
+ 		nestlevel = set_transmission_modes();
+ 
+ 		i = 0;
+ 		foreach(lc, dpstate->param_exprs)
+ 		{
+ 			ExprState  *expr_state = (ExprState *) lfirst(lc);
+ 			Datum		expr_value;
+ 			bool		isNull;
+ 
+ 			/* Evaluate the parameter expression */
+ 			expr_value = ExecEvalExpr(expr_state, econtext, &isNull, NULL);
+ 
+ 			/*
+ 			 * Get string representation of each parameter value by invoking
+ 			 * type-specific output function, unless the value is null.
+ 			 */
+ 			if (isNull)
+ 				values[i] = NULL;
+ 			else
+ 				values[i] = OutputFunctionCall(&dpstate->param_flinfo[i],
+ 											   expr_value);
+ 			i++;
+ 		}
+ 
+ 		reset_transmission_modes(nestlevel);
+ 	}
+ 
+ 	/*
+ 	 * Notice that we pass NULL for paramTypes, thus forcing the remote server
+ 	 * to infer types for all parameters.  Since we explicitly cast every
+ 	 * parameter (see deparse.c), the "inference" is trivial and will produce
+ 	 * the desired result.  This allows us to avoid assuming that the remote
+ 	 * server has the same OIDs we do for the parameters' types.
+ 	 *
+ 	 * We don't use a PG_TRY block here, so be careful not to throw error
+ 	 * without releasing the PGresult.
+ 	 */
+ 	dpstate->result = PQexecParams(dpstate->conn, dpstate->query,
+ 								   numParams, NULL, values, NULL, NULL, 0);
+ 	if (PQresultStatus(dpstate->result) !=
+ 		(dpstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 		pgfdw_report_error(ERROR, dpstate->result, dpstate->conn, true,
+ 						   dpstate->query);
+ 
+ 	/* Get the number of rows affected. */
+ 	if (dpstate->has_returning)
+ 		dpstate->num_tuples = PQntuples(dpstate->result);
+ 	else
+ 		dpstate->num_tuples = atoi(PQcmdTuples(dpstate->result));
+ }
+ 
+ /*
+  * Get the result of a RETURNING clause.
+  */
+ static TupleTableSlot *
+ get_returning_data(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 
+ 	Assert(resultRelInfo->ri_projectReturning);
+ 
+ 	/* If we didn't get any tuples, must be end of data. */
+ 	if (dpstate->next_tuple >= dpstate->num_tuples)
+ 		return ExecClearTuple(slot);
+ 
+ 	/* Increment the command es_processed count if necessary. */
+ 	if (dpstate->set_processed)
+ 		estate->es_processed += 1;
+ 
+ 	/*
+ 	 * Store a RETURNING tuple.  If has_returning is false, just emit a dummy
+ 	 * tuple.  (We have has_returning=false if the local query is of the form
+ 	 * UPDATE/DELETE .. RETURNING 1 for example.)
+ 	 */
+ 	if (!dpstate->has_returning)
+ 		ExecStoreAllNullTuple(slot);
+ 	else
+ 	{
+ 		/*
+ 		 * On error, be sure to release the PGresult on the way out.  Callers
+ 		 * do not have PG_TRY blocks to ensure this happens.
+ 		 */
+ 		PG_TRY();
+ 		{
+ 			HeapTuple	newtup;
+ 
+ 			newtup = make_tuple_from_result_row(dpstate->result,
+ 												dpstate->next_tuple,
+ 												dpstate->rel,
+ 												dpstate->attinmeta,
+ 												dpstate->retrieved_attrs,
+ 												dpstate->temp_cxt);
+ 			ExecStoreTuple(newtup, slot, InvalidBuffer, false);
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			if (dpstate->result)
+ 				PQclear(dpstate->result);
+ 			PG_RE_THROW();
+ 		}
+ 		PG_END_TRY();
+ 	}
+ 	dpstate->next_tuple++;
+ 
+ 	/* Make slot available for evaluation of the local query RETURNING list. */
+ 	resultRelInfo->ri_projectReturning->pi_exprContext->ecxt_scantuple = slot;
+ 
+ 	return slot;
+ }
+ 
+ /*
   * postgresAnalyzeForeignTable
   *		Test whether analyzing this foreign table is supported
   */
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 91,100 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 91,114 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*targetlist,
+ 									   List *targetAttrs,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 399,426 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  EXPLAIN (verbose, costs off)
  INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  EXPLAIN (verbose, costs off)
! UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  
  -- Test that trigger on remote table works as expected
--- 399,430 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  EXPLAIN (verbose, costs off)
  INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  EXPLAIN (verbose, costs off)
! UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;             -- can be pushed down
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;                       -- can be pushed down
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  
  -- Test that trigger on remote table works as expected
***************
*** 737,742 **** UPDATE rem1 SET f2 = 'testo';
--- 741,830 ----
  -- Test returning a system attribute
  INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ 
+ 
+ -- Test DML pushdown functionality
+ 
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_before ON rem1;
+ 
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_after ON rem1;
+ 
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ 
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_update ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_update ON rem1;
+ 
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_after_delete ON rem1;
+ 
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
***************
*** 868,873 **** fetch from c;
--- 956,968 ----
  update bar set f2 = null where current of c;
  rollback;
  
+ explain (verbose, costs off)
+ delete from foo where f1 < 5 returning *;
+ delete from foo where f1 < 5 returning *;
+ explain (verbose, costs off)
+ update bar set f2 = f2 + 100 returning *;
+ update bar set f2 = f2 + 100 returning *;
+ 
  drop table foo cascade;
  drop table bar cascade;
  drop table loct1;
*** a/doc/src/sgml/fdwhandler.sgml
--- b/doc/src/sgml/fdwhandler.sgml
***************
*** 657,669 **** IsForeignRelUpdatable (Relation rel);
       <literal>NULL</>, foreign tables are assumed to be insertable, updatable,
       or deletable if the FDW provides <function>ExecForeignInsert</>,
       <function>ExecForeignUpdate</>, or <function>ExecForeignDelete</>
!      respectively.  This function is only needed if the FDW supports some
       tables that are updatable and some that are not.  (Even then, it's
       permissible to throw an error in the execution routine instead of
       checking in this function.  However, this function is used to determine
       updatability for display in the <literal>information_schema</> views.)
      </para>
  
     </sect2>
  
     <sect2 id="fdw-callbacks-row-locking">
--- 657,819 ----
       <literal>NULL</>, foreign tables are assumed to be insertable, updatable,
       or deletable if the FDW provides <function>ExecForeignInsert</>,
       <function>ExecForeignUpdate</>, or <function>ExecForeignDelete</>
!      respectively.
!      (If the FDW optimizes a foreign table update on a foreign table using
!      <function>PlanDMLPushdown</>, it still needs to provide
!      <function>BeginDMLPushdown</>, <function>IterateDMLPushdown</>, and
!      <function>EndDMLPushdown</> to execute the optimized update.)
!      This function is only needed if the FDW supports some
       tables that are updatable and some that are not.  (Even then, it's
       permissible to throw an error in the execution routine instead of
       checking in this function.  However, this function is used to determine
       updatability for display in the <literal>information_schema</> views.)
      </para>
  
+     <para>
+      If an FDW supports an optimization that executes a foreign table update
+      directly on the remote server, it should provide the following callback
+      functions in addition to the table-updating functions described above:
+     </para>
+ 
+     <para>
+ <programlisting>
+ bool
+ PlanDMLPushdown (PlannerInfo *root,
+                  ModifyTable *plan,
+                  Index resultRelation,
+                  int subplan_index);
+ </programlisting>
+ 
+      Decide whether it is safe to execute a foreign table update directly
+      on the remote server.  If so, return <literal>true</> after performing
+      planning actions needed for that.  Otherwise, return <literal>false</>.
+      This function is executed just before <function>PlanForeignModify</>
+      is called.  If this function succeeds, <function>PlanForeignModify</>
+      won't be executed, and <function>BeginDMLPushdown</>,
+      <function>IterateDMLPushdown</> and <function>EndDMLPushdown</> will
+      be called at the execution stage, instead.  Otherwise, the table update
+      will be executed using the table-updating functions described above.
+      The parameters are the same as for <function>PlanForeignModify</>.
+     </para>
+ 
+     <para>
+      To execute the table update directly on the remote server, this function
+      must rewrite the target subplan with a <structname>ForeignScan</> plan
+      node that executes the table update directly on the remote server.  The
+      <structfield>operation</> field of the <structname>ForeignScan</> must
+      be set to the <literal>CmdType</> enumeration appropriately; that is,
+      <literal>CMD_UPDATE</> for <command>UPDATE</>,
+      <literal>CMD_INSERT</> for <command>INSERT</>, and
+      <literal>CMD_DELETE</> for <command>DELETE</>.
+     </para>
+ 
+     <para>
+      See <xref linkend="fdw-planning"> for additional information.
+     </para>
+ 
+     <para>
+      If the <function>PlanDMLPushdown</> pointer is set to
+      <literal>NULL</>, no attempts to execute the table update directly on
+      the remote server are taken.
+     </para>
+ 
+     <para>
+ <programlisting>
+ void
+ BeginDMLPushdown (ForeignScanState *node,
+                   int eflags);
+ </programlisting>
+ 
+      Begin executing a foreign table update directly on the remote server.
+      This is called during executor startup.  It should perform any
+      initialization needed prior to the actual table update (that should be
+      done upon the first call to <function>IterateDMLPushdown</>).
+      The <structname>ForeignScanState</> node has already been created, but
+      its <structfield>fdw_state</> field is still NULL.  Information about
+      the table to update is accessible through the
+      <structname>ForeignScanState</> node (in particular, from the underlying
+      <structname>ForeignScan</> plan node, which contains any FDW-private
+      information provided by <function>PlanDMLPushdown</>).
+      <literal>eflags</> contains flag bits describing the executor's
+      operating mode for this plan node.
+     </para>
+ 
+     <para>
+      Note that when <literal>(eflags &amp; EXEC_FLAG_EXPLAIN_ONLY)</> is
+      true, this function should not perform any externally-visible actions;
+      it should only do the minimum required to make the node state valid
+      for <function>ExplainDMLPushdown</> and <function>EndDMLPushdown</>.
+     </para>
+ 
+     <para>
+      If the <function>BeginDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
+     <para>
+ <programlisting>
+ TupleTableSlot *
+ IterateDMLPushdown (ForeignScanState *node);
+ </programlisting>
+ 
+      When the <command>INSERT</>, <command>UPDATE</> or <command>DELETE</>
+      query doesn't have a <literal>RETURNING</> clause, just return NULL
+      after the actual table update directly executed on the remote server.
+      When the query has the clause, fetch one result containing the data
+      needed for the <literal>RETURNING</> calculation, returning it in a
+      tuple table slot (the node's <structfield>ScanTupleSlot</> should be
+      used for this purpose).  The data that was actually inserted, updated
+      or deleted must be stored in the
+      <literal>es_result_relation_info-&gt;ri_projectReturning-&gt;pi_exprContext-&gt;ecxt_scantuple</>
+      of the node's <structname>EState</>.
+      Return NULL if no more rows are available.
+      Note that this is called in a short-lived memory context that will be
+      reset between invocations.  Create a memory context in
+      <function>BeginDMLPushdown</> if you need longer-lived storage, or use
+      the <structfield>es_query_cxt</> of the node's <structname>EState</>.
+     </para>
+ 
+     <para>
+      The rows returned must match the <structfield>fdw_scan_tlist</> target
+      list if one was supplied, otherwise they must match the row type of the
+      foreign table being updated.  If you choose to optimize away fetching
+      columns that are not needed for the <literal>RETURNING</> calculation,
+      you should insert nulls in those column positions, or else generate a
+      <structfield>fdw_scan_tlist</> list with those columns omitted.
+     </para>
+ 
+     <para>
+      Whether the query has the clause or not, the query's reported row count 
+      must be incremented by the FDW itself.  When the query doesn't has the
+      clause, the FDW must also increment the row count for the
+      <structname>ForeignScanState</> node in the <command>EXPLAIN ANALYZE</>
+      case.
+     </para>
+ 
+     <para>
+      If the <function>IterateDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
+     <para>
+ <programlisting>
+ void
+ EndDMLPushdown (ForeignScanState *node);
+ </programlisting>
+ 
+      End the table update and release resources.  It is normally not important
+      to release palloc'd memory, but for example open files and connections
+      to remote servers should be cleaned up.
+     </para>
+ 
+     <para>
+      If the <function>EndDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
     </sect2>
  
     <sect2 id="fdw-callbacks-row-locking">
***************
*** 848,853 **** ExplainForeignModify (ModifyTableState *mtstate,
--- 998,1026 ----
       <command>EXPLAIN</>.
      </para>
  
+     <para>
+ <programlisting>
+ void
+ ExplainDMLPushdown (ForeignScanState *node,
+                     ExplainState *es);
+ </programlisting>
+ 
+      Print additional <command>EXPLAIN</> output for a foreign table update
+      that is executed directly on the remote server.
+      This function can call <function>ExplainPropertyText</> and
+      related functions to add fields to the <command>EXPLAIN</> output.
+      The flag fields in <literal>es</> can be used to determine what to
+      print, and the state of the <structname>ForeignScanState</> node
+      can be inspected to provide run-time statistics in the <command>EXPLAIN
+      ANALYZE</> case.
+     </para>
+ 
+     <para>
+      If the <function>ExplainDMLPushdown</> pointer is set to
+      <literal>NULL</>, no additional information is printed during
+      <command>EXPLAIN</>.
+     </para>
+ 
     </sect2>
  
     <sect2 id="fdw-callbacks-analyze">
***************
*** 1068,1074 **** GetForeignServerByName(const char *name, bool missing_ok);
      <para>
       The FDW callback functions <function>GetForeignRelSize</>,
       <function>GetForeignPaths</>, <function>GetForeignPlan</>,
!      <function>PlanForeignModify</>, and <function>GetForeignJoinPaths</>
       must fit into the workings of the <productname>PostgreSQL</> planner.
       Here are some notes about what they must do.
      </para>
--- 1241,1248 ----
      <para>
       The FDW callback functions <function>GetForeignRelSize</>,
       <function>GetForeignPaths</>, <function>GetForeignPlan</>,
!      <function>PlanForeignModify</>, <function>GetForeignJoinPaths</>, and
!      <function>PlanDMLPushdown</>
       must fit into the workings of the <productname>PostgreSQL</> planner.
       Here are some notes about what they must do.
      </para>
***************
*** 1228,1234 **** GetForeignServerByName(const char *name, bool missing_ok);
  
      <para>
       When planning an <command>UPDATE</> or <command>DELETE</>,
!      <function>PlanForeignModify</> can look up the <structname>RelOptInfo</>
       struct for the foreign table and make use of the
       <literal>baserel-&gt;fdw_private</> data previously created by the
       scan-planning functions.  However, in <command>INSERT</> the target
--- 1402,1409 ----
  
      <para>
       When planning an <command>UPDATE</> or <command>DELETE</>,
!      <function>PlanForeignModify</> and <function>PlanDMLPushdown</>
!      can look up the <structname>RelOptInfo</>
       struct for the foreign table and make use of the
       <literal>baserel-&gt;fdw_private</> data previously created by the
       scan-planning functions.  However, in <command>INSERT</> the target
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 471,476 ****
--- 471,485 ----
     extension that's listed in the foreign server's <literal>extensions</>
     option.  Operators and functions in such clauses must
     be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, and no row-level local <literal>BEFORE</> or
+    <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, or <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 888,894 **** ExplainNode(PlanState *planstate, List *ancestors,
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			pname = sname = "Foreign Scan";
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
--- 888,916 ----
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			sname = "Foreign Scan";
! 			switch (((ForeignScan *) plan)->operation)
! 			{
! 				case CMD_SELECT:
! 					pname = "Foreign Scan";
! 					operation = "Select";
! 					break;
! 				case CMD_INSERT:
! 					pname = "Foreign Insert";
! 					operation = "Insert";
! 					break;
! 				case CMD_UPDATE:
! 					pname = "Foreign Update";
! 					operation = "Update";
! 					break;
! 				case CMD_DELETE:
! 					pname = "Foreign Delete";
! 					operation = "Delete";
! 					break;
! 				default:
! 					pname = "???";
! 					break;
! 			}
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
***************
*** 1636,1641 **** show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
--- 1658,1669 ----
  		return;
  	if (IsA(plan, RecursiveUnion))
  		return;
+ 	/* Likewise for ForeignScan that has pushed down INSERT/UPDATE/DELETE */
+ 	if (IsA(plan, ForeignScan) &&
+ 		(((ForeignScan *) plan)->operation == CMD_INSERT ||
+ 		 ((ForeignScan *) plan)->operation == CMD_UPDATE ||
+ 		 ((ForeignScan *) plan)->operation == CMD_DELETE))
+ 		return;
  
  	/* Set up deparsing context */
  	context = set_deparse_context_planstate(es->deparse_cxt,
***************
*** 2224,2231 **** show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es)
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (fdwroutine->ExplainForeignScan != NULL)
! 		fdwroutine->ExplainForeignScan(fsstate, es);
  }
  
  /*
--- 2252,2267 ----
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (((ForeignScan *) fsstate->ss.ps.plan)->operation != CMD_SELECT)
! 	{
! 		if (fdwroutine->ExplainDMLPushdown != NULL)
! 			fdwroutine->ExplainDMLPushdown(fsstate, es);
! 	}
! 	else
! 	{
! 		if (fdwroutine->ExplainForeignScan != NULL)
! 			fdwroutine->ExplainForeignScan(fsstate, es);
! 	}
  }
  
  /*
***************
*** 2611,2618 **** show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
  			}
  		}
  
! 		/* Give FDW a chance */
! 		if (fdwroutine && fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
--- 2647,2656 ----
  			}
  		}
  
! 		/* Give FDW a chance if needed */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			fdwroutine != NULL &&
! 			fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1011,1018 **** InitPlan(QueryDesc *queryDesc, int eflags)
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(Relation resultRel, CmdType operation)
  {
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
  
--- 1011,1019 ----
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
  {
+ 	Relation	resultRel = resultRelInfo->ri_RelationDesc;
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
  
***************
*** 1128,1133 **** CheckValidResultRel(Relation resultRel, CmdType operation)
--- 1129,1166 ----
  					elog(ERROR, "unrecognized CmdType: %d", (int) operation);
  					break;
  			}
+ 			if (resultRelInfo->ri_FdwPushdown)
+ 			{
+ 				if (fdwroutine->BeginDMLPushdown == NULL ||
+ 					fdwroutine->IterateDMLPushdown == NULL ||
+ 					fdwroutine->EndDMLPushdown == NULL)
+ 				{
+ 					switch (operation)
+ 					{
+ 						case CMD_INSERT:
+ 							ereport(ERROR,
+ 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 									 errmsg("cannot push down insert on foreign table \"%s\"",
+ 											RelationGetRelationName(resultRel))));
+ 							break;
+ 						case CMD_UPDATE:
+ 							ereport(ERROR,
+ 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 									 errmsg("cannot push down update on foreign table \"%s\"",
+ 											RelationGetRelationName(resultRel))));
+ 							break;
+ 						case CMD_DELETE:
+ 							ereport(ERROR,
+ 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 									 errmsg("cannot push down delete on foreign table \"%s\"",
+ 											RelationGetRelationName(resultRel))));
+ 							break;
+ 						default:
+ 							elog(ERROR, "unrecognized CmdType: %d", (int) operation);
+ 							break;
+ 					}
+ 				}
+ 			}
  			break;
  		default:
  			ereport(ERROR,
***************
*** 1245,1250 **** InitResultRelInfo(ResultRelInfo *resultRelInfo,
--- 1278,1284 ----
  	else
  		resultRelInfo->ri_FdwRoutine = NULL;
  	resultRelInfo->ri_FdwState = NULL;
+ 	resultRelInfo->ri_FdwPushdown = false;
  	resultRelInfo->ri_ConstraintExprs = NULL;
  	resultRelInfo->ri_junkFilter = NULL;
  	resultRelInfo->ri_projectReturning = NULL;
*** a/src/backend/executor/nodeForeignscan.c
--- b/src/backend/executor/nodeForeignscan.c
***************
*** 48,54 **** ForeignNext(ForeignScanState *node)
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
--- 48,57 ----
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	if (plan->operation != CMD_SELECT)
! 		slot = node->fdwroutine->IterateDMLPushdown(node);
! 	else
! 		slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
***************
*** 226,232 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
--- 229,238 ----
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	if (node->operation != CMD_SELECT)
! 		fdwroutine->BeginDMLPushdown(scanstate, eflags);
! 	else
! 		fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
***************
*** 240,247 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
  	/* Let the FDW shut down */
! 	node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
--- 246,258 ----
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
+ 	ForeignScan *plan = (ForeignScan *) node->ss.ps.plan;
+ 
  	/* Let the FDW shut down */
! 	if (plan->operation != CMD_SELECT)
! 		node->fdwroutine->EndDMLPushdown(node);
! 	else
! 		node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
*** a/src/backend/executor/nodeModifyTable.c
--- b/src/backend/executor/nodeModifyTable.c
***************
*** 138,150 **** ExecCheckPlanOutput(Relation resultRel, List *targetList)
   * tupleSlot: slot holding tuple actually inserted/updated/deleted
   * planSlot: slot holding tuple returned by top subplan node
   *
   * Returns a slot holding the result tuple
   */
  static TupleTableSlot *
! ExecProcessReturning(ProjectionInfo *projectReturning,
  					 TupleTableSlot *tupleSlot,
  					 TupleTableSlot *planSlot)
  {
  	ExprContext *econtext = projectReturning->pi_exprContext;
  
  	/*
--- 138,154 ----
   * tupleSlot: slot holding tuple actually inserted/updated/deleted
   * planSlot: slot holding tuple returned by top subplan node
   *
+  * Note: If tupleSlot is NULL, the FDW should have already provided econtext's
+  * scan tuple.
+  *
   * Returns a slot holding the result tuple
   */
  static TupleTableSlot *
! ExecProcessReturning(ResultRelInfo *resultRelInfo,
  					 TupleTableSlot *tupleSlot,
  					 TupleTableSlot *planSlot)
  {
+ 	ProjectionInfo *projectReturning = resultRelInfo->ri_projectReturning;
  	ExprContext *econtext = projectReturning->pi_exprContext;
  
  	/*
***************
*** 154,160 **** ExecProcessReturning(ProjectionInfo *projectReturning,
  	ResetExprContext(econtext);
  
  	/* Make tuple and any needed join variables available to ExecProject */
! 	econtext->ecxt_scantuple = tupleSlot;
  	econtext->ecxt_outertuple = planSlot;
  
  	/* Compute the RETURNING expressions */
--- 158,177 ----
  	ResetExprContext(econtext);
  
  	/* Make tuple and any needed join variables available to ExecProject */
! 	if (tupleSlot)
! 		econtext->ecxt_scantuple = tupleSlot;
! 	else
! 	{
! 		HeapTuple	tuple;
! 
! 		/*
! 		 * RETURNING expressions might reference the tableoid column, so
! 		 * initialize t_tableOid before evaluating them.
! 		 */
! 		Assert(!TupIsNull(econtext->ecxt_scantuple));
! 		tuple = ExecMaterializeSlot(econtext->ecxt_scantuple);
! 		tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
! 	}
  	econtext->ecxt_outertuple = planSlot;
  
  	/* Compute the RETURNING expressions */
***************
*** 496,503 **** ExecInsert(ModifyTableState *mtstate,
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									slot, planSlot);
  
  	return NULL;
  }
--- 513,519 ----
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  	return NULL;
  }
***************
*** 738,745 **** ldelete:;
  			ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);
  		}
  
! 		rslot = ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									 slot, planSlot);
  
  		/*
  		 * Before releasing the target tuple again, make sure rslot has a
--- 754,760 ----
  			ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);
  		}
  
! 		rslot = ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  		/*
  		 * Before releasing the target tuple again, make sure rslot has a
***************
*** 1024,1031 **** lreplace:;
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									slot, planSlot);
  
  	return NULL;
  }
--- 1039,1045 ----
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  	return NULL;
  }
***************
*** 1380,1385 **** ExecModifyTable(ModifyTableState *node)
--- 1394,1414 ----
  				break;
  		}
  
+ 		/*
+ 		 * If ri_FdwPushdown is true, all we need to do here is compute the
+ 		 * RETURNING expressions.
+ 		 */
+ 		if (resultRelInfo->ri_FdwPushdown)
+ 		{
+ 			Assert(resultRelInfo->ri_projectReturning);
+ 
+ 			/* No need to provide scan tuple to ExecProcessReturning. */
+ 			slot = ExecProcessReturning(resultRelInfo, NULL, planSlot);
+ 
+ 			estate->es_result_relation_info = saved_resultRelInfo;
+ 			return slot;
+ 		}
+ 
  		EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
  		slot = planSlot;
  
***************
*** 1559,1568 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  	{
  		subplan = (Plan *) lfirst(l);
  
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo->ri_RelationDesc, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
--- 1588,1600 ----
  	{
  		subplan = (Plan *) lfirst(l);
  
+ 		/* Initialize the FdwPushdown flag */
+ 		resultRelInfo->ri_FdwPushdown = list_nth_int(node->fdwPushdowns, i);
+ 
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
***************
*** 1583,1589 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
--- 1615,1622 ----
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
***************
*** 1754,1766 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1787,1811 ----
  		erm = ExecFindRowMark(estate, rc->rti, false);
  
  		/* build ExecAuxRowMark for each subplan */
+ 		resultRelInfo = mtstate->resultRelInfo;
  		for (i = 0; i < nplans; i++)
  		{
  			ExecAuxRowMark *aerm;
  
+ 			/*
+ 			 * ignore subplan if the FDW pushes down the command to the remote
+ 			 * server
+ 			 */
+ 			if (resultRelInfo->ri_FdwPushdown)
+ 			{
+ 				resultRelInfo++;
+ 				continue;
+ 			}
+ 
  			subplan = mtstate->mt_plans[i]->plan;
  			aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
  			mtstate->mt_arowmarks[i] = lappend(mtstate->mt_arowmarks[i], aerm);
+ 			resultRelInfo++;
  		}
  	}
  
***************
*** 1821,1826 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1866,1881 ----
  					ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
  										subplan->targetlist);
  
+ 				/*
+ 				 * ignore subplan if the FDW pushes down the command to the
+ 				 * remote server
+ 				 */
+ 				if (resultRelInfo->ri_FdwPushdown)
+ 				{
+ 					resultRelInfo++;
+ 					continue;
+ 				}
+ 
  				j = ExecInitJunkFilter(subplan->targetlist,
  							resultRelInfo->ri_RelationDesc->rd_att->tdhasoid,
  									   ExecInitExtraTupleSlot(estate));
***************
*** 1910,1916 **** ExecEndModifyTable(ModifyTableState *node)
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
--- 1965,1972 ----
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 187,192 **** _copyModifyTable(const ModifyTable *from)
--- 187,193 ----
  	COPY_NODE_FIELD(withCheckOptionLists);
  	COPY_NODE_FIELD(returningLists);
  	COPY_NODE_FIELD(fdwPrivLists);
+ 	COPY_NODE_FIELD(fdwPushdowns);
  	COPY_NODE_FIELD(rowMarks);
  	COPY_SCALAR_FIELD(epqParam);
  	COPY_SCALAR_FIELD(onConflictAction);
***************
*** 646,651 **** _copyForeignScan(const ForeignScan *from)
--- 647,653 ----
  	/*
  	 * copy remainder of node
  	 */
+ 	COPY_SCALAR_FIELD(operation);
  	COPY_SCALAR_FIELD(fs_server);
  	COPY_NODE_FIELD(fdw_exprs);
  	COPY_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 341,346 **** _outModifyTable(StringInfo str, const ModifyTable *node)
--- 341,347 ----
  	WRITE_NODE_FIELD(withCheckOptionLists);
  	WRITE_NODE_FIELD(returningLists);
  	WRITE_NODE_FIELD(fdwPrivLists);
+ 	WRITE_NODE_FIELD(fdwPushdowns);
  	WRITE_NODE_FIELD(rowMarks);
  	WRITE_INT_FIELD(epqParam);
  	WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
***************
*** 592,597 **** _outForeignScan(StringInfo str, const ForeignScan *node)
--- 593,599 ----
  
  	_outScanInfo(str, (const Scan *) node);
  
+ 	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_OID_FIELD(fs_server);
  	WRITE_NODE_FIELD(fdw_exprs);
  	WRITE_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/readfuncs.c
--- b/src/backend/nodes/readfuncs.c
***************
*** 1472,1477 **** _readModifyTable(void)
--- 1472,1478 ----
  	READ_NODE_FIELD(withCheckOptionLists);
  	READ_NODE_FIELD(returningLists);
  	READ_NODE_FIELD(fdwPrivLists);
+ 	READ_NODE_FIELD(fdwPushdowns);
  	READ_NODE_FIELD(rowMarks);
  	READ_INT_FIELD(epqParam);
  	READ_ENUM_FIELD(onConflictAction, OnConflictAction);
*** a/src/backend/optimizer/plan/createplan.c
--- b/src/backend/optimizer/plan/createplan.c
***************
*** 3779,3784 **** make_foreignscan(List *qptlist,
--- 3779,3785 ----
  	plan->lefttree = outer_plan;
  	plan->righttree = NULL;
  	node->scan.scanrelid = scanrelid;
+ 	node->operation = CMD_SELECT;
  	/* fs_server will be filled in by create_foreignscan_plan */
  	node->fs_server = InvalidOid;
  	node->fdw_exprs = fdw_exprs;
***************
*** 5055,5060 **** make_modifytable(PlannerInfo *root,
--- 5056,5062 ----
  	Plan	   *plan = &node->plan;
  	double		total_size;
  	List	   *fdw_private_list;
+ 	List	   *fdwpushdown_list;
  	ListCell   *subnode;
  	ListCell   *lc;
  	int			i;
***************
*** 5135,5146 **** make_modifytable(PlannerInfo *root,
--- 5137,5150 ----
  	 * construct private plan data, and accumulate it all into a list.
  	 */
  	fdw_private_list = NIL;
+ 	fdwpushdown_list = NIL;
  	i = 0;
  	foreach(lc, resultRelations)
  	{
  		Index		rti = lfirst_int(lc);
  		FdwRoutine *fdwroutine;
  		List	   *fdw_private;
+ 		bool		fdwpushdown;
  
  		/*
  		 * If possible, we want to get the FdwRoutine from our RelOptInfo for
***************
*** 5167,5173 **** make_modifytable(PlannerInfo *root,
--- 5171,5190 ----
  				fdwroutine = NULL;
  		}
  
+ 		/*
+ 		 * If the target relation has any row-level triggers, we can't push
+ 		 * down the command to the remote server.
+ 		 */
  		if (fdwroutine != NULL &&
+ 			fdwroutine->PlanDMLPushdown != NULL &&
+ 			!has_row_triggers(root, rti, operation))
+ 			fdwpushdown = fdwroutine->PlanDMLPushdown(root, node, rti, i);
+ 		else
+ 			fdwpushdown = false;
+ 		fdwpushdown_list = lappend_int(fdwpushdown_list, fdwpushdown);
+ 
+ 		if (!fdwpushdown &&
+ 			fdwroutine != NULL &&
  			fdwroutine->PlanForeignModify != NULL)
  			fdw_private = fdwroutine->PlanForeignModify(root, node, rti, i);
  		else
***************
*** 5176,5181 **** make_modifytable(PlannerInfo *root,
--- 5193,5199 ----
  		i++;
  	}
  	node->fdwPrivLists = fdw_private_list;
+ 	node->fdwPushdowns = fdwpushdown_list;
  
  	return node;
  }
*** a/src/backend/optimizer/util/plancat.c
--- b/src/backend/optimizer/util/plancat.c
***************
*** 1520,1522 **** has_unique_index(RelOptInfo *rel, AttrNumber attno)
--- 1520,1569 ----
  	}
  	return false;
  }
+ 
+ 
+ /*
+  * has_row_triggers
+  *
+  * Detect whether the specified relation has any row-level triggers for event.
+  */
+ bool
+ has_row_triggers(PlannerInfo *root, Index rti, CmdType event)
+ {
+ 	RangeTblEntry *rte = planner_rt_fetch(rti, root);
+ 	Relation	relation;
+ 	TriggerDesc *trigDesc;
+ 	bool		result = false;
+ 
+ 	/* Assume we already have adequate lock */
+ 	relation = heap_open(rte->relid, NoLock);
+ 
+ 	trigDesc = relation->trigdesc;
+ 	switch (event)
+ 	{
+ 		case CMD_INSERT:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_insert_after_row ||
+ 				 trigDesc->trig_insert_before_row))
+ 				result = true;
+ 			break;
+ 		case CMD_UPDATE:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_update_after_row ||
+ 				 trigDesc->trig_update_before_row))
+ 				result = true;
+ 			break;
+ 		case CMD_DELETE:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_delete_after_row ||
+ 				 trigDesc->trig_delete_before_row))
+ 				result = true;
+ 			break;
+ 		default:
+ 			elog(ERROR, "unrecognized CmdType: %d", (int) event);
+ 			break;
+ 	}
+ 
+ 	heap_close(relation, NoLock);
+ 	return result;
+ }
*** a/src/include/executor/executor.h
--- b/src/include/executor/executor.h
***************
*** 184,190 **** extern void ExecutorEnd(QueryDesc *queryDesc);
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(Relation resultRel, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
--- 184,190 ----
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
*** a/src/include/foreign/fdwapi.h
--- b/src/include/foreign/fdwapi.h
***************
*** 93,98 **** typedef void (*EndForeignModify_function) (EState *estate,
--- 93,110 ----
  
  typedef int (*IsForeignRelUpdatable_function) (Relation rel);
  
+ typedef bool (*PlanDMLPushdown_function) (PlannerInfo *root,
+ 										  ModifyTable *plan,
+ 										  Index resultRelation,
+ 										  int subplan_index);
+ 
+ typedef void (*BeginDMLPushdown_function) (ForeignScanState *node,
+ 										   int eflags);
+ 
+ typedef TupleTableSlot *(*IterateDMLPushdown_function) (ForeignScanState *node);
+ 
+ typedef void (*EndDMLPushdown_function) (ForeignScanState *node);
+ 
  typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
  												LockClauseStrength strength);
  
***************
*** 110,115 **** typedef void (*ExplainForeignModify_function) (ModifyTableState *mtstate,
--- 122,130 ----
  														   int subplan_index,
  													struct ExplainState *es);
  
+ typedef void (*ExplainDMLPushdown_function) (ForeignScanState *node,
+ 													struct ExplainState *es);
+ 
  typedef int (*AcquireSampleRowsFunc) (Relation relation, int elevel,
  											   HeapTuple *rows, int targrows,
  												  double *totalrows,
***************
*** 162,167 **** typedef struct FdwRoutine
--- 177,186 ----
  	ExecForeignDelete_function ExecForeignDelete;
  	EndForeignModify_function EndForeignModify;
  	IsForeignRelUpdatable_function IsForeignRelUpdatable;
+ 	PlanDMLPushdown_function PlanDMLPushdown;
+ 	BeginDMLPushdown_function BeginDMLPushdown;
+ 	IterateDMLPushdown_function IterateDMLPushdown;
+ 	EndDMLPushdown_function EndDMLPushdown;
  
  	/* Functions for SELECT FOR UPDATE/SHARE row locking */
  	GetForeignRowMarkType_function GetForeignRowMarkType;
***************
*** 171,176 **** typedef struct FdwRoutine
--- 190,196 ----
  	/* Support functions for EXPLAIN */
  	ExplainForeignScan_function ExplainForeignScan;
  	ExplainForeignModify_function ExplainForeignModify;
+ 	ExplainDMLPushdown_function ExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	AnalyzeForeignTable_function AnalyzeForeignTable;
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 311,316 **** typedef struct JunkFilter
--- 311,317 ----
   *		TrigInstrument			optional runtime measurements for triggers
   *		FdwRoutine				FDW callback functions, if foreign table
   *		FdwState				available to save private state of FDW
+  *		FdwPushdown				true when the command is pushed down
   *		WithCheckOptions		list of WithCheckOption's to be checked
   *		WithCheckOptionExprs	list of WithCheckOption expr states
   *		ConstraintExprs			array of constraint-checking expr states
***************
*** 334,339 **** typedef struct ResultRelInfo
--- 335,341 ----
  	Instrumentation *ri_TrigInstrument;
  	struct FdwRoutine *ri_FdwRoutine;
  	void	   *ri_FdwState;
+ 	bool		ri_FdwPushdown;
  	List	   *ri_WithCheckOptions;
  	List	   *ri_WithCheckOptionExprs;
  	List	  **ri_ConstraintExprs;
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
***************
*** 189,194 **** typedef struct ModifyTable
--- 189,195 ----
  	List	   *withCheckOptionLists;	/* per-target-table WCO lists */
  	List	   *returningLists; /* per-target-table RETURNING tlists */
  	List	   *fdwPrivLists;	/* per-target-table FDW private data lists */
+ 	List	   *fdwPushdowns;	/* per-target-table FDW pushdown flags */
  	List	   *rowMarks;		/* PlanRowMarks (non-locking only) */
  	int			epqParam;		/* ID of Param for EvalPlanQual re-eval */
  	OnConflictAction onConflictAction;	/* ON CONFLICT action */
***************
*** 531,536 **** typedef struct WorkTableScan
--- 532,538 ----
  typedef struct ForeignScan
  {
  	Scan		scan;
+ 	CmdType		operation;		/* SELECT/INSERT/UPDATE/DELETE */
  	Oid			fs_server;		/* OID of foreign server */
  	List	   *fdw_exprs;		/* expressions that FDW may evaluate */
  	List	   *fdw_private;	/* private data for FDW */
*** a/src/include/optimizer/plancat.h
--- b/src/include/optimizer/plancat.h
***************
*** 55,58 **** extern Selectivity join_selectivity(PlannerInfo *root,
--- 55,60 ----
  				 JoinType jointype,
  				 SpecialJoinInfo *sjinfo);
  
+ extern bool has_row_triggers(PlannerInfo *root, Index rti, CmdType event);
+ 
  #endif   /* PLANCAT_H */

*** a/contrib/postgres_fdw/deparse.c
--- b/contrib/postgres_fdw/deparse.c
***************
*** 1069,1074 **** deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 1069,1134 ----
  }
  
  /*
+  * deparse remote UPDATE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*targetlist,
+ 						   List *targetAttrs,
+ 						   List	*remote_conds,
+ 						   List **params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	deparse_expr_cxt context;
+ 	int			nestlevel;
+ 	bool		first;
+ 	ListCell   *lc;
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = params_list;
+ 
+ 	appendStringInfoString(buf, "UPDATE ");
+ 	deparseRelation(buf, rel);
+ 	appendStringInfoString(buf, " SET ");
+ 
+ 	/* Make sure any constants in the exprs are printed portably */
+ 	nestlevel = set_transmission_modes();
+ 
+ 	first = true;
+ 	foreach(lc, targetAttrs)
+ 	{
+ 		int			attnum = lfirst_int(lc);
+ 		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+ 
+ 		if (!first)
+ 			appendStringInfoString(buf, ", ");
+ 		first = false;
+ 
+ 		deparseColumnRef(buf, rtindex, attnum, root);
+ 		appendStringInfoString(buf, " = ");
+ 		deparseExpr((Expr *) tle->expr, &context);
+ 	}
+ 
+ 	reset_transmission_modes(nestlevel);
+ 
+ 	if (remote_conds)
+ 		appendWhereClause(remote_conds, &context);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * deparse remote DELETE statement
   *
   * The statement text is appended to buf, and we also create an integer List
***************
*** 1091,1096 **** deparseDeleteSql(StringInfo buf, PlannerInfo *root,
--- 1151,1190 ----
  }
  
  /*
+  * deparse remote DELETE statement
+  *
+  * The statement text is appended to buf, and we also create an integer List
+  * of the columns being retrieved by RETURNING (if any), which is returned
+  * to *retrieved_attrs.
+  */
+ void
+ deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 						   Index rtindex, Relation rel,
+ 						   List	*remote_conds,
+ 						   List	**params_list,
+ 						   List *returningList,
+ 						   List **retrieved_attrs)
+ {
+ 	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+ 	deparse_expr_cxt context;
+ 
+ 	/* Set up context struct for recursion */
+ 	context.root = root;
+ 	context.foreignrel = baserel;
+ 	context.buf = buf;
+ 	context.params_list = params_list;
+ 
+ 	appendStringInfoString(buf, "DELETE FROM ");
+ 	deparseRelation(buf, rel);
+ 
+ 	if (remote_conds)
+ 		appendWhereClause(remote_conds, &context);
+ 
+ 	deparseReturningList(buf, root, rtindex, rel, false,
+ 						 returningList, retrieved_attrs);
+ }
+ 
+ /*
   * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
   */
  static void
*** a/contrib/postgres_fdw/expected/postgres_fdw.out
--- b/contrib/postgres_fdw/expected/postgres_fdw.out
***************
*** 1314,1320 **** INSERT INTO ft2 (c1,c2,c3)
--- 1314,1339 ----
  (3 rows)
  
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                       QUERY PLAN                                                      
+ ----------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+ (3 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                             QUERY PLAN                                                                            
+ ------------------------------------------------------------------------------------------------------------------------------------------------------------------
+  Update on public.ft2
+    Output: c1, c2, c3, c4, c5, c6, c7, c8
+    ->  Foreign Update on public.ft2
+          Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+ (4 rows)
+ 
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
    c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
  ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
***************
*** 1424,1430 **** UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
--- 1443,1449 ----
  
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                              QUERY PLAN                                                                             
  -------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
***************
*** 1445,1460 **** UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
!                                        QUERY PLAN                                       
! ----------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
--- 1464,1477 ----
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
!                                          QUERY PLAN                                         
! --------------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: c1, c4
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
    c1  |              c4              
***************
*** 1565,1571 **** DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
--- 1582,1588 ----
  (103 rows)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                        QUERY PLAN                                                      
  ----------------------------------------------------------------------------------------------------------------------
   Delete on public.ft2
***************
*** 2426,2441 **** INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  (1 row)
  
  EXPLAIN (verbose, costs off)
! UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
!                                                     QUERY PLAN                                                     
! -------------------------------------------------------------------------------------------------------------------
   Update on public.ft2
     Output: (tableoid)::regclass
!    Remote SQL: UPDATE "S 1"."T 1" SET c3 = $2 WHERE ctid = $1
!    ->  Foreign Scan on public.ft2
!          Output: c1, c2, NULL::integer, 'bar'::text, c4, c5, c6, c7, c8, ctid
!          Remote SQL: SELECT "C 1", c2, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
! (6 rows)
  
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
--- 2443,2456 ----
  (1 row)
  
  EXPLAIN (verbose, costs off)
! UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;             -- can be pushed down
!                                      QUERY PLAN                                     
! ------------------------------------------------------------------------------------
   Update on public.ft2
     Output: (tableoid)::regclass
!    ->  Foreign Update on public.ft2
!          Remote SQL: UPDATE "S 1"."T 1" SET c3 = 'bar'::text WHERE (("C 1" = 9999))
! (4 rows)
  
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
***************
*** 2444,2459 **** UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  (1 row)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
!                                      QUERY PLAN                                     
! ------------------------------------------------------------------------------------
   Delete on public.ft2
     Output: (tableoid)::regclass
!    Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1
!    ->  Foreign Scan on public.ft2
!          Output: ctid
!          Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
! (6 rows)
  
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
--- 2459,2472 ----
  (1 row)
  
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;                       -- can be pushed down
!                              QUERY PLAN                             
! --------------------------------------------------------------------
   Delete on public.ft2
     Output: (tableoid)::regclass
!    ->  Foreign Delete on public.ft2
!          Remote SQL: DELETE FROM "S 1"."T 1" WHERE (("C 1" = 9999))
! (4 rows)
  
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
   tableoid 
***************
*** 2607,2613 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2620,2626 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  -- Test savepoint/rollback behavior
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2766,2772 **** savepoint s3;
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
--- 2779,2785 ----
  update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
  rollback to savepoint s3;
  select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
   c2  | count 
***************
*** 2906,2912 **** CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
--- 2919,2925 ----
  UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
  ERROR:  new row for relation "T 1" violates check constraint "c2positive"
  DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
! CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
  ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
  -- But inconsistent check constraints provide inconsistent results
  ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
***************
*** 3299,3304 **** NOTICE:  NEW: (13,"test triggered !")
--- 3312,3510 ----
   (0,27)
  (1 row)
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ -- Test DML pushdown functionality
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_before ON rem1;
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_stmt_after ON rem1;
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_before_update ON rem1;
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                   QUERY PLAN                                   
+ -------------------------------------------------------------------------------
+  Update on public.rem1
+    Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: f1, ''::text, ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+                  QUERY PLAN                  
+ ---------------------------------------------
+  Delete on public.rem1
+    ->  Foreign Delete on public.rem1
+          Remote SQL: DELETE FROM public.loc1
+ (3 rows)
+ 
+ DROP TRIGGER trig_row_after_update ON rem1;
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                              QUERY PLAN                              
+ ---------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+                         QUERY PLAN                        
+ ----------------------------------------------------------
+  Update on public.rem1
+    ->  Foreign Update on public.rem1
+          Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+ (3 rows)
+ 
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+                                QUERY PLAN                               
+ ------------------------------------------------------------------------
+  Delete on public.rem1
+    Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+    ->  Foreign Scan on public.rem1
+          Output: ctid, rem1.*
+          Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+ (5 rows)
+ 
+ DROP TRIGGER trig_row_after_delete ON rem1;
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
***************
*** 3768,3773 **** fetch from c;
--- 3974,4029 ----
  update bar set f2 = null where current of c;
  ERROR:  WHERE CURRENT OF is not supported for this table type
  rollback;
+ explain (verbose, costs off)
+ delete from foo where f1 < 5 returning *;
+                                    QUERY PLAN                                   
+ --------------------------------------------------------------------------------
+  Delete on public.foo
+    Output: foo.f1, foo.f2
+    Delete on public.foo
+    Foreign Delete on public.foo2
+    ->  Index Scan using i_foo_f1 on public.foo
+          Output: foo.ctid
+          Index Cond: (foo.f1 < 5)
+    ->  Foreign Delete on public.foo2
+          Remote SQL: DELETE FROM public.loct1 WHERE ((f1 < 5)) RETURNING f1, f2
+ (9 rows)
+ 
+ delete from foo where f1 < 5 returning *;
+  f1 | f2 
+ ----+----
+   1 |  1
+   3 |  3
+   0 |  0
+   2 |  2
+   4 |  4
+ (5 rows)
+ 
+ explain (verbose, costs off)
+ update bar set f2 = f2 + 100 returning *;
+                                   QUERY PLAN                                  
+ ------------------------------------------------------------------------------
+  Update on public.bar
+    Output: bar.f1, bar.f2
+    Update on public.bar
+    Foreign Update on public.bar2
+    ->  Seq Scan on public.bar
+          Output: bar.f1, (bar.f2 + 100), bar.ctid
+    ->  Foreign Update on public.bar2
+          Remote SQL: UPDATE public.loct2 SET f2 = (f2 + 100) RETURNING f1, f2
+ (8 rows)
+ 
+ update bar set f2 = f2 + 100 returning *;
+  f1 | f2  
+ ----+-----
+   1 | 311
+   2 | 322
+   6 | 266
+   3 | 333
+   4 | 344
+   7 | 277
+ (6 rows)
+ 
  drop table foo cascade;
  NOTICE:  drop cascades to foreign table foo2
  drop table bar cascade;
*** a/contrib/postgres_fdw/postgres_fdw.c
--- b/contrib/postgres_fdw/postgres_fdw.c
***************
*** 61,66 **** enum FdwScanPrivateIndex
--- 61,68 ----
  {
  	/* SQL statement to execute remotely (as a String node) */
  	FdwScanPrivateSelectSql,
+ 	/* List of restriction clauses that can be executed remotely */
+ 	FdwScanPrivateRemoteConds,
  	/* Integer list of attribute numbers retrieved by the SELECT */
  	FdwScanPrivateRetrievedAttrs,
  	/* Integer representing the desired fetch_size */
***************
*** 90,95 **** enum FdwModifyPrivateIndex
--- 92,119 ----
  };
  
  /*
+  * Similarly, this enum describes what's kept in the fdw_private list for
+  * a ForeignScan node that has pushed down an UPDATE/DELETE to the remote
+  * server.  We store:
+  *
+  * 1) UPDATE/DELETE statement text to be sent to the remote server
+  * 2) Boolean flag showing if the remote query has a RETURNING clause
+  * 3) Integer list of attribute numbers retrieved by RETURNING, if any
+  * 4) Boolean flag showing if we set the command es_processed
+  */
+ enum FdwDmlPushdownPrivateIndex
+ {
+ 	/* SQL statement to execute remotely (as a String node) */
+ 	FdwDmlPushdownPrivateUpdateSql,
+ 	/* has-returning flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateHasReturning,
+ 	/* Integer list of attribute numbers retrieved by RETURNING */
+ 	FdwDmlPushdownPrivateRetrievedAttrs,
+ 	/* set-processed flag (as an integer Value node) */
+ 	FdwDmlPushdownPrivateSetProcessed
+ };
+ 
+ /*
   * Execution state of a foreign scan using postgres_fdw.
   */
  typedef struct PgFdwScanState
***************
*** 154,159 **** typedef struct PgFdwModifyState
--- 178,214 ----
  } PgFdwModifyState;
  
  /*
+  * Execution state of a foreign scan that has pushed down a foreign table
+  * modification to the remote server
+  */
+ typedef struct PgFdwDmlPushdownState
+ {
+ 	Relation	rel;			/* relcache entry for the foreign table */
+ 	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
+ 
+ 	/* extracted fdw_private data */
+ 	char	   *query;			/* text of UPDATE/DELETE command */
+ 	bool		has_returning;	/* is there a RETURNING clause? */
+ 	List	   *retrieved_attrs;	/* attr numbers retrieved by RETURNING */
+ 	bool		set_processed;	/* do we set the command es_processed? */
+ 
+ 	/* for remote query execution */
+ 	PGconn	   *conn;			/* connection for the update */
+ 	int			numParams;		/* number of parameters passed to query */
+ 	FmgrInfo   *param_flinfo;	/* output conversion functions for them */
+ 	List	   *param_exprs;	/* executable expressions for param values */
+ 	const char **param_values;	/* textual values of query parameters */
+ 
+ 	/* for storing result tuples */
+ 	PGresult   *result;			/* result for query */
+ 	int			num_tuples;		/* # of result tuples */
+ 	int			next_tuple;		/* index of next one to return */
+ 
+ 	/* working memory context */
+ 	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
+ } PgFdwDmlPushdownState;
+ 
+ /*
   * Workspace for analyzing a foreign table.
   */
  typedef struct PgFdwAnalyzeState
***************
*** 245,250 **** static TupleTableSlot *postgresExecForeignDelete(EState *estate,
--- 300,312 ----
  static void postgresEndForeignModify(EState *estate,
  						 ResultRelInfo *resultRelInfo);
  static int	postgresIsForeignRelUpdatable(Relation rel);
+ static bool postgresPlanDMLPushdown(PlannerInfo *root,
+ 									ModifyTable *plan,
+ 									Index resultRelation,
+ 									int subplan_index);
+ static void postgresBeginDMLPushdown(ForeignScanState *node, int eflags);
+ static TupleTableSlot *postgresIterateDMLPushdown(ForeignScanState *node);
+ static void postgresEndDMLPushdown(ForeignScanState *node);
  static void postgresExplainForeignScan(ForeignScanState *node,
  						   ExplainState *es);
  static void postgresExplainForeignModify(ModifyTableState *mtstate,
***************
*** 252,257 **** static void postgresExplainForeignModify(ModifyTableState *mtstate,
--- 314,321 ----
  							 List *fdw_private,
  							 int subplan_index,
  							 ExplainState *es);
+ static void postgresExplainDMLPushdown(ForeignScanState *node,
+ 						   ExplainState *es);
  static bool postgresAnalyzeForeignTable(Relation relation,
  							AcquireSampleRowsFunc *func,
  							BlockNumber *totalpages);
***************
*** 288,293 **** static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
--- 352,359 ----
  						 TupleTableSlot *slot);
  static void store_returning_result(PgFdwModifyState *fmstate,
  					   TupleTableSlot *slot, PGresult *res);
+ static void execute_dml_stmt(ForeignScanState *node);
+ static TupleTableSlot *get_returning_data(ForeignScanState *node);
  static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
  							  HeapTuple *rows, int targrows,
  							  double *totalrows,
***************
*** 330,339 **** postgres_fdw_handler(PG_FUNCTION_ARGS)
--- 396,410 ----
  	routine->ExecForeignDelete = postgresExecForeignDelete;
  	routine->EndForeignModify = postgresEndForeignModify;
  	routine->IsForeignRelUpdatable = postgresIsForeignRelUpdatable;
+ 	routine->PlanDMLPushdown = postgresPlanDMLPushdown;
+ 	routine->BeginDMLPushdown = postgresBeginDMLPushdown;
+ 	routine->IterateDMLPushdown = postgresIterateDMLPushdown;
+ 	routine->EndDMLPushdown = postgresEndDMLPushdown;
  
  	/* Support functions for EXPLAIN */
  	routine->ExplainForeignScan = postgresExplainForeignScan;
  	routine->ExplainForeignModify = postgresExplainForeignModify;
+ 	routine->ExplainDMLPushdown = postgresExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	routine->AnalyzeForeignTable = postgresAnalyzeForeignTable;
***************
*** 1010,1016 **** postgresGetForeignPlan(PlannerInfo *root,
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make3(makeString(sql.data),
  							 retrieved_attrs,
  							 makeInteger(fpinfo->fetch_size));
  
--- 1081,1088 ----
  	 * Build the fdw_private list that will be available to the executor.
  	 * Items in the list must match enum FdwScanPrivateIndex, above.
  	 */
! 	fdw_private = list_make4(makeString(sql.data),
! 							 remote_conds,
  							 retrieved_attrs,
  							 makeInteger(fpinfo->fetch_size));
  
***************
*** 1307,1319 **** postgresAddForeignUpdateTargets(Query *parsetree,
  /*
   * postgresPlanForeignModify
   *		Plan an insert/update/delete operation on a foreign table
-  *
-  * Note: currently, the plan tree generated for UPDATE/DELETE will always
-  * include a ForeignScan that retrieves ctids (using SELECT FOR UPDATE)
-  * and then the ModifyTable node will have to execute individual remote
-  * UPDATE/DELETE commands.  If there are no local conditions or joins
-  * needed, it'd be better to let the scan node do UPDATE/DELETE RETURNING
-  * and then do nothing at ModifyTable.  Room for future optimization ...
   */
  static List *
  postgresPlanForeignModify(PlannerInfo *root,
--- 1379,1384 ----
***************
*** 1824,1829 **** postgresIsForeignRelUpdatable(Relation rel)
--- 1889,2225 ----
  }
  
  /*
+  * postgresPlanDMLPushdown
+  *		Consider pushing down a foreign table modification to the remote server
+  *
+  * Decide whether the table modification is safe to push down to the remote end,
+  * and if so, modify subplan so as to do that.
+  *
+  * Conditions checked here:
+  *
+  * 1. The table modification must be an UPDATE or DELETE.
+  *
+  * 2. It's unsafe to push down the command if there are any local joins needed.
+  *
+  * 3. It's unsafe to push down the command if there are any quals that can't be
+  *    evaluated remotely.
+  *
+  * 4. We can't push down an UPDATE, if any expressions to assign to the target
+  *    columns are unsafe to evaluate on the remote end.
+  */
+ static bool
+ postgresPlanDMLPushdown(PlannerInfo *root,
+ 						ModifyTable *plan,
+ 						Index resultRelation,
+ 						int subplan_index)
+ {
+ 	CmdType		operation = plan->operation;
+ 	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+ 	RangeTblEntry *rte = planner_rt_fetch(resultRelation, root);
+ 	Relation	rel;
+ 	StringInfoData sql;
+ 	ForeignScan *fscan;
+ 	List	   *targetAttrs = NIL;
+ 	List	   *remote_conds;
+ 	List	   *params_list = NIL;
+ 	List	   *returningList = NIL;
+ 	List	   *retrieved_attrs = NIL;
+ 
+ 	/*
+ 	 * Decide whether the table modification is safe to push down to the remote
+ 	 * server.
+ 	 */
+ 
+ 	/* Check point 1 */
+ 	if (operation == CMD_INSERT)
+ 		return false;
+ 
+ 	/* Check point 2 */
+ 	if (nodeTag(subplan) != T_ForeignScan)
+ 		return false;
+ 
+ 	/* Check point 3 */
+ 	if (subplan->qual != NIL)
+ 		return false;
+ 
+ 	/* Check point 4 */
+ 	if (operation == CMD_UPDATE)
+ 	{
+ 		RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+ 		int			col;
+ 
+ 		/*
+ 		 * We transmit only columns that were explicitly targets of the UPDATE,
+ 		 * so as to avoid unnecessary data transmission.
+ 		 */
+ 		col = -1;
+ 		while ((col = bms_next_member(rte->updatedCols, col)) >= 0)
+ 		{
+ 			/* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
+ 			AttrNumber	attno = col + FirstLowInvalidHeapAttributeNumber;
+ 			TargetEntry *tle;
+ 
+ 			if (attno <= InvalidAttrNumber)		/* shouldn't happen */
+ 				elog(ERROR, "system-column update is not supported");
+ 
+ 			tle = get_tle_by_resno(subplan->targetlist, attno);
+ 
+ 			if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+ 				return false;
+ 
+ 			targetAttrs = lappend_int(targetAttrs, attno);
+ 		}
+ 	}
+ 
+ 	/*
+ 	 * Ok, modify subplan so as to push down the command to the remote server.
+ 	 */
+ 	fscan = (ForeignScan *) subplan;
+ 
+ 	initStringInfo(&sql);
+ 
+ 	/*
+ 	 * Core code already has some lock on each rel being planned, so we can
+ 	 * use NoLock here.
+ 	 */
+ 	rel = heap_open(rte->relid, NoLock);
+ 
+ 	/*
+ 	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+ 	 */
+ 	remote_conds = (List *) list_nth(fscan->fdw_private,
+ 									 FdwScanPrivateRemoteConds);
+ 
+ 	/*
+ 	 * Extract the relevant RETURNING list if any.
+ 	 */
+ 	if (plan->returningLists)
+ 		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+ 
+ 	/*
+ 	 * Construct the SQL command string.
+ 	 */
+ 	switch (operation)
+ 	{
+ 		case CMD_UPDATE:
+ 			deparsePushedDownUpdateSql(&sql, root, resultRelation, rel,
+ 									   ((Plan *) fscan)->targetlist,
+ 									   targetAttrs,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		case CMD_DELETE:
+ 			deparsePushedDownDeleteSql(&sql, root, resultRelation, rel,
+ 									   remote_conds, &params_list,
+ 									   returningList, &retrieved_attrs);
+ 			break;
+ 		default:
+ 			elog(ERROR, "unexpected operation: %d", (int) operation);
+ 			break;
+ 	}
+ 
+ 	/*
+ 	 * Update the operation info.
+ 	 */
+ 	fscan->operation = operation;
+ 
+ 	/*
+ 	 * Update the fdw_exprs list that will be available to the executor.
+ 	 */
+ 	fscan->fdw_exprs = params_list;
+ 
+ 	/*
+ 	 * Update the fdw_private list that will be available to the executor.
+ 	 * Items in the list must match enum FdwDmlPushdownPrivateIndex, above.
+ 	 */
+ 	fscan->fdw_private = list_make4(makeString(sql.data),
+ 									makeInteger((retrieved_attrs != NIL)),
+ 									retrieved_attrs,
+ 									makeInteger(plan->canSetTag));
+ 
+ 	heap_close(rel, NoLock);
+ 	return true;
+ }
+ 
+ /*
+  * postgresBeginDMLPushdown
+  *		Initiate pushing down a foreign table modification to the remote server
+  */
+ static void
+ postgresBeginDMLPushdown(ForeignScanState *node, int eflags)
+ {
+ 	ForeignScan *fsplan = (ForeignScan *) node->ss.ps.plan;
+ 	EState	   *estate = node->ss.ps.state;
+ 	PgFdwDmlPushdownState *dpstate;
+ 	RangeTblEntry *rte;
+ 	Oid			userid;
+ 	ForeignTable *table;
+ 	UserMapping *user;
+ 	int			numParams;
+ 	int			i;
+ 	ListCell   *lc;
+ 
+ 	/*
+ 	 * Do nothing in EXPLAIN (no ANALYZE) case.  node->fdw_state stays NULL.
+ 	 */
+ 	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
+ 		return;
+ 
+ 	/*
+ 	 * We'll save private state in node->fdw_state.
+ 	 */
+ 	dpstate = (PgFdwDmlPushdownState *) palloc0(sizeof(PgFdwDmlPushdownState));
+ 	node->fdw_state = (void *) dpstate;
+ 
+ 	/*
+ 	 * Identify which user to do the remote access as.  This should match what
+ 	 * ExecCheckRTEPerms() does.
+ 	 */
+ 	rte = rt_fetch(fsplan->scan.scanrelid, estate->es_range_table);
+ 	userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
+ 
+ 	/* Get info about foreign table. */
+ 	dpstate->rel = node->ss.ss_currentRelation;
+ 	table = GetForeignTable(RelationGetRelid(dpstate->rel));
+ 	user = GetUserMapping(userid, table->serverid);
+ 
+ 	/*
+ 	 * Get connection to the foreign server.  Connection manager will
+ 	 * establish new connection if necessary.
+ 	 */
+ 	dpstate->conn = GetConnection(user, false);
+ 
+ 	/* Initialize state variable */
+ 	dpstate->num_tuples = -1;		/* -1 means not set yet */
+ 
+ 	/* Get private info created by planner functions. */
+ 	dpstate->query = strVal(list_nth(fsplan->fdw_private,
+ 									 FdwDmlPushdownPrivateUpdateSql));
+ 	dpstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateHasReturning));
+ 	dpstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+ 										FdwDmlPushdownPrivateRetrievedAttrs);
+ 	dpstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+ 										 FdwDmlPushdownPrivateSetProcessed));
+ 
+ 	/* Create context for per-tuple temp workspace. */
+ 	dpstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
+ 											  "postgres_fdw temporary data",
+ 											  ALLOCSET_SMALL_MINSIZE,
+ 											  ALLOCSET_SMALL_INITSIZE,
+ 											  ALLOCSET_SMALL_MAXSIZE);
+ 
+ 	/* Prepare for input conversion of RETURNING results. */
+ 	if (dpstate->has_returning)
+ 		dpstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(dpstate->rel));
+ 
+ 	/* Prepare for output conversion of parameters used in remote query. */
+ 	numParams = list_length(fsplan->fdw_exprs);
+ 	dpstate->numParams = numParams;
+ 	dpstate->param_flinfo = (FmgrInfo *) palloc0(sizeof(FmgrInfo) * numParams);
+ 
+ 	i = 0;
+ 	foreach(lc, fsplan->fdw_exprs)
+ 	{
+ 		Node	   *param_expr = (Node *) lfirst(lc);
+ 		Oid			typefnoid;
+ 		bool		isvarlena;
+ 
+ 		getTypeOutputInfo(exprType(param_expr), &typefnoid, &isvarlena);
+ 		fmgr_info(typefnoid, &dpstate->param_flinfo[i]);
+ 		i++;
+ 	}
+ 
+ 	/*
+ 	 * Prepare remote-parameter expressions for evaluation.  (Note: in
+ 	 * practice, we expect that all these expressions will be just Params, so
+ 	 * we could possibly do something more efficient than using the full
+ 	 * expression-eval machinery for this.  But probably there would be little
+ 	 * benefit, and it'd require postgres_fdw to know more than is desirable
+ 	 * about Param evaluation.)
+ 	 */
+ 	dpstate->param_exprs = (List *)
+ 		ExecInitExpr((Expr *) fsplan->fdw_exprs,
+ 					 (PlanState *) node);
+ 
+ 	/*
+ 	 * Allocate buffer for text form of query parameters, if any.
+ 	 */
+ 	if (numParams > 0)
+ 		dpstate->param_values = (const char **) palloc0(numParams * sizeof(char *));
+ 	else
+ 		dpstate->param_values = NULL;
+ }
+ 
+ /*
+  * postgresIterateDMLPushdown
+  *		Execute pushing down a foreign table modification to the remote server
+  */
+ static TupleTableSlot *
+ postgresIterateDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 
+ 	/*
+ 	 * If this is the first call after Begin, execute the statement.
+ 	 */
+ 	if (dpstate->num_tuples == -1)
+ 		execute_dml_stmt(node);
+ 
+ 	/*
+ 	 * If the local query doesn't specify RETURNING, just clear tuple slot.
+ 	 */
+ 	if (!resultRelInfo->ri_projectReturning)
+ 	{
+ 		TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 		Instrumentation *instr = node->ss.ps.instrument;
+ 
+ 		Assert(!dpstate->has_returning);
+ 
+ 		/* Increment the command es_processed count if necessary. */
+ 		if (dpstate->set_processed)
+ 			estate->es_processed += dpstate->num_tuples;
+ 
+ 		/* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
+ 		if (instr)
+ 			instr->tuplecount += dpstate->num_tuples;
+ 
+ 		return ExecClearTuple(slot);
+ 	}
+ 
+ 	/*
+ 	 * Get the next RETURNING tuple.
+ 	 */
+ 	return get_returning_data(node);
+ }
+ 
+ /*
+  * postgresEndDMLPushdown
+  *		Finish pushing down a foreign table modification to the remote server
+  */
+ static void
+ postgresEndDMLPushdown(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 
+ 	/* if dpstate is NULL, we are in EXPLAIN; nothing to do */
+ 	if (dpstate == NULL)
+ 		return;
+ 
+ 	/* Release PGresult */
+ 	if (dpstate->result)
+ 		PQclear(dpstate->result);
+ 
+ 	/* Release remote connection */
+ 	ReleaseConnection(dpstate->conn);
+ 	dpstate->conn = NULL;
+ 
+ 	/* MemoryContext will be deleted automatically. */
+ }
+ 
+ /*
   * postgresExplainForeignScan
   *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
   */
***************
*** 1861,1866 **** postgresExplainForeignModify(ModifyTableState *mtstate,
--- 2257,2281 ----
  	}
  }
  
+ /*
+  * postgresExplainDMLPushdown
+  *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
+  *		that has pushed down an UPDATE/DELETE to the remote server
+  */
+ static void
+ postgresExplainDMLPushdown(ForeignScanState *node, ExplainState *es)
+ {
+ 	List	   *fdw_private;
+ 	char	   *sql;
+ 
+ 	if (es->verbose)
+ 	{
+ 		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
+ 		sql = strVal(list_nth(fdw_private, FdwDmlPushdownPrivateUpdateSql));
+ 		ExplainPropertyText("Remote SQL", sql, es);
+ 	}
+ }
+ 
  
  /*
   * estimate_path_cost_size
***************
*** 2473,2478 **** store_returning_result(PgFdwModifyState *fmstate,
--- 2888,3026 ----
  }
  
  /*
+  * Execute a pushed-down UPDATE/DELETE statement.
+  */
+ static void
+ execute_dml_stmt(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	ExprContext *econtext = node->ss.ps.ps_ExprContext;
+ 	int			numParams = dpstate->numParams;
+ 	const char **values = dpstate->param_values;
+ 
+ 	/*
+ 	 * Construct array of query parameter values in text format.
+ 	 */
+ 	if (numParams > 0)
+ 	{
+ 		int			nestlevel;
+ 		int			i;
+ 		ListCell   *lc;
+ 
+ 		nestlevel = set_transmission_modes();
+ 
+ 		i = 0;
+ 		foreach(lc, dpstate->param_exprs)
+ 		{
+ 			ExprState  *expr_state = (ExprState *) lfirst(lc);
+ 			Datum		expr_value;
+ 			bool		isNull;
+ 
+ 			/* Evaluate the parameter expression */
+ 			expr_value = ExecEvalExpr(expr_state, econtext, &isNull, NULL);
+ 
+ 			/*
+ 			 * Get string representation of each parameter value by invoking
+ 			 * type-specific output function, unless the value is null.
+ 			 */
+ 			if (isNull)
+ 				values[i] = NULL;
+ 			else
+ 				values[i] = OutputFunctionCall(&dpstate->param_flinfo[i],
+ 											   expr_value);
+ 			i++;
+ 		}
+ 
+ 		reset_transmission_modes(nestlevel);
+ 	}
+ 
+ 	/*
+ 	 * Notice that we pass NULL for paramTypes, thus forcing the remote server
+ 	 * to infer types for all parameters.  Since we explicitly cast every
+ 	 * parameter (see deparse.c), the "inference" is trivial and will produce
+ 	 * the desired result.  This allows us to avoid assuming that the remote
+ 	 * server has the same OIDs we do for the parameters' types.
+ 	 *
+ 	 * We don't use a PG_TRY block here, so be careful not to throw error
+ 	 * without releasing the PGresult.
+ 	 */
+ 	dpstate->result = PQexecParams(dpstate->conn, dpstate->query,
+ 								   numParams, NULL, values, NULL, NULL, 0);
+ 	if (PQresultStatus(dpstate->result) !=
+ 		(dpstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+ 		pgfdw_report_error(ERROR, dpstate->result, dpstate->conn, true,
+ 						   dpstate->query);
+ 
+ 	/* Get the number of rows affected. */
+ 	if (dpstate->has_returning)
+ 		dpstate->num_tuples = PQntuples(dpstate->result);
+ 	else
+ 		dpstate->num_tuples = atoi(PQcmdTuples(dpstate->result));
+ }
+ 
+ /*
+  * Get the result of a RETURNING clause.
+  */
+ static TupleTableSlot *
+ get_returning_data(ForeignScanState *node)
+ {
+ 	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+ 	EState	   *estate = node->ss.ps.state;
+ 	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+ 	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+ 
+ 	Assert(resultRelInfo->ri_projectReturning);
+ 
+ 	/* If we didn't get any tuples, must be end of data. */
+ 	if (dpstate->next_tuple >= dpstate->num_tuples)
+ 		return ExecClearTuple(slot);
+ 
+ 	/* Increment the command es_processed count if necessary. */
+ 	if (dpstate->set_processed)
+ 		estate->es_processed += 1;
+ 
+ 	/*
+ 	 * Store a RETURNING tuple.  If has_returning is false, just emit a dummy
+ 	 * tuple.  (We have has_returning=false if the local query is of the form
+ 	 * UPDATE/DELETE .. RETURNING 1 for example.)
+ 	 */
+ 	if (!dpstate->has_returning)
+ 		ExecStoreAllNullTuple(slot);
+ 	else
+ 	{
+ 		/*
+ 		 * On error, be sure to release the PGresult on the way out.  Callers
+ 		 * do not have PG_TRY blocks to ensure this happens.
+ 		 */
+ 		PG_TRY();
+ 		{
+ 			HeapTuple	newtup;
+ 
+ 			newtup = make_tuple_from_result_row(dpstate->result,
+ 												dpstate->next_tuple,
+ 												dpstate->rel,
+ 												dpstate->attinmeta,
+ 												dpstate->retrieved_attrs,
+ 												dpstate->temp_cxt);
+ 			ExecStoreTuple(newtup, slot, InvalidBuffer, false);
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			if (dpstate->result)
+ 				PQclear(dpstate->result);
+ 			PG_RE_THROW();
+ 		}
+ 		PG_END_TRY();
+ 	}
+ 	dpstate->next_tuple++;
+ 
+ 	/* Make slot available for evaluation of the local query RETURNING list. */
+ 	resultRelInfo->ri_projectReturning->pi_exprContext->ecxt_scantuple = slot;
+ 
+ 	return slot;
+ }
+ 
+ /*
   * postgresAnalyzeForeignTable
   *		Test whether analyzing this foreign table is supported
   */
*** a/contrib/postgres_fdw/postgres_fdw.h
--- b/contrib/postgres_fdw/postgres_fdw.h
***************
*** 93,102 **** extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
--- 93,116 ----
  				 Index rtindex, Relation rel,
  				 List *targetAttrs, List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*targetlist,
+ 									   List *targetAttrs,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
  				 Index rtindex, Relation rel,
  				 List *returningList,
  				 List **retrieved_attrs);
+ extern void deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+ 									   Index rtindex, Relation rel,
+ 									   List	*remote_conds,
+ 									   List **params_list,
+ 									   List *returningList,
+ 									   List **retrieved_attrs);
  extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
  extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
  				  List **retrieved_attrs);
*** a/contrib/postgres_fdw/sql/postgres_fdw.sql
--- b/contrib/postgres_fdw/sql/postgres_fdw.sql
***************
*** 399,426 **** INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  EXPLAIN (verbose, costs off)
  INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  EXPLAIN (verbose, costs off)
! UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  
  -- Test that trigger on remote table works as expected
--- 399,430 ----
  INSERT INTO ft2 (c1,c2,c3)
    VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
  INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+ EXPLAIN (verbose, costs off)
+ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
  UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
  EXPLAIN (verbose, costs off)
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
!   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
  UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
    FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
  EXPLAIN (verbose, costs off)
!   DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
  DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
  SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
  EXPLAIN (verbose, costs off)
  INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
  EXPLAIN (verbose, costs off)
! UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;             -- can be pushed down
  UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  EXPLAIN (verbose, costs off)
! DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;                       -- can be pushed down
  DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  
  -- Test that trigger on remote table works as expected
***************
*** 737,742 **** UPDATE rem1 SET f2 = 'testo';
--- 741,830 ----
  -- Test returning a system attribute
  INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
  
+ -- cleanup
+ DROP TRIGGER trig_row_before ON rem1;
+ DROP TRIGGER trig_row_after ON rem1;
+ DROP TRIGGER trig_local_before ON loc1;
+ 
+ 
+ -- Test DML pushdown functionality
+ 
+ -- Test with statement-level triggers
+ CREATE TRIGGER trig_stmt_before
+ 	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_before ON rem1;
+ 
+ CREATE TRIGGER trig_stmt_after
+ 	AFTER DELETE OR INSERT OR UPDATE ON rem1
+ 	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_stmt_after ON rem1;
+ 
+ -- Test with row-level ON INSERT triggers
+ CREATE TRIGGER trig_row_before_insert
+ BEFORE INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_insert ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_insert
+ AFTER INSERT ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_insert ON rem1;
+ 
+ -- Test with row-level ON UPDATE triggers
+ CREATE TRIGGER trig_row_before_update
+ BEFORE UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_before_update ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_update
+ AFTER UPDATE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can't be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can be pushed down
+ DROP TRIGGER trig_row_after_update ON rem1;
+ 
+ -- Test with row-level ON DELETE triggers
+ CREATE TRIGGER trig_row_before_delete
+ BEFORE DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_before_delete ON rem1;
+ 
+ CREATE TRIGGER trig_row_after_delete
+ AFTER DELETE ON rem1
+ FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+ EXPLAIN (verbose, costs off)
+ UPDATE rem1 set f2 = '';          -- can be pushed down
+ EXPLAIN (verbose, costs off)
+ DELETE FROM rem1;                 -- can't be pushed down
+ DROP TRIGGER trig_row_after_delete ON rem1;
+ 
  -- ===================================================================
  -- test inheritance features
  -- ===================================================================
***************
*** 868,873 **** fetch from c;
--- 956,968 ----
  update bar set f2 = null where current of c;
  rollback;
  
+ explain (verbose, costs off)
+ delete from foo where f1 < 5 returning *;
+ delete from foo where f1 < 5 returning *;
+ explain (verbose, costs off)
+ update bar set f2 = f2 + 100 returning *;
+ update bar set f2 = f2 + 100 returning *;
+ 
  drop table foo cascade;
  drop table bar cascade;
  drop table loct1;
*** a/doc/src/sgml/fdwhandler.sgml
--- b/doc/src/sgml/fdwhandler.sgml
***************
*** 672,684 **** IsForeignRelUpdatable (Relation rel);
       <literal>NULL</>, foreign tables are assumed to be insertable, updatable,
       or deletable if the FDW provides <function>ExecForeignInsert</>,
       <function>ExecForeignUpdate</>, or <function>ExecForeignDelete</>
!      respectively.  This function is only needed if the FDW supports some
       tables that are updatable and some that are not.  (Even then, it's
       permissible to throw an error in the execution routine instead of
       checking in this function.  However, this function is used to determine
       updatability for display in the <literal>information_schema</> views.)
      </para>
  
     </sect2>
  
     <sect2 id="fdw-callbacks-row-locking">
--- 672,833 ----
       <literal>NULL</>, foreign tables are assumed to be insertable, updatable,
       or deletable if the FDW provides <function>ExecForeignInsert</>,
       <function>ExecForeignUpdate</>, or <function>ExecForeignDelete</>
!      respectively.
!      (If the FDW optimizes a foreign table update on a foreign table using
!      <function>PlanDMLPushdown</>, it still needs to provide
!      <function>BeginDMLPushdown</>, <function>IterateDMLPushdown</> and
!      <function>EndDMLPushdown</> to execute the optimized update.)
!      This function is only needed if the FDW supports some
       tables that are updatable and some that are not.  (Even then, it's
       permissible to throw an error in the execution routine instead of
       checking in this function.  However, this function is used to determine
       updatability for display in the <literal>information_schema</> views.)
      </para>
  
+     <para>
+      If an FDW supports an optimization that executes a foreign table update
+      directly on the remote server, it should provide the following callback
+      functions in addition to the table-updating functions described above:
+     </para>
+ 
+     <para>
+ <programlisting>
+ bool
+ PlanDMLPushdown (PlannerInfo *root,
+                  ModifyTable *plan,
+                  Index resultRelation,
+                  int subplan_index);
+ </programlisting>
+ 
+      Decide whether it is safe to execute a foreign table update directly
+      on the remote server.  If so, return <literal>true</> after performing
+      planning actions needed for that.  Otherwise, return <literal>false</>.
+      This optional function is called during query planning.
+      If this function succeeds, <function>BeginDMLPushdown</>,
+      <function>IterateDMLPushdown</> and <function>EndDMLPushdown</> will be
+      called at the execution stage, instead.  Otherwise, the table update
+      will be executed using the table-updating functions described above.
+      The parameters are the same as for <function>PlanForeignModify</>.
+     </para>
+ 
+     <para>
+      To execute the table update directly on the remote server, this function
+      must rewrite the target subplan with a <structname>ForeignScan</> plan
+      node that executes the table update directly on the remote server.  The
+      <structfield>operation</> field of the <structname>ForeignScan</> must
+      be set to the <literal>CmdType</> enumeration appropriately; that is,
+      <literal>CMD_UPDATE</> for <command>UPDATE</>,
+      <literal>CMD_INSERT</> for <command>INSERT</>, and
+      <literal>CMD_DELETE</> for <command>DELETE</>.
+     </para>
+ 
+     <para>
+      See <xref linkend="fdw-planning"> for additional information.
+     </para>
+ 
+     <para>
+      If the <function>PlanDMLPushdown</> pointer is set to
+      <literal>NULL</>, no attempts to execute the table update directly on
+      the remote server are taken.
+     </para>
+ 
+     <para>
+ <programlisting>
+ void
+ BeginDMLPushdown (ForeignScanState *node,
+                   int eflags);
+ </programlisting>
+ 
+      Begin executing a foreign table update directly on the remote server.
+      This is called during executor startup.  It should perform any
+      initialization needed prior to the actual table update (that should be
+      done upon the first call to <function>IterateDMLPushdown</>).
+      The <structname>ForeignScanState</> node has already been created, but
+      its <structfield>fdw_state</> field is still NULL.  Information about
+      the table to update is accessible through the
+      <structname>ForeignScanState</> node (in particular, from the underlying
+      <structname>ForeignScan</> plan node, which contains any FDW-private
+      information provided by <function>PlanDMLPushdown</>).
+      <literal>eflags</> contains flag bits describing the executor's
+      operating mode for this plan node.
+     </para>
+ 
+     <para>
+      Note that when <literal>(eflags &amp; EXEC_FLAG_EXPLAIN_ONLY)</> is
+      true, this function should not perform any externally-visible actions;
+      it should only do the minimum required to make the node state valid
+      for <function>ExplainDMLPushdown</> and <function>EndDMLPushdown</>.
+     </para>
+ 
+     <para>
+      If the <function>BeginDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
+     <para>
+ <programlisting>
+ TupleTableSlot *
+ IterateDMLPushdown (ForeignScanState *node);
+ </programlisting>
+ 
+      When the <command>INSERT</>, <command>UPDATE</> or <command>DELETE</>
+      query doesn't have a <literal>RETURNING</> clause, just return NULL
+      after the actual table update directly executed on the remote server.
+      When the query has the clause, fetch one result containing the data
+      needed for the <literal>RETURNING</> calculation, returning it in a
+      tuple table slot (the node's <structfield>ScanTupleSlot</> should be
+      used for this purpose).  The data that was actually inserted, updated
+      or deleted must be stored in the
+      <literal>es_result_relation_info-&gt;ri_projectReturning-&gt;pi_exprContext-&gt;ecxt_scantuple</>
+      of the node's <structname>EState</>.
+      Return NULL if no more rows are available.
+      Note that this is called in a short-lived memory context that will be
+      reset between invocations.  Create a memory context in
+      <function>BeginDMLPushdown</> if you need longer-lived storage, or use
+      the <structfield>es_query_cxt</> of the node's <structname>EState</>.
+     </para>
+ 
+     <para>
+      The rows returned must match the <structfield>fdw_scan_tlist</> target
+      list if one was supplied, otherwise they must match the row type of the
+      foreign table being updated.  If you choose to optimize away fetching
+      columns that are not needed for the <literal>RETURNING</> calculation,
+      you should insert nulls in those column positions, or else generate a
+      <structfield>fdw_scan_tlist</> list with those columns omitted.
+     </para>
+ 
+     <para>
+      Whether the query has the clause or not, the query's reported row count 
+      must be incremented by the FDW itself.  When the query doesn't has the
+      clause, the FDW must also increment the row count for the
+      <structname>ForeignScanState</> node in the <command>EXPLAIN ANALYZE</>
+      case.
+     </para>
+ 
+     <para>
+      If the <function>IterateDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
+     <para>
+ <programlisting>
+ void
+ EndDMLPushdown (ForeignScanState *node);
+ </programlisting>
+ 
+      End the table update and release resources.  It is normally not important
+      to release palloc'd memory, but for example open files and connections
+      to remote servers should be cleaned up.
+     </para>
+ 
+     <para>
+      If the <function>EndDMLPushdown</> pointer is set to
+      <literal>NULL</>, attempts to execute the table update directly on
+      the remote server will fail with an error message.
+     </para>
+ 
     </sect2>
  
     <sect2 id="fdw-callbacks-row-locking">
***************
*** 866,871 **** ExplainForeignModify (ModifyTableState *mtstate,
--- 1015,1043 ----
       <command>EXPLAIN</>.
      </para>
  
+     <para>
+ <programlisting>
+ void
+ ExplainDMLPushdown (ForeignScanState *node,
+                     ExplainState *es);
+ </programlisting>
+ 
+      Print additional <command>EXPLAIN</> output for a foreign table update
+      that is executed directly on the remote server.
+      This function can call <function>ExplainPropertyText</> and
+      related functions to add fields to the <command>EXPLAIN</> output.
+      The flag fields in <literal>es</> can be used to determine what to
+      print, and the state of the <structname>ForeignScanState</> node
+      can be inspected to provide run-time statistics in the <command>EXPLAIN
+      ANALYZE</> case.
+     </para>
+ 
+     <para>
+      If the <function>ExplainDMLPushdown</> pointer is set to
+      <literal>NULL</>, no additional information is printed during
+      <command>EXPLAIN</>.
+     </para>
+ 
     </sect2>
  
     <sect2 id="fdw-callbacks-analyze">
***************
*** 1147,1153 **** GetForeignServerByName(const char *name, bool missing_ok);
      <para>
       The FDW callback functions <function>GetForeignRelSize</>,
       <function>GetForeignPaths</>, <function>GetForeignPlan</>,
!      <function>PlanForeignModify</>, and <function>GetForeignJoinPaths</>
       must fit into the workings of the <productname>PostgreSQL</> planner.
       Here are some notes about what they must do.
      </para>
--- 1319,1326 ----
      <para>
       The FDW callback functions <function>GetForeignRelSize</>,
       <function>GetForeignPaths</>, <function>GetForeignPlan</>,
!      <function>PlanForeignModify</>, <function>GetForeignJoinPaths</>, and
!      <function>PlanDMLPushdown</>
       must fit into the workings of the <productname>PostgreSQL</> planner.
       Here are some notes about what they must do.
      </para>
***************
*** 1307,1313 **** GetForeignServerByName(const char *name, bool missing_ok);
  
      <para>
       When planning an <command>UPDATE</> or <command>DELETE</>,
!      <function>PlanForeignModify</> can look up the <structname>RelOptInfo</>
       struct for the foreign table and make use of the
       <literal>baserel-&gt;fdw_private</> data previously created by the
       scan-planning functions.  However, in <command>INSERT</> the target
--- 1480,1487 ----
  
      <para>
       When planning an <command>UPDATE</> or <command>DELETE</>,
!      <function>PlanForeignModify</> and <function>PlanDMLPushdown</>
!      can look up the <structname>RelOptInfo</>
       struct for the foreign table and make use of the
       <literal>baserel-&gt;fdw_private</> data previously created by the
       scan-planning functions.  However, in <command>INSERT</> the target
*** a/doc/src/sgml/postgres-fdw.sgml
--- b/doc/src/sgml/postgres-fdw.sgml
***************
*** 484,489 ****
--- 484,498 ----
     extension that's listed in the foreign server's <literal>extensions</>
     option.  Operators and functions in such clauses must
     be <literal>IMMUTABLE</> as well.
+    For an <command>UPDATE</> or <command>DELETE</> query,
+    <filename>postgres_fdw</> attempts to optimize the query execution by
+    sending the whole query to the remote server if there are no query
+    <literal>WHERE</> clauses that cannot be sent to the remote server,
+    no local joins for the query, and no row-level local <literal>BEFORE</> or
+    <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+    expressions to assign to target columns must use only built-in data types,
+    <literal>IMMUTABLE</> operators, or <literal>IMMUTABLE</> functions,
+    to reduce the risk of misexecution of the query.
    </para>
  
    <para>
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 888,894 **** ExplainNode(PlanState *planstate, List *ancestors,
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			pname = sname = "Foreign Scan";
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
--- 888,916 ----
  			pname = sname = "WorkTable Scan";
  			break;
  		case T_ForeignScan:
! 			sname = "Foreign Scan";
! 			switch (((ForeignScan *) plan)->operation)
! 			{
! 				case CMD_SELECT:
! 					pname = "Foreign Scan";
! 					operation = "Select";
! 					break;
! 				case CMD_INSERT:
! 					pname = "Foreign Insert";
! 					operation = "Insert";
! 					break;
! 				case CMD_UPDATE:
! 					pname = "Foreign Update";
! 					operation = "Update";
! 					break;
! 				case CMD_DELETE:
! 					pname = "Foreign Delete";
! 					operation = "Delete";
! 					break;
! 				default:
! 					pname = "???";
! 					break;
! 			}
  			break;
  		case T_CustomScan:
  			sname = "Custom Scan";
***************
*** 1636,1641 **** show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
--- 1658,1669 ----
  		return;
  	if (IsA(plan, RecursiveUnion))
  		return;
+ 	/* Likewise for ForeignScan that has pushed down INSERT/UPDATE/DELETE */
+ 	if (IsA(plan, ForeignScan) &&
+ 		(((ForeignScan *) plan)->operation == CMD_INSERT ||
+ 		 ((ForeignScan *) plan)->operation == CMD_UPDATE ||
+ 		 ((ForeignScan *) plan)->operation == CMD_DELETE))
+ 		return;
  
  	/* Set up deparsing context */
  	context = set_deparse_context_planstate(es->deparse_cxt,
***************
*** 2224,2231 **** show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es)
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (fdwroutine->ExplainForeignScan != NULL)
! 		fdwroutine->ExplainForeignScan(fsstate, es);
  }
  
  /*
--- 2252,2267 ----
  	FdwRoutine *fdwroutine = fsstate->fdwroutine;
  
  	/* Let the FDW emit whatever fields it wants */
! 	if (((ForeignScan *) fsstate->ss.ps.plan)->operation != CMD_SELECT)
! 	{
! 		if (fdwroutine->ExplainDMLPushdown != NULL)
! 			fdwroutine->ExplainDMLPushdown(fsstate, es);
! 	}
! 	else
! 	{
! 		if (fdwroutine->ExplainForeignScan != NULL)
! 			fdwroutine->ExplainForeignScan(fsstate, es);
! 	}
  }
  
  /*
***************
*** 2611,2618 **** show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
  			}
  		}
  
! 		/* Give FDW a chance */
! 		if (fdwroutine && fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
--- 2647,2656 ----
  			}
  		}
  
! 		/* Give FDW a chance if needed */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			fdwroutine != NULL &&
! 			fdwroutine->ExplainForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
  
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1011,1018 **** InitPlan(QueryDesc *queryDesc, int eflags)
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(Relation resultRel, CmdType operation)
  {
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
  
--- 1011,1019 ----
   * CheckValidRowMarkRel.
   */
  void
! CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
  {
+ 	Relation	resultRel = resultRelInfo->ri_RelationDesc;
  	TriggerDesc *trigDesc = resultRel->trigdesc;
  	FdwRoutine *fdwroutine;
  
***************
*** 1128,1133 **** CheckValidResultRel(Relation resultRel, CmdType operation)
--- 1129,1166 ----
  					elog(ERROR, "unrecognized CmdType: %d", (int) operation);
  					break;
  			}
+ 			if (resultRelInfo->ri_FdwPushdown)
+ 			{
+ 				if (fdwroutine->BeginDMLPushdown == NULL ||
+ 					fdwroutine->IterateDMLPushdown == NULL ||
+ 					fdwroutine->EndDMLPushdown == NULL)
+ 				{
+ 					switch (operation)
+ 					{
+ 						case CMD_INSERT:
+ 							ereport(ERROR,
+ 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 									 errmsg("cannot push down insert on foreign table \"%s\"",
+ 											RelationGetRelationName(resultRel))));
+ 							break;
+ 						case CMD_UPDATE:
+ 							ereport(ERROR,
+ 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 									 errmsg("cannot push down update on foreign table \"%s\"",
+ 											RelationGetRelationName(resultRel))));
+ 							break;
+ 						case CMD_DELETE:
+ 							ereport(ERROR,
+ 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 									 errmsg("cannot push down delete on foreign table \"%s\"",
+ 											RelationGetRelationName(resultRel))));
+ 							break;
+ 						default:
+ 							elog(ERROR, "unrecognized CmdType: %d", (int) operation);
+ 							break;
+ 					}
+ 				}
+ 			}
  			break;
  		default:
  			ereport(ERROR,
***************
*** 1245,1250 **** InitResultRelInfo(ResultRelInfo *resultRelInfo,
--- 1278,1284 ----
  	else
  		resultRelInfo->ri_FdwRoutine = NULL;
  	resultRelInfo->ri_FdwState = NULL;
+ 	resultRelInfo->ri_FdwPushdown = false;
  	resultRelInfo->ri_ConstraintExprs = NULL;
  	resultRelInfo->ri_junkFilter = NULL;
  	resultRelInfo->ri_projectReturning = NULL;
*** a/src/backend/executor/nodeForeignscan.c
--- b/src/backend/executor/nodeForeignscan.c
***************
*** 48,54 **** ForeignNext(ForeignScanState *node)
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
--- 48,57 ----
  
  	/* Call the Iterate function in short-lived context */
  	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
! 	if (plan->operation != CMD_SELECT)
! 		slot = node->fdwroutine->IterateDMLPushdown(node);
! 	else
! 		slot = node->fdwroutine->IterateForeignScan(node);
  	MemoryContextSwitchTo(oldcontext);
  
  	/*
***************
*** 226,232 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
--- 229,238 ----
  	/*
  	 * Tell the FDW to initialize the scan.
  	 */
! 	if (node->operation != CMD_SELECT)
! 		fdwroutine->BeginDMLPushdown(scanstate, eflags);
! 	else
! 		fdwroutine->BeginForeignScan(scanstate, eflags);
  
  	return scanstate;
  }
***************
*** 240,247 **** ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
  	/* Let the FDW shut down */
! 	node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
--- 246,258 ----
  void
  ExecEndForeignScan(ForeignScanState *node)
  {
+ 	ForeignScan *plan = (ForeignScan *) node->ss.ps.plan;
+ 
  	/* Let the FDW shut down */
! 	if (plan->operation != CMD_SELECT)
! 		node->fdwroutine->EndDMLPushdown(node);
! 	else
! 		node->fdwroutine->EndForeignScan(node);
  
  	/* Shut down any outer plan. */
  	if (outerPlanState(node))
*** a/src/backend/executor/nodeModifyTable.c
--- b/src/backend/executor/nodeModifyTable.c
***************
*** 138,150 **** ExecCheckPlanOutput(Relation resultRel, List *targetList)
   * tupleSlot: slot holding tuple actually inserted/updated/deleted
   * planSlot: slot holding tuple returned by top subplan node
   *
   * Returns a slot holding the result tuple
   */
  static TupleTableSlot *
! ExecProcessReturning(ProjectionInfo *projectReturning,
  					 TupleTableSlot *tupleSlot,
  					 TupleTableSlot *planSlot)
  {
  	ExprContext *econtext = projectReturning->pi_exprContext;
  
  	/*
--- 138,154 ----
   * tupleSlot: slot holding tuple actually inserted/updated/deleted
   * planSlot: slot holding tuple returned by top subplan node
   *
+  * Note: If tupleSlot is NULL, the FDW should have already provided econtext's
+  * scan tuple.
+  *
   * Returns a slot holding the result tuple
   */
  static TupleTableSlot *
! ExecProcessReturning(ResultRelInfo *resultRelInfo,
  					 TupleTableSlot *tupleSlot,
  					 TupleTableSlot *planSlot)
  {
+ 	ProjectionInfo *projectReturning = resultRelInfo->ri_projectReturning;
  	ExprContext *econtext = projectReturning->pi_exprContext;
  
  	/*
***************
*** 154,160 **** ExecProcessReturning(ProjectionInfo *projectReturning,
  	ResetExprContext(econtext);
  
  	/* Make tuple and any needed join variables available to ExecProject */
! 	econtext->ecxt_scantuple = tupleSlot;
  	econtext->ecxt_outertuple = planSlot;
  
  	/* Compute the RETURNING expressions */
--- 158,177 ----
  	ResetExprContext(econtext);
  
  	/* Make tuple and any needed join variables available to ExecProject */
! 	if (tupleSlot)
! 		econtext->ecxt_scantuple = tupleSlot;
! 	else
! 	{
! 		HeapTuple	tuple;
! 
! 		/*
! 		 * RETURNING expressions might reference the tableoid column, so
! 		 * initialize t_tableOid before evaluating them.
! 		 */
! 		Assert(!TupIsNull(econtext->ecxt_scantuple));
! 		tuple = ExecMaterializeSlot(econtext->ecxt_scantuple);
! 		tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
! 	}
  	econtext->ecxt_outertuple = planSlot;
  
  	/* Compute the RETURNING expressions */
***************
*** 496,503 **** ExecInsert(ModifyTableState *mtstate,
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									slot, planSlot);
  
  	return NULL;
  }
--- 513,519 ----
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  	return NULL;
  }
***************
*** 738,745 **** ldelete:;
  			ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);
  		}
  
! 		rslot = ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									 slot, planSlot);
  
  		/*
  		 * Before releasing the target tuple again, make sure rslot has a
--- 754,760 ----
  			ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);
  		}
  
! 		rslot = ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  		/*
  		 * Before releasing the target tuple again, make sure rslot has a
***************
*** 1024,1031 **** lreplace:;
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo->ri_projectReturning,
! 									slot, planSlot);
  
  	return NULL;
  }
--- 1039,1045 ----
  
  	/* Process RETURNING if present */
  	if (resultRelInfo->ri_projectReturning)
! 		return ExecProcessReturning(resultRelInfo, slot, planSlot);
  
  	return NULL;
  }
***************
*** 1380,1385 **** ExecModifyTable(ModifyTableState *node)
--- 1394,1414 ----
  				break;
  		}
  
+ 		/*
+ 		 * If ri_FdwPushdown is true, all we need to do here is compute the
+ 		 * RETURNING expressions.
+ 		 */
+ 		if (resultRelInfo->ri_FdwPushdown)
+ 		{
+ 			Assert(resultRelInfo->ri_projectReturning);
+ 
+ 			/* No need to provide scan tuple to ExecProcessReturning. */
+ 			slot = ExecProcessReturning(resultRelInfo, NULL, planSlot);
+ 
+ 			estate->es_result_relation_info = saved_resultRelInfo;
+ 			return slot;
+ 		}
+ 
  		EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
  		slot = planSlot;
  
***************
*** 1559,1568 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  	{
  		subplan = (Plan *) lfirst(l);
  
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo->ri_RelationDesc, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
--- 1588,1600 ----
  	{
  		subplan = (Plan *) lfirst(l);
  
+ 		/* Initialize the FdwPushdown flag */
+ 		resultRelInfo->ri_FdwPushdown = list_nth_int(node->fdwPushdowns, i);
+ 
  		/*
  		 * Verify result relation is a valid target for the current operation
  		 */
! 		CheckValidResultRel(resultRelInfo, operation);
  
  		/*
  		 * If there are indices on the result relation, open them and save
***************
*** 1583,1589 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
--- 1615,1622 ----
  		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
  
  		/* Also let FDWs init themselves for foreign-table result rels */
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
  		{
  			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
***************
*** 1754,1766 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1787,1811 ----
  		erm = ExecFindRowMark(estate, rc->rti, false);
  
  		/* build ExecAuxRowMark for each subplan */
+ 		resultRelInfo = mtstate->resultRelInfo;
  		for (i = 0; i < nplans; i++)
  		{
  			ExecAuxRowMark *aerm;
  
+ 			/*
+ 			 * ignore subplan if the FDW pushes down the command to the remote
+ 			 * server
+ 			 */
+ 			if (resultRelInfo->ri_FdwPushdown)
+ 			{
+ 				resultRelInfo++;
+ 				continue;
+ 			}
+ 
  			subplan = mtstate->mt_plans[i]->plan;
  			aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
  			mtstate->mt_arowmarks[i] = lappend(mtstate->mt_arowmarks[i], aerm);
+ 			resultRelInfo++;
  		}
  	}
  
***************
*** 1821,1826 **** ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
--- 1866,1881 ----
  					ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
  										subplan->targetlist);
  
+ 				/*
+ 				 * ignore subplan if the FDW pushes down the command to the
+ 				 * remote server
+ 				 */
+ 				if (resultRelInfo->ri_FdwPushdown)
+ 				{
+ 					resultRelInfo++;
+ 					continue;
+ 				}
+ 
  				j = ExecInitJunkFilter(subplan->targetlist,
  							resultRelInfo->ri_RelationDesc->rd_att->tdhasoid,
  									   ExecInitExtraTupleSlot(estate));
***************
*** 1910,1916 **** ExecEndModifyTable(ModifyTableState *node)
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
--- 1965,1972 ----
  	{
  		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
! 		if (!resultRelInfo->ri_FdwPushdown &&
! 			resultRelInfo->ri_FdwRoutine != NULL &&
  			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
  			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
  														   resultRelInfo);
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 187,192 **** _copyModifyTable(const ModifyTable *from)
--- 187,193 ----
  	COPY_NODE_FIELD(withCheckOptionLists);
  	COPY_NODE_FIELD(returningLists);
  	COPY_NODE_FIELD(fdwPrivLists);
+ 	COPY_NODE_FIELD(fdwPushdowns);
  	COPY_NODE_FIELD(rowMarks);
  	COPY_SCALAR_FIELD(epqParam);
  	COPY_SCALAR_FIELD(onConflictAction);
***************
*** 646,651 **** _copyForeignScan(const ForeignScan *from)
--- 647,653 ----
  	/*
  	 * copy remainder of node
  	 */
+ 	COPY_SCALAR_FIELD(operation);
  	COPY_SCALAR_FIELD(fs_server);
  	COPY_NODE_FIELD(fdw_exprs);
  	COPY_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/outfuncs.c
--- b/src/backend/nodes/outfuncs.c
***************
*** 341,346 **** _outModifyTable(StringInfo str, const ModifyTable *node)
--- 341,347 ----
  	WRITE_NODE_FIELD(withCheckOptionLists);
  	WRITE_NODE_FIELD(returningLists);
  	WRITE_NODE_FIELD(fdwPrivLists);
+ 	WRITE_NODE_FIELD(fdwPushdowns);
  	WRITE_NODE_FIELD(rowMarks);
  	WRITE_INT_FIELD(epqParam);
  	WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
***************
*** 592,597 **** _outForeignScan(StringInfo str, const ForeignScan *node)
--- 593,599 ----
  
  	_outScanInfo(str, (const Scan *) node);
  
+ 	WRITE_ENUM_FIELD(operation, CmdType);
  	WRITE_OID_FIELD(fs_server);
  	WRITE_NODE_FIELD(fdw_exprs);
  	WRITE_NODE_FIELD(fdw_private);
*** a/src/backend/nodes/readfuncs.c
--- b/src/backend/nodes/readfuncs.c
***************
*** 1472,1477 **** _readModifyTable(void)
--- 1472,1478 ----
  	READ_NODE_FIELD(withCheckOptionLists);
  	READ_NODE_FIELD(returningLists);
  	READ_NODE_FIELD(fdwPrivLists);
+ 	READ_NODE_FIELD(fdwPushdowns);
  	READ_NODE_FIELD(rowMarks);
  	READ_INT_FIELD(epqParam);
  	READ_ENUM_FIELD(onConflictAction, OnConflictAction);
*** a/src/backend/optimizer/plan/createplan.c
--- b/src/backend/optimizer/plan/createplan.c
***************
*** 3788,3793 **** make_foreignscan(List *qptlist,
--- 3788,3794 ----
  	plan->lefttree = outer_plan;
  	plan->righttree = NULL;
  	node->scan.scanrelid = scanrelid;
+ 	node->operation = CMD_SELECT;
  	/* fs_server will be filled in by create_foreignscan_plan */
  	node->fs_server = InvalidOid;
  	node->fdw_exprs = fdw_exprs;
***************
*** 5064,5069 **** make_modifytable(PlannerInfo *root,
--- 5065,5071 ----
  	Plan	   *plan = &node->plan;
  	double		total_size;
  	List	   *fdw_private_list;
+ 	List	   *fdwpushdown_list;
  	ListCell   *subnode;
  	ListCell   *lc;
  	int			i;
***************
*** 5144,5155 **** make_modifytable(PlannerInfo *root,
--- 5146,5159 ----
  	 * construct private plan data, and accumulate it all into a list.
  	 */
  	fdw_private_list = NIL;
+ 	fdwpushdown_list = NIL;
  	i = 0;
  	foreach(lc, resultRelations)
  	{
  		Index		rti = lfirst_int(lc);
  		FdwRoutine *fdwroutine;
  		List	   *fdw_private;
+ 		bool		fdwpushdown;
  
  		/*
  		 * If possible, we want to get the FdwRoutine from our RelOptInfo for
***************
*** 5176,5182 **** make_modifytable(PlannerInfo *root,
--- 5180,5199 ----
  				fdwroutine = NULL;
  		}
  
+ 		/*
+ 		 * If the target relation has any row-level triggers, we can't push
+ 		 * down the command to the remote server.
+ 		 */
  		if (fdwroutine != NULL &&
+ 			fdwroutine->PlanDMLPushdown != NULL &&
+ 			!has_row_triggers(root, rti, operation))
+ 			fdwpushdown = fdwroutine->PlanDMLPushdown(root, node, rti, i);
+ 		else
+ 			fdwpushdown = false;
+ 		fdwpushdown_list = lappend_int(fdwpushdown_list, fdwpushdown);
+ 
+ 		if (!fdwpushdown &&
+ 			fdwroutine != NULL &&
  			fdwroutine->PlanForeignModify != NULL)
  			fdw_private = fdwroutine->PlanForeignModify(root, node, rti, i);
  		else
***************
*** 5185,5190 **** make_modifytable(PlannerInfo *root,
--- 5202,5208 ----
  		i++;
  	}
  	node->fdwPrivLists = fdw_private_list;
+ 	node->fdwPushdowns = fdwpushdown_list;
  
  	return node;
  }
*** a/src/backend/optimizer/util/plancat.c
--- b/src/backend/optimizer/util/plancat.c
***************
*** 1520,1522 **** has_unique_index(RelOptInfo *rel, AttrNumber attno)
--- 1520,1569 ----
  	}
  	return false;
  }
+ 
+ 
+ /*
+  * has_row_triggers
+  *
+  * Detect whether the specified relation has any row-level triggers for event.
+  */
+ bool
+ has_row_triggers(PlannerInfo *root, Index rti, CmdType event)
+ {
+ 	RangeTblEntry *rte = planner_rt_fetch(rti, root);
+ 	Relation	relation;
+ 	TriggerDesc *trigDesc;
+ 	bool		result = false;
+ 
+ 	/* Assume we already have adequate lock */
+ 	relation = heap_open(rte->relid, NoLock);
+ 
+ 	trigDesc = relation->trigdesc;
+ 	switch (event)
+ 	{
+ 		case CMD_INSERT:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_insert_after_row ||
+ 				 trigDesc->trig_insert_before_row))
+ 				result = true;
+ 			break;
+ 		case CMD_UPDATE:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_update_after_row ||
+ 				 trigDesc->trig_update_before_row))
+ 				result = true;
+ 			break;
+ 		case CMD_DELETE:
+ 			if (trigDesc &&
+ 				(trigDesc->trig_delete_after_row ||
+ 				 trigDesc->trig_delete_before_row))
+ 				result = true;
+ 			break;
+ 		default:
+ 			elog(ERROR, "unrecognized CmdType: %d", (int) event);
+ 			break;
+ 	}
+ 
+ 	heap_close(relation, NoLock);
+ 	return result;
+ }
*** a/src/include/executor/executor.h
--- b/src/include/executor/executor.h
***************
*** 184,190 **** extern void ExecutorEnd(QueryDesc *queryDesc);
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(Relation resultRel, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
--- 184,190 ----
  extern void standard_ExecutorEnd(QueryDesc *queryDesc);
  extern void ExecutorRewind(QueryDesc *queryDesc);
  extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
! extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation);
  extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
  				  Relation resultRelationDesc,
  				  Index resultRelationIndex,
*** a/src/include/foreign/fdwapi.h
--- b/src/include/foreign/fdwapi.h
***************
*** 94,99 **** typedef void (*EndForeignModify_function) (EState *estate,
--- 94,111 ----
  
  typedef int (*IsForeignRelUpdatable_function) (Relation rel);
  
+ typedef bool (*PlanDMLPushdown_function) (PlannerInfo *root,
+ 										  ModifyTable *plan,
+ 										  Index resultRelation,
+ 										  int subplan_index);
+ 
+ typedef void (*BeginDMLPushdown_function) (ForeignScanState *node,
+ 										   int eflags);
+ 
+ typedef TupleTableSlot *(*IterateDMLPushdown_function) (ForeignScanState *node);
+ 
+ typedef void (*EndDMLPushdown_function) (ForeignScanState *node);
+ 
  typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
  												LockClauseStrength strength);
  
***************
*** 111,116 **** typedef void (*ExplainForeignModify_function) (ModifyTableState *mtstate,
--- 123,131 ----
  														   int subplan_index,
  													struct ExplainState *es);
  
+ typedef void (*ExplainDMLPushdown_function) (ForeignScanState *node,
+ 													struct ExplainState *es);
+ 
  typedef int (*AcquireSampleRowsFunc) (Relation relation, int elevel,
  											   HeapTuple *rows, int targrows,
  												  double *totalrows,
***************
*** 171,176 **** typedef struct FdwRoutine
--- 186,195 ----
  	ExecForeignDelete_function ExecForeignDelete;
  	EndForeignModify_function EndForeignModify;
  	IsForeignRelUpdatable_function IsForeignRelUpdatable;
+ 	PlanDMLPushdown_function PlanDMLPushdown;
+ 	BeginDMLPushdown_function BeginDMLPushdown;
+ 	IterateDMLPushdown_function IterateDMLPushdown;
+ 	EndDMLPushdown_function EndDMLPushdown;
  
  	/* Functions for SELECT FOR UPDATE/SHARE row locking */
  	GetForeignRowMarkType_function GetForeignRowMarkType;
***************
*** 180,185 **** typedef struct FdwRoutine
--- 199,205 ----
  	/* Support functions for EXPLAIN */
  	ExplainForeignScan_function ExplainForeignScan;
  	ExplainForeignModify_function ExplainForeignModify;
+ 	ExplainDMLPushdown_function ExplainDMLPushdown;
  
  	/* Support functions for ANALYZE */
  	AnalyzeForeignTable_function AnalyzeForeignTable;
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 311,316 **** typedef struct JunkFilter
--- 311,317 ----
   *		TrigInstrument			optional runtime measurements for triggers
   *		FdwRoutine				FDW callback functions, if foreign table
   *		FdwState				available to save private state of FDW
+  *		FdwPushdown				true when the command is pushed down
   *		WithCheckOptions		list of WithCheckOption's to be checked
   *		WithCheckOptionExprs	list of WithCheckOption expr states
   *		ConstraintExprs			array of constraint-checking expr states
***************
*** 334,339 **** typedef struct ResultRelInfo
--- 335,341 ----
  	Instrumentation *ri_TrigInstrument;
  	struct FdwRoutine *ri_FdwRoutine;
  	void	   *ri_FdwState;
+ 	bool		ri_FdwPushdown;
  	List	   *ri_WithCheckOptions;
  	List	   *ri_WithCheckOptionExprs;
  	List	  **ri_ConstraintExprs;
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
***************
*** 189,194 **** typedef struct ModifyTable
--- 189,195 ----
  	List	   *withCheckOptionLists;	/* per-target-table WCO lists */
  	List	   *returningLists; /* per-target-table RETURNING tlists */
  	List	   *fdwPrivLists;	/* per-target-table FDW private data lists */
+ 	List	   *fdwPushdowns;	/* per-target-table FDW pushdown flags */
  	List	   *rowMarks;		/* PlanRowMarks (non-locking only) */
  	int			epqParam;		/* ID of Param for EvalPlanQual re-eval */
  	OnConflictAction onConflictAction;	/* ON CONFLICT action */
***************
*** 531,536 **** typedef struct WorkTableScan
--- 532,538 ----
  typedef struct ForeignScan
  {
  	Scan		scan;
+ 	CmdType		operation;		/* SELECT/INSERT/UPDATE/DELETE */
  	Oid			fs_server;		/* OID of foreign server */
  	List	   *fdw_exprs;		/* expressions that FDW may evaluate */
  	List	   *fdw_private;	/* private data for FDW */
*** a/src/include/optimizer/plancat.h
--- b/src/include/optimizer/plancat.h
***************
*** 55,58 **** extern Selectivity join_selectivity(PlannerInfo *root,
--- 55,60 ----
  				 JoinType jointype,
  				 SpecialJoinInfo *sjinfo);
  
+ extern bool has_row_triggers(PlannerInfo *root, Index rti, CmdType event);
+ 
  #endif   /* PLANCAT_H */

diff --git a/src/backend/executor/.execMain.c.swp b/src/backend/executor/.execMain.c.swp
index 6f54fd9..8a29cc6 100644
Binary files a/src/backend/executor/.execMain.c.swp and b/src/backend/executor/.execMain.c.swp differ
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index eb24051..04d90ea 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -1082,86 +1082,88 @@ CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
 								RelationGetRelationName(resultRel))));
 			break;
 		case RELKIND_FOREIGN_TABLE:
-			/* Okay only if the FDW supports it */
-			fdwroutine = GetFdwRoutineForRelation(resultRel, false);
-			switch (operation)
-			{
-				case CMD_INSERT:
-					if (fdwroutine->ExecForeignInsert == NULL)
-						ereport(ERROR,
-								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-							errmsg("cannot insert into foreign table \"%s\"",
-								   RelationGetRelationName(resultRel))));
-					if (fdwroutine->IsForeignRelUpdatable != NULL &&
-						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
-						ereport(ERROR,
-						  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-						errmsg("foreign table \"%s\" does not allow inserts",
-							   RelationGetRelationName(resultRel))));
-					break;
-				case CMD_UPDATE:
-					if (fdwroutine->ExecForeignUpdate == NULL)
-						ereport(ERROR,
-								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-								 errmsg("cannot update foreign table \"%s\"",
-										RelationGetRelationName(resultRel))));
-					if (fdwroutine->IsForeignRelUpdatable != NULL &&
-						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_UPDATE)) == 0)
-						ereport(ERROR,
-						  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-						errmsg("foreign table \"%s\" does not allow updates",
-							   RelationGetRelationName(resultRel))));
-					break;
-				case CMD_DELETE:
-					if (fdwroutine->ExecForeignDelete == NULL)
-						ereport(ERROR,
-								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-							errmsg("cannot delete from foreign table \"%s\"",
-								   RelationGetRelationName(resultRel))));
-					if (fdwroutine->IsForeignRelUpdatable != NULL &&
-						(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_DELETE)) == 0)
-						ereport(ERROR,
-						  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
-						errmsg("foreign table \"%s\" does not allow deletes",
-							   RelationGetRelationName(resultRel))));
-					break;
-				default:
-					elog(ERROR, "unrecognized CmdType: %d", (int) operation);
-					break;
-			}
-			if (resultRelInfo->ri_FdwPushdown)
 			{
-				if (fdwroutine->BeginDMLPushdown == NULL ||
-					fdwroutine->IterateDMLPushdown == NULL ||
-					fdwroutine->EndDMLPushdown == NULL)
+				/*
+				 * Mark DMLPushdownOk if DML is pushed down safe and FDW provides
+				 * the DMLPushdown APIs. Later if ExecForeignInsert or
+				 * ExecForeignUpdate or ExecForeignDelete is missing and
+				 * DMLPushdownOk is false, then only throw an error.
+				 */
+				bool	DMLPushdownOk = false;
+				/* Okay only if the FDW supports it */
+				fdwroutine = GetFdwRoutineForRelation(resultRel, false);
+				if (resultRelInfo->ri_FdwPushdown)
 				{
-					switch (operation)
+					if (fdwroutine->BeginDMLPushdown == NULL ||
+						fdwroutine->IterateDMLPushdown == NULL ||
+						fdwroutine->EndDMLPushdown == NULL)
 					{
-						case CMD_INSERT:
+						switch (operation)
+						{
+							case CMD_INSERT:
+							case CMD_UPDATE:
+							case CMD_DELETE:
+								DMLPushdownOk = false;
+								break;
+							default:
+								elog(ERROR, "unrecognized CmdType: %d", (int) operation);
+								break;
+						}
+					}
+					else
+						DMLPushdownOk = true;
+				}
+
+				switch (operation)
+				{
+					case CMD_INSERT:
+						if (fdwroutine->ExecForeignInsert == NULL &&
+							!DMLPushdownOk)
 							ereport(ERROR,
 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-									 errmsg("cannot push down insert on foreign table \"%s\"",
+									 errmsg("cannot insert into foreign table \"%s\"",
 											RelationGetRelationName(resultRel))));
-							break;
-						case CMD_UPDATE:
+						if (fdwroutine->IsForeignRelUpdatable != NULL &&
+							(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
+							ereport(ERROR,
+									(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+									 errmsg("foreign table \"%s\" does not allow inserts",
+											RelationGetRelationName(resultRel))));
+						break;
+					case CMD_UPDATE:
+						if (fdwroutine->ExecForeignUpdate == NULL &&
+							!DMLPushdownOk)
 							ereport(ERROR,
 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-									 errmsg("cannot push down update on foreign table \"%s\"",
+									 errmsg("cannot update foreign table \"%s\"",
 											RelationGetRelationName(resultRel))));
-							break;
-						case CMD_DELETE:
+						if (fdwroutine->IsForeignRelUpdatable != NULL &&
+							(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_UPDATE)) == 0)
+							ereport(ERROR,
+									(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+									 errmsg("foreign table \"%s\" does not allow updates",
+											RelationGetRelationName(resultRel))));
+						break;
+					case CMD_DELETE:
+						if (fdwroutine->ExecForeignDelete == NULL &&
+							!DMLPushdownOk)
 							ereport(ERROR,
 									(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-									 errmsg("cannot push down delete on foreign table \"%s\"",
+									 errmsg("cannot delete from foreign table \"%s\"",
 											RelationGetRelationName(resultRel))));
-							break;
-						default:
-							elog(ERROR, "unrecognized CmdType: %d", (int) operation);
-							break;
-					}
+						if (fdwroutine->IsForeignRelUpdatable != NULL &&
+							(fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_DELETE)) == 0)
+							ereport(ERROR,
+									(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+									 errmsg("foreign table \"%s\" does not allow deletes",
+											RelationGetRelationName(resultRel))));
+						break;
+					default:
+						elog(ERROR, "unrecognized CmdType: %d", (int) operation);
+						break;
 				}
+				break;
 			}
-			break;
 		default:
 			ereport(ERROR,
 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),

diff --git a/contrib/postgres_fdw/deparse.c b/contrib/postgres_fdw/deparse.c
index d778e61..157de59 100644
--- a/contrib/postgres_fdw/deparse.c
+++ b/contrib/postgres_fdw/deparse.c
@@ -1069,6 +1069,66 @@ deparseUpdateSql(StringInfo buf, PlannerInfo *root,
 }
 
 /*
+ * deparse remote UPDATE statement
+ *
+ * The statement text is appended to buf, and we also create an integer List
+ * of the columns being retrieved by RETURNING (if any), which is returned
+ * to *retrieved_attrs.
+ */
+void
+deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+						   Index rtindex, Relation rel,
+						   List	*targetlist,
+						   List *targetAttrs,
+						   List	*remote_conds,
+						   List **params_list,
+						   List *returningList,
+						   List **retrieved_attrs)
+{
+	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+	deparse_expr_cxt context;
+	int			nestlevel;
+	bool		first;
+	ListCell   *lc;
+
+	/* Set up context struct for recursion */
+	context.root = root;
+	context.foreignrel = baserel;
+	context.buf = buf;
+	context.params_list = params_list;
+
+	appendStringInfoString(buf, "UPDATE ");
+	deparseRelation(buf, rel);
+	appendStringInfoString(buf, " SET ");
+
+	/* Make sure any constants in the exprs are printed portably */
+	nestlevel = set_transmission_modes();
+
+	first = true;
+	foreach(lc, targetAttrs)
+	{
+		int			attnum = lfirst_int(lc);
+		TargetEntry *tle = get_tle_by_resno(targetlist, attnum);
+
+		if (!first)
+			appendStringInfoString(buf, ", ");
+		first = false;
+
+		deparseColumnRef(buf, rtindex, attnum, root);
+		appendStringInfoString(buf, " = ");
+		deparseExpr((Expr *) tle->expr, &context);
+	}
+
+	reset_transmission_modes(nestlevel);
+
+	if (remote_conds)
+		appendWhereClause(remote_conds, &context);
+
+	deparseReturningList(buf, root, rtindex, rel, false,
+						 returningList, retrieved_attrs);
+}
+
+/*
  * deparse remote DELETE statement
  *
  * The statement text is appended to buf, and we also create an integer List
@@ -1091,6 +1151,40 @@ deparseDeleteSql(StringInfo buf, PlannerInfo *root,
 }
 
 /*
+ * deparse remote DELETE statement
+ *
+ * The statement text is appended to buf, and we also create an integer List
+ * of the columns being retrieved by RETURNING (if any), which is returned
+ * to *retrieved_attrs.
+ */
+void
+deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+						   Index rtindex, Relation rel,
+						   List	*remote_conds,
+						   List	**params_list,
+						   List *returningList,
+						   List **retrieved_attrs)
+{
+	RelOptInfo *baserel = root->simple_rel_array[rtindex];
+	deparse_expr_cxt context;
+
+	/* Set up context struct for recursion */
+	context.root = root;
+	context.foreignrel = baserel;
+	context.buf = buf;
+	context.params_list = params_list;
+
+	appendStringInfoString(buf, "DELETE FROM ");
+	deparseRelation(buf, rel);
+
+	if (remote_conds)
+		appendWhereClause(remote_conds, &context);
+
+	deparseReturningList(buf, root, rtindex, rel, false,
+						 returningList, retrieved_attrs);
+}
+
+/*
  * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
  */
 static void
diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
index f621024..ed9ac3e 100644
--- a/contrib/postgres_fdw/expected/postgres_fdw.out
+++ b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -1314,7 +1314,26 @@ INSERT INTO ft2 (c1,c2,c3)
 (3 rows)
 
 INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+EXPLAIN (verbose, costs off)
+UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
+                                                      QUERY PLAN                                                      
+----------------------------------------------------------------------------------------------------------------------
+ Update on public.ft2
+   ->  Foreign Update on public.ft2
+         Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 300), c3 = (c3 || '_update3'::text) WHERE ((("C 1" % 10) = 3))
+(3 rows)
+
 UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+EXPLAIN (verbose, costs off)
+UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
+                                                                            QUERY PLAN                                                                            
+------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Update on public.ft2
+   Output: c1, c2, c3, c4, c5, c6, c7, c8
+   ->  Foreign Update on public.ft2
+         Remote SQL: UPDATE "S 1"."T 1" SET c2 = (c2 + 400), c3 = (c3 || '_update7'::text) WHERE ((("C 1" % 10) = 7)) RETURNING "C 1", c2, c3, c4, c5, c6, c7, c8
+(4 rows)
+
 UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
   c1  | c2  |         c3         |              c4              |            c5            | c6 |     c7     | c8  
 ------+-----+--------------------+------------------------------+--------------------------+----+------------+-----
@@ -1424,7 +1443,7 @@ UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING
 
 EXPLAIN (verbose, costs off)
 UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
-  FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
+  FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
                                                                             QUERY PLAN                                                                             
 -------------------------------------------------------------------------------------------------------------------------------------------------------------------
  Update on public.ft2
@@ -1445,16 +1464,14 @@ UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
 UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
 EXPLAIN (verbose, costs off)
-  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
-                                       QUERY PLAN                                       
-----------------------------------------------------------------------------------------
+  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
+                                         QUERY PLAN                                         
+--------------------------------------------------------------------------------------------
  Delete on public.ft2
    Output: c1, c4
-   Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1 RETURNING "C 1", c4
-   ->  Foreign Scan on public.ft2
-         Output: ctid
-         Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) FOR UPDATE
-(6 rows)
+   ->  Foreign Delete on public.ft2
+         Remote SQL: DELETE FROM "S 1"."T 1" WHERE ((("C 1" % 10) = 5)) RETURNING "C 1", c4
+(4 rows)
 
 DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
   c1  |              c4              
@@ -1565,7 +1582,7 @@ DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
 (103 rows)
 
 EXPLAIN (verbose, costs off)
-DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
+DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
                                                       QUERY PLAN                                                      
 ----------------------------------------------------------------------------------------------------------------------
  Delete on public.ft2
@@ -2426,16 +2443,14 @@ INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
 (1 row)
 
 EXPLAIN (verbose, costs off)
-UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
-                                                    QUERY PLAN                                                     
--------------------------------------------------------------------------------------------------------------------
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;             -- can be pushed down
+                                     QUERY PLAN                                     
+------------------------------------------------------------------------------------
  Update on public.ft2
    Output: (tableoid)::regclass
-   Remote SQL: UPDATE "S 1"."T 1" SET c3 = $2 WHERE ctid = $1
-   ->  Foreign Scan on public.ft2
-         Output: c1, c2, NULL::integer, 'bar'::text, c4, c5, c6, c7, c8, ctid
-         Remote SQL: SELECT "C 1", c2, c4, c5, c6, c7, c8, ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
-(6 rows)
+   ->  Foreign Update on public.ft2
+         Remote SQL: UPDATE "S 1"."T 1" SET c3 = 'bar'::text WHERE (("C 1" = 9999))
+(4 rows)
 
 UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
  tableoid 
@@ -2444,16 +2459,14 @@ UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
 (1 row)
 
 EXPLAIN (verbose, costs off)
-DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
-                                     QUERY PLAN                                     
-------------------------------------------------------------------------------------
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;                       -- can be pushed down
+                             QUERY PLAN                             
+--------------------------------------------------------------------
  Delete on public.ft2
    Output: (tableoid)::regclass
-   Remote SQL: DELETE FROM "S 1"."T 1" WHERE ctid = $1
-   ->  Foreign Scan on public.ft2
-         Output: ctid
-         Remote SQL: SELECT ctid FROM "S 1"."T 1" WHERE (("C 1" = 9999)) FOR UPDATE
-(6 rows)
+   ->  Foreign Delete on public.ft2
+         Remote SQL: DELETE FROM "S 1"."T 1" WHERE (("C 1" = 9999))
+(4 rows)
 
 DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
  tableoid 
@@ -2607,7 +2620,7 @@ CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
 UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
 ERROR:  new row for relation "T 1" violates check constraint "c2positive"
 DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
-CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
+CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
 -- Test savepoint/rollback behavior
 select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
  c2  | count 
@@ -2766,7 +2779,7 @@ savepoint s3;
 update ft2 set c2 = -2 where c2 = 42 and c1 = 10; -- fail on remote side
 ERROR:  new row for relation "T 1" violates check constraint "c2positive"
 DETAIL:  Failing row contains (10, -2, 00010_trig_update_trig_update, 1970-01-11 08:00:00+00, 1970-01-11 00:00:00, 0, 0         , foo).
-CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
+CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (-2) WHERE ((c2 = 42)) AND (("C 1" = 10))
 rollback to savepoint s3;
 select c2, count(*) from ft2 where c2 < 500 group by 1 order by 1;
  c2  | count 
@@ -2906,7 +2919,7 @@ CONTEXT:  Remote SQL command: INSERT INTO "S 1"."T 1"("C 1", c2, c3, c4, c5, c6,
 UPDATE ft1 SET c2 = -c2 WHERE c1 = 1;  -- c2positive
 ERROR:  new row for relation "T 1" violates check constraint "c2positive"
 DETAIL:  Failing row contains (1, -1, 00001_trig_update, 1970-01-02 08:00:00+00, 1970-01-02 00:00:00, 1, 1         , foo).
-CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = $2 WHERE ctid = $1
+CONTEXT:  Remote SQL command: UPDATE "S 1"."T 1" SET c2 = (- c2) WHERE (("C 1" = 1))
 ALTER FOREIGN TABLE ft1 DROP CONSTRAINT ft1_c2positive;
 -- But inconsistent check constraints provide inconsistent results
 ALTER FOREIGN TABLE ft1 ADD CONSTRAINT ft1_c2negative CHECK (c2 < 0);
@@ -3299,6 +3312,199 @@ NOTICE:  NEW: (13,"test triggered !")
  (0,27)
 (1 row)
 
+-- cleanup
+DROP TRIGGER trig_row_before ON rem1;
+DROP TRIGGER trig_row_after ON rem1;
+DROP TRIGGER trig_local_before ON loc1;
+-- Test DML pushdown functionality
+-- Test with statement-level triggers
+CREATE TRIGGER trig_stmt_before
+	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+                        QUERY PLAN                        
+----------------------------------------------------------
+ Update on public.rem1
+   ->  Foreign Update on public.rem1
+         Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+(3 rows)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+                 QUERY PLAN                  
+---------------------------------------------
+ Delete on public.rem1
+   ->  Foreign Delete on public.rem1
+         Remote SQL: DELETE FROM public.loc1
+(3 rows)
+
+DROP TRIGGER trig_stmt_before ON rem1;
+CREATE TRIGGER trig_stmt_after
+	AFTER DELETE OR INSERT OR UPDATE ON rem1
+	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+                        QUERY PLAN                        
+----------------------------------------------------------
+ Update on public.rem1
+   ->  Foreign Update on public.rem1
+         Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+(3 rows)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+                 QUERY PLAN                  
+---------------------------------------------
+ Delete on public.rem1
+   ->  Foreign Delete on public.rem1
+         Remote SQL: DELETE FROM public.loc1
+(3 rows)
+
+DROP TRIGGER trig_stmt_after ON rem1;
+-- Test with row-level ON INSERT triggers
+CREATE TRIGGER trig_row_before_insert
+BEFORE INSERT ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+                        QUERY PLAN                        
+----------------------------------------------------------
+ Update on public.rem1
+   ->  Foreign Update on public.rem1
+         Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+(3 rows)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+                 QUERY PLAN                  
+---------------------------------------------
+ Delete on public.rem1
+   ->  Foreign Delete on public.rem1
+         Remote SQL: DELETE FROM public.loc1
+(3 rows)
+
+DROP TRIGGER trig_row_before_insert ON rem1;
+CREATE TRIGGER trig_row_after_insert
+AFTER INSERT ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+                        QUERY PLAN                        
+----------------------------------------------------------
+ Update on public.rem1
+   ->  Foreign Update on public.rem1
+         Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+(3 rows)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+                 QUERY PLAN                  
+---------------------------------------------
+ Delete on public.rem1
+   ->  Foreign Delete on public.rem1
+         Remote SQL: DELETE FROM public.loc1
+(3 rows)
+
+DROP TRIGGER trig_row_after_insert ON rem1;
+-- Test with row-level ON UPDATE triggers
+CREATE TRIGGER trig_row_before_update
+BEFORE UPDATE ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can't be pushed down
+                             QUERY PLAN                              
+---------------------------------------------------------------------
+ Update on public.rem1
+   Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1
+   ->  Foreign Scan on public.rem1
+         Output: f1, ''::text, ctid, rem1.*
+         Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+(5 rows)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+                 QUERY PLAN                  
+---------------------------------------------
+ Delete on public.rem1
+   ->  Foreign Delete on public.rem1
+         Remote SQL: DELETE FROM public.loc1
+(3 rows)
+
+DROP TRIGGER trig_row_before_update ON rem1;
+CREATE TRIGGER trig_row_after_update
+AFTER UPDATE ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can't be pushed down
+                                  QUERY PLAN                                   
+-------------------------------------------------------------------------------
+ Update on public.rem1
+   Remote SQL: UPDATE public.loc1 SET f2 = $2 WHERE ctid = $1 RETURNING f1, f2
+   ->  Foreign Scan on public.rem1
+         Output: f1, ''::text, ctid, rem1.*
+         Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+(5 rows)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+                 QUERY PLAN                  
+---------------------------------------------
+ Delete on public.rem1
+   ->  Foreign Delete on public.rem1
+         Remote SQL: DELETE FROM public.loc1
+(3 rows)
+
+DROP TRIGGER trig_row_after_update ON rem1;
+-- Test with row-level ON DELETE triggers
+CREATE TRIGGER trig_row_before_delete
+BEFORE DELETE ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+                        QUERY PLAN                        
+----------------------------------------------------------
+ Update on public.rem1
+   ->  Foreign Update on public.rem1
+         Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+(3 rows)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can't be pushed down
+                             QUERY PLAN                              
+---------------------------------------------------------------------
+ Delete on public.rem1
+   Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1
+   ->  Foreign Scan on public.rem1
+         Output: ctid, rem1.*
+         Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+(5 rows)
+
+DROP TRIGGER trig_row_before_delete ON rem1;
+CREATE TRIGGER trig_row_after_delete
+AFTER DELETE ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+                        QUERY PLAN                        
+----------------------------------------------------------
+ Update on public.rem1
+   ->  Foreign Update on public.rem1
+         Remote SQL: UPDATE public.loc1 SET f2 = ''::text
+(3 rows)
+
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can't be pushed down
+                               QUERY PLAN                               
+------------------------------------------------------------------------
+ Delete on public.rem1
+   Remote SQL: DELETE FROM public.loc1 WHERE ctid = $1 RETURNING f1, f2
+   ->  Foreign Scan on public.rem1
+         Output: ctid, rem1.*
+         Remote SQL: SELECT f1, f2, ctid FROM public.loc1 FOR UPDATE
+(5 rows)
+
+DROP TRIGGER trig_row_after_delete ON rem1;
 -- ===================================================================
 -- test inheritance features
 -- ===================================================================
@@ -3768,6 +3974,56 @@ fetch from c;
 update bar set f2 = null where current of c;
 ERROR:  WHERE CURRENT OF is not supported for this table type
 rollback;
+explain (verbose, costs off)
+delete from foo where f1 < 5 returning *;
+                                   QUERY PLAN                                   
+--------------------------------------------------------------------------------
+ Delete on public.foo
+   Output: foo.f1, foo.f2
+   Delete on public.foo
+   Foreign Delete on public.foo2
+   ->  Index Scan using i_foo_f1 on public.foo
+         Output: foo.ctid
+         Index Cond: (foo.f1 < 5)
+   ->  Foreign Delete on public.foo2
+         Remote SQL: DELETE FROM public.loct1 WHERE ((f1 < 5)) RETURNING f1, f2
+(9 rows)
+
+delete from foo where f1 < 5 returning *;
+ f1 | f2 
+----+----
+  1 |  1
+  3 |  3
+  0 |  0
+  2 |  2
+  4 |  4
+(5 rows)
+
+explain (verbose, costs off)
+update bar set f2 = f2 + 100 returning *;
+                                  QUERY PLAN                                  
+------------------------------------------------------------------------------
+ Update on public.bar
+   Output: bar.f1, bar.f2
+   Update on public.bar
+   Foreign Update on public.bar2
+   ->  Seq Scan on public.bar
+         Output: bar.f1, (bar.f2 + 100), bar.ctid
+   ->  Foreign Update on public.bar2
+         Remote SQL: UPDATE public.loct2 SET f2 = (f2 + 100) RETURNING f1, f2
+(8 rows)
+
+update bar set f2 = f2 + 100 returning *;
+ f1 | f2  
+----+-----
+  1 | 311
+  2 | 322
+  6 | 266
+  3 | 333
+  4 | 344
+  7 | 277
+(6 rows)
+
 drop table foo cascade;
 NOTICE:  drop cascades to foreign table foo2
 drop table bar cascade;
diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
index d5a2af9..a292dbb 100644
--- a/contrib/postgres_fdw/postgres_fdw.c
+++ b/contrib/postgres_fdw/postgres_fdw.c
@@ -61,6 +61,8 @@ enum FdwScanPrivateIndex
 {
 	/* SQL statement to execute remotely (as a String node) */
 	FdwScanPrivateSelectSql,
+	/* List of restriction clauses that can be executed remotely */
+	FdwScanPrivateRemoteConds,
 	/* Integer list of attribute numbers retrieved by the SELECT */
 	FdwScanPrivateRetrievedAttrs,
 	/* Integer representing the desired fetch_size */
@@ -90,6 +92,28 @@ enum FdwModifyPrivateIndex
 };
 
 /*
+ * Similarly, this enum describes what's kept in the fdw_private list for
+ * a ForeignScan node that has pushed down an UPDATE/DELETE to the remote
+ * server.  We store:
+ *
+ * 1) UPDATE/DELETE statement text to be sent to the remote server
+ * 2) Boolean flag showing if the remote query has a RETURNING clause
+ * 3) Integer list of attribute numbers retrieved by RETURNING, if any
+ * 4) Boolean flag showing if we set the command es_processed
+ */
+enum FdwDmlPushdownPrivateIndex
+{
+	/* SQL statement to execute remotely (as a String node) */
+	FdwDmlPushdownPrivateUpdateSql,
+	/* has-returning flag (as an integer Value node) */
+	FdwDmlPushdownPrivateHasReturning,
+	/* Integer list of attribute numbers retrieved by RETURNING */
+	FdwDmlPushdownPrivateRetrievedAttrs,
+	/* set-processed flag (as an integer Value node) */
+	FdwDmlPushdownPrivateSetProcessed
+};
+
+/*
  * Execution state of a foreign scan using postgres_fdw.
  */
 typedef struct PgFdwScanState
@@ -154,6 +178,37 @@ typedef struct PgFdwModifyState
 } PgFdwModifyState;
 
 /*
+ * Execution state of a foreign scan that has pushed down a foreign table
+ * modification to the remote server
+ */
+typedef struct PgFdwDmlPushdownState
+{
+	Relation	rel;			/* relcache entry for the foreign table */
+	AttInMetadata *attinmeta;	/* attribute datatype conversion metadata */
+
+	/* extracted fdw_private data */
+	char	   *query;			/* text of UPDATE/DELETE command */
+	bool		has_returning;	/* is there a RETURNING clause? */
+	List	   *retrieved_attrs;	/* attr numbers retrieved by RETURNING */
+	bool		set_processed;	/* do we set the command es_processed? */
+
+	/* for remote query execution */
+	PGconn	   *conn;			/* connection for the update */
+	int			numParams;		/* number of parameters passed to query */
+	FmgrInfo   *param_flinfo;	/* output conversion functions for them */
+	List	   *param_exprs;	/* executable expressions for param values */
+	const char **param_values;	/* textual values of query parameters */
+
+	/* for storing result tuples */
+	PGresult   *result;			/* result for query */
+	int			num_tuples;		/* # of result tuples */
+	int			next_tuple;		/* index of next one to return */
+
+	/* working memory context */
+	MemoryContext temp_cxt;		/* context for per-tuple temporary data */
+} PgFdwDmlPushdownState;
+
+/*
  * Workspace for analyzing a foreign table.
  */
 typedef struct PgFdwAnalyzeState
@@ -245,6 +300,13 @@ static TupleTableSlot *postgresExecForeignDelete(EState *estate,
 static void postgresEndForeignModify(EState *estate,
 						 ResultRelInfo *resultRelInfo);
 static int	postgresIsForeignRelUpdatable(Relation rel);
+static bool postgresPlanDMLPushdown(PlannerInfo *root,
+									ModifyTable *plan,
+									Index resultRelation,
+									int subplan_index);
+static void postgresBeginDMLPushdown(ForeignScanState *node, int eflags);
+static TupleTableSlot *postgresIterateDMLPushdown(ForeignScanState *node);
+static void postgresEndDMLPushdown(ForeignScanState *node);
 static void postgresExplainForeignScan(ForeignScanState *node,
 						   ExplainState *es);
 static void postgresExplainForeignModify(ModifyTableState *mtstate,
@@ -252,6 +314,8 @@ static void postgresExplainForeignModify(ModifyTableState *mtstate,
 							 List *fdw_private,
 							 int subplan_index,
 							 ExplainState *es);
+static void postgresExplainDMLPushdown(ForeignScanState *node,
+						   ExplainState *es);
 static bool postgresAnalyzeForeignTable(Relation relation,
 							AcquireSampleRowsFunc *func,
 							BlockNumber *totalpages);
@@ -288,6 +352,8 @@ static const char **convert_prep_stmt_params(PgFdwModifyState *fmstate,
 						 TupleTableSlot *slot);
 static void store_returning_result(PgFdwModifyState *fmstate,
 					   TupleTableSlot *slot, PGresult *res);
+static void execute_dml_stmt(ForeignScanState *node);
+static TupleTableSlot *get_returning_data(ForeignScanState *node);
 static int postgresAcquireSampleRowsFunc(Relation relation, int elevel,
 							  HeapTuple *rows, int targrows,
 							  double *totalrows,
@@ -330,10 +396,15 @@ postgres_fdw_handler(PG_FUNCTION_ARGS)
 	routine->ExecForeignDelete = postgresExecForeignDelete;
 	routine->EndForeignModify = postgresEndForeignModify;
 	routine->IsForeignRelUpdatable = postgresIsForeignRelUpdatable;
+	routine->PlanDMLPushdown = postgresPlanDMLPushdown;
+	routine->BeginDMLPushdown = postgresBeginDMLPushdown;
+	routine->IterateDMLPushdown = postgresIterateDMLPushdown;
+	routine->EndDMLPushdown = postgresEndDMLPushdown;
 
 	/* Support functions for EXPLAIN */
 	routine->ExplainForeignScan = postgresExplainForeignScan;
 	routine->ExplainForeignModify = postgresExplainForeignModify;
+	routine->ExplainDMLPushdown = postgresExplainDMLPushdown;
 
 	/* Support functions for ANALYZE */
 	routine->AnalyzeForeignTable = postgresAnalyzeForeignTable;
@@ -1011,7 +1082,8 @@ postgresGetForeignPlan(PlannerInfo *root,
 	 * Build the fdw_private list that will be available to the executor.
 	 * Items in the list must match enum FdwScanPrivateIndex, above.
 	 */
-	fdw_private = list_make3(makeString(sql.data),
+	fdw_private = list_make4(makeString(sql.data),
+							 remote_conds,
 							 retrieved_attrs,
 							 makeInteger(fpinfo->fetch_size));
 
@@ -1308,13 +1380,6 @@ postgresAddForeignUpdateTargets(Query *parsetree,
 /*
  * postgresPlanForeignModify
  *		Plan an insert/update/delete operation on a foreign table
- *
- * Note: currently, the plan tree generated for UPDATE/DELETE will always
- * include a ForeignScan that retrieves ctids (using SELECT FOR UPDATE)
- * and then the ModifyTable node will have to execute individual remote
- * UPDATE/DELETE commands.  If there are no local conditions or joins
- * needed, it'd be better to let the scan node do UPDATE/DELETE RETURNING
- * and then do nothing at ModifyTable.  Room for future optimization ...
  */
 static List *
 postgresPlanForeignModify(PlannerInfo *root,
@@ -1825,6 +1890,337 @@ postgresIsForeignRelUpdatable(Relation rel)
 }
 
 /*
+ * postgresPlanDMLPushdown
+ *		Consider pushing down a foreign table modification to the remote server
+ *
+ * Decide whether the table modification is safe to push down to the remote end,
+ * and if so, modify subplan so as to do that.
+ *
+ * Conditions checked here:
+ *
+ * 1. The table modification must be an UPDATE or DELETE.
+ *
+ * 2. It's unsafe to push down the command if there are any local joins needed.
+ *
+ * 3. It's unsafe to push down the command if there are any quals that can't be
+ *    evaluated remotely.
+ *
+ * 4. We can't push down an UPDATE, if any expressions to assign to the target
+ *    columns are unsafe to evaluate on the remote end.
+ */
+static bool
+postgresPlanDMLPushdown(PlannerInfo *root,
+						ModifyTable *plan,
+						Index resultRelation,
+						int subplan_index)
+{
+	CmdType		operation = plan->operation;
+	Plan	   *subplan = (Plan *) list_nth(plan->plans, subplan_index);
+	RangeTblEntry *rte = planner_rt_fetch(resultRelation, root);
+	Relation	rel;
+	StringInfoData sql;
+	ForeignScan *fscan;
+	List	   *targetAttrs = NIL;
+	List	   *remote_conds;
+	List	   *params_list = NIL;
+	List	   *returningList = NIL;
+	List	   *retrieved_attrs = NIL;
+
+	/*
+	 * Decide whether the table modification is safe to push down to the remote
+	 * server.
+	 */
+
+	/* Check point 1 */
+	if (operation == CMD_INSERT)
+		return false;
+
+	/* Check point 2 */
+	if (nodeTag(subplan) != T_ForeignScan)
+		return false;
+
+	/* Check point 3 */
+	if (subplan->qual != NIL)
+		return false;
+
+	/* Check point 4 */
+	if (operation == CMD_UPDATE)
+	{
+		RelOptInfo *baserel = root->simple_rel_array[resultRelation];
+		int			col;
+
+		/*
+		 * We transmit only columns that were explicitly targets of the UPDATE,
+		 * so as to avoid unnecessary data transmission.
+		 */
+		col = -1;
+		while ((col = bms_next_member(rte->updatedCols, col)) >= 0)
+		{
+			/* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
+			AttrNumber	attno = col + FirstLowInvalidHeapAttributeNumber;
+			TargetEntry *tle;
+
+			if (attno <= InvalidAttrNumber)		/* shouldn't happen */
+				elog(ERROR, "system-column update is not supported");
+
+			tle = get_tle_by_resno(subplan->targetlist, attno);
+
+			if (!is_foreign_expr(root, baserel, (Expr *) tle->expr))
+				return false;
+
+			targetAttrs = lappend_int(targetAttrs, attno);
+		}
+	}
+
+	/*
+	 * Ok, modify subplan so as to push down the command to the remote server.
+	 */
+	fscan = (ForeignScan *) subplan;
+
+	initStringInfo(&sql);
+
+	/*
+	 * Core code already has some lock on each rel being planned, so we can
+	 * use NoLock here.
+	 */
+	rel = heap_open(rte->relid, NoLock);
+
+	/*
+	 * Extract the baserestrictinfo clauses that can be evaluated remotely.
+	 */
+	remote_conds = (List *) list_nth(fscan->fdw_private,
+									 FdwScanPrivateRemoteConds);
+
+	/*
+	 * Extract the relevant RETURNING list if any.
+	 */
+	if (plan->returningLists)
+		returningList = (List *) list_nth(plan->returningLists, subplan_index);
+
+	/*
+	 * Construct the SQL command string.
+	 */
+	switch (operation)
+	{
+		case CMD_UPDATE:
+			deparsePushedDownUpdateSql(&sql, root, resultRelation, rel,
+									   ((Plan *) fscan)->targetlist,
+									   targetAttrs,
+									   remote_conds, &params_list,
+									   returningList, &retrieved_attrs);
+			break;
+		case CMD_DELETE:
+			deparsePushedDownDeleteSql(&sql, root, resultRelation, rel,
+									   remote_conds, &params_list,
+									   returningList, &retrieved_attrs);
+			break;
+		default:
+			elog(ERROR, "unexpected operation: %d", (int) operation);
+			break;
+	}
+
+	/*
+	 * Update the operation info.
+	 */
+	fscan->operation = operation;
+
+	/*
+	 * Update the fdw_exprs list that will be available to the executor.
+	 */
+	fscan->fdw_exprs = params_list;
+
+	/*
+	 * Update the fdw_private list that will be available to the executor.
+	 * Items in the list must match enum FdwDmlPushdownPrivateIndex, above.
+	 */
+	fscan->fdw_private = list_make4(makeString(sql.data),
+									makeInteger((retrieved_attrs != NIL)),
+									retrieved_attrs,
+									makeInteger(plan->canSetTag));
+
+	heap_close(rel, NoLock);
+	return true;
+}
+
+/*
+ * postgresBeginDMLPushdown
+ *		Initiate pushing down a foreign table modification to the remote server
+ */
+static void
+postgresBeginDMLPushdown(ForeignScanState *node, int eflags)
+{
+	ForeignScan *fsplan = (ForeignScan *) node->ss.ps.plan;
+	EState	   *estate = node->ss.ps.state;
+	PgFdwDmlPushdownState *dpstate;
+	RangeTblEntry *rte;
+	Oid			userid;
+	ForeignTable *table;
+	UserMapping *user;
+	int			numParams;
+	int			i;
+	ListCell   *lc;
+
+	/*
+	 * Do nothing in EXPLAIN (no ANALYZE) case.  node->fdw_state stays NULL.
+	 */
+	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)
+		return;
+
+	/*
+	 * We'll save private state in node->fdw_state.
+	 */
+	dpstate = (PgFdwDmlPushdownState *) palloc0(sizeof(PgFdwDmlPushdownState));
+	node->fdw_state = (void *) dpstate;
+
+	/*
+	 * Identify which user to do the remote access as.  This should match what
+	 * ExecCheckRTEPerms() does.
+	 */
+	rte = rt_fetch(fsplan->scan.scanrelid, estate->es_range_table);
+	userid = rte->checkAsUser ? rte->checkAsUser : GetUserId();
+
+	/* Get info about foreign table. */
+	dpstate->rel = node->ss.ss_currentRelation;
+	table = GetForeignTable(RelationGetRelid(dpstate->rel));
+	user = GetUserMapping(userid, table->serverid);
+
+	/*
+	 * Get connection to the foreign server.  Connection manager will
+	 * establish new connection if necessary.
+	 */
+	dpstate->conn = GetConnection(user, false);
+
+	/* Initialize state variable */
+	dpstate->num_tuples = -1;		/* -1 means not set yet */
+
+	/* Get private info created by planner functions. */
+	dpstate->query = strVal(list_nth(fsplan->fdw_private,
+									 FdwDmlPushdownPrivateUpdateSql));
+	dpstate->has_returning = intVal(list_nth(fsplan->fdw_private,
+										 FdwDmlPushdownPrivateHasReturning));
+	dpstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
+										FdwDmlPushdownPrivateRetrievedAttrs);
+	dpstate->set_processed = intVal(list_nth(fsplan->fdw_private,
+										 FdwDmlPushdownPrivateSetProcessed));
+
+	/* Create context for per-tuple temp workspace. */
+	dpstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
+											  "postgres_fdw temporary data",
+											  ALLOCSET_SMALL_MINSIZE,
+											  ALLOCSET_SMALL_INITSIZE,
+											  ALLOCSET_SMALL_MAXSIZE);
+
+	/* Prepare for input conversion of RETURNING results. */
+	if (dpstate->has_returning)
+		dpstate->attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(dpstate->rel));
+
+	/* Prepare for output conversion of parameters used in remote query. */
+	numParams = list_length(fsplan->fdw_exprs);
+	dpstate->numParams = numParams;
+	dpstate->param_flinfo = (FmgrInfo *) palloc0(sizeof(FmgrInfo) * numParams);
+
+	i = 0;
+	foreach(lc, fsplan->fdw_exprs)
+	{
+		Node	   *param_expr = (Node *) lfirst(lc);
+		Oid			typefnoid;
+		bool		isvarlena;
+
+		getTypeOutputInfo(exprType(param_expr), &typefnoid, &isvarlena);
+		fmgr_info(typefnoid, &dpstate->param_flinfo[i]);
+		i++;
+	}
+
+	/*
+	 * Prepare remote-parameter expressions for evaluation.  (Note: in
+	 * practice, we expect that all these expressions will be just Params, so
+	 * we could possibly do something more efficient than using the full
+	 * expression-eval machinery for this.  But probably there would be little
+	 * benefit, and it'd require postgres_fdw to know more than is desirable
+	 * about Param evaluation.)
+	 */
+	dpstate->param_exprs = (List *)
+		ExecInitExpr((Expr *) fsplan->fdw_exprs,
+					 (PlanState *) node);
+
+	/*
+	 * Allocate buffer for text form of query parameters, if any.
+	 */
+	if (numParams > 0)
+		dpstate->param_values = (const char **) palloc0(numParams * sizeof(char *));
+	else
+		dpstate->param_values = NULL;
+}
+
+/*
+ * postgresIterateDMLPushdown
+ *		Execute pushing down a foreign table modification to the remote server
+ */
+static TupleTableSlot *
+postgresIterateDMLPushdown(ForeignScanState *node)
+{
+	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+	EState	   *estate = node->ss.ps.state;
+	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+
+	/*
+	 * If this is the first call after Begin, execute the statement.
+	 */
+	if (dpstate->num_tuples == -1)
+		execute_dml_stmt(node);
+
+	/*
+	 * If the local query doesn't specify RETURNING, just clear tuple slot.
+	 */
+	if (!resultRelInfo->ri_projectReturning)
+	{
+		TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+		Instrumentation *instr = node->ss.ps.instrument;
+
+		Assert(!dpstate->has_returning);
+
+		/* Increment the command es_processed count if necessary. */
+		if (dpstate->set_processed)
+			estate->es_processed += dpstate->num_tuples;
+
+		/* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
+		if (instr)
+			instr->tuplecount += dpstate->num_tuples;
+
+		return ExecClearTuple(slot);
+	}
+
+	/*
+	 * Get the next RETURNING tuple.
+	 */
+	return get_returning_data(node);
+}
+
+/*
+ * postgresEndDMLPushdown
+ *		Finish pushing down a foreign table modification to the remote server
+ */
+static void
+postgresEndDMLPushdown(ForeignScanState *node)
+{
+	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+
+	/* if dpstate is NULL, we are in EXPLAIN; nothing to do */
+	if (dpstate == NULL)
+		return;
+
+	/* Release PGresult */
+	if (dpstate->result)
+		PQclear(dpstate->result);
+
+	/* Release remote connection */
+	ReleaseConnection(dpstate->conn);
+	dpstate->conn = NULL;
+
+	/* MemoryContext will be deleted automatically. */
+}
+
+/*
  * postgresExplainForeignScan
  *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
  */
@@ -1862,6 +2258,25 @@ postgresExplainForeignModify(ModifyTableState *mtstate,
 	}
 }
 
+/*
+ * postgresExplainDMLPushdown
+ *		Produce extra output for EXPLAIN of a ForeignScan on a foreign table
+ *		that has pushed down an UPDATE/DELETE to the remote server
+ */
+static void
+postgresExplainDMLPushdown(ForeignScanState *node, ExplainState *es)
+{
+	List	   *fdw_private;
+	char	   *sql;
+
+	if (es->verbose)
+	{
+		fdw_private = ((ForeignScan *) node->ss.ps.plan)->fdw_private;
+		sql = strVal(list_nth(fdw_private, FdwDmlPushdownPrivateUpdateSql));
+		ExplainPropertyText("Remote SQL", sql, es);
+	}
+}
+
 
 /*
  * estimate_path_cost_size
@@ -2474,6 +2889,139 @@ store_returning_result(PgFdwModifyState *fmstate,
 }
 
 /*
+ * Execute a pushed-down UPDATE/DELETE statement.
+ */
+static void
+execute_dml_stmt(ForeignScanState *node)
+{
+	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+	ExprContext *econtext = node->ss.ps.ps_ExprContext;
+	int			numParams = dpstate->numParams;
+	const char **values = dpstate->param_values;
+
+	/*
+	 * Construct array of query parameter values in text format.
+	 */
+	if (numParams > 0)
+	{
+		int			nestlevel;
+		int			i;
+		ListCell   *lc;
+
+		nestlevel = set_transmission_modes();
+
+		i = 0;
+		foreach(lc, dpstate->param_exprs)
+		{
+			ExprState  *expr_state = (ExprState *) lfirst(lc);
+			Datum		expr_value;
+			bool		isNull;
+
+			/* Evaluate the parameter expression */
+			expr_value = ExecEvalExpr(expr_state, econtext, &isNull, NULL);
+
+			/*
+			 * Get string representation of each parameter value by invoking
+			 * type-specific output function, unless the value is null.
+			 */
+			if (isNull)
+				values[i] = NULL;
+			else
+				values[i] = OutputFunctionCall(&dpstate->param_flinfo[i],
+											   expr_value);
+			i++;
+		}
+
+		reset_transmission_modes(nestlevel);
+	}
+
+	/*
+	 * Notice that we pass NULL for paramTypes, thus forcing the remote server
+	 * to infer types for all parameters.  Since we explicitly cast every
+	 * parameter (see deparse.c), the "inference" is trivial and will produce
+	 * the desired result.  This allows us to avoid assuming that the remote
+	 * server has the same OIDs we do for the parameters' types.
+	 *
+	 * We don't use a PG_TRY block here, so be careful not to throw error
+	 * without releasing the PGresult.
+	 */
+	dpstate->result = PQexecParams(dpstate->conn, dpstate->query,
+								   numParams, NULL, values, NULL, NULL, 0);
+	if (PQresultStatus(dpstate->result) !=
+		(dpstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
+		pgfdw_report_error(ERROR, dpstate->result, dpstate->conn, true,
+						   dpstate->query);
+
+	/* Get the number of rows affected. */
+	if (dpstate->has_returning)
+		dpstate->num_tuples = PQntuples(dpstate->result);
+	else
+		dpstate->num_tuples = atoi(PQcmdTuples(dpstate->result));
+}
+
+/*
+ * Get the result of a RETURNING clause.
+ */
+static TupleTableSlot *
+get_returning_data(ForeignScanState *node)
+{
+	PgFdwDmlPushdownState *dpstate = (PgFdwDmlPushdownState *) node->fdw_state;
+	EState	   *estate = node->ss.ps.state;
+	ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
+	TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
+
+	Assert(resultRelInfo->ri_projectReturning);
+
+	/* If we didn't get any tuples, must be end of data. */
+	if (dpstate->next_tuple >= dpstate->num_tuples)
+		return ExecClearTuple(slot);
+
+	/* Increment the command es_processed count if necessary. */
+	if (dpstate->set_processed)
+		estate->es_processed += 1;
+
+	/*
+	 * Store a RETURNING tuple.  If has_returning is false, just emit a dummy
+	 * tuple.  (We have has_returning=false if the local query is of the form
+	 * UPDATE/DELETE .. RETURNING 1 for example.)
+	 */
+	if (!dpstate->has_returning)
+		ExecStoreAllNullTuple(slot);
+	else
+	{
+		/*
+		 * On error, be sure to release the PGresult on the way out.  Callers
+		 * do not have PG_TRY blocks to ensure this happens.
+		 */
+		PG_TRY();
+		{
+			HeapTuple	newtup;
+
+			newtup = make_tuple_from_result_row(dpstate->result,
+												dpstate->next_tuple,
+												dpstate->rel,
+												dpstate->attinmeta,
+												dpstate->retrieved_attrs,
+												dpstate->temp_cxt);
+			ExecStoreTuple(newtup, slot, InvalidBuffer, false);
+		}
+		PG_CATCH();
+		{
+			if (dpstate->result)
+				PQclear(dpstate->result);
+			PG_RE_THROW();
+		}
+		PG_END_TRY();
+	}
+	dpstate->next_tuple++;
+
+	/* Make slot available for evaluation of the local query RETURNING list. */
+	resultRelInfo->ri_projectReturning->pi_exprContext->ecxt_scantuple = slot;
+
+	return slot;
+}
+
+/*
  * postgresAnalyzeForeignTable
  *		Test whether analyzing this foreign table is supported
  */
diff --git a/contrib/postgres_fdw/postgres_fdw.h b/contrib/postgres_fdw/postgres_fdw.h
index 2b63281..c0f5766 100644
--- a/contrib/postgres_fdw/postgres_fdw.h
+++ b/contrib/postgres_fdw/postgres_fdw.h
@@ -93,10 +93,24 @@ extern void deparseUpdateSql(StringInfo buf, PlannerInfo *root,
 				 Index rtindex, Relation rel,
 				 List *targetAttrs, List *returningList,
 				 List **retrieved_attrs);
+extern void deparsePushedDownUpdateSql(StringInfo buf, PlannerInfo *root,
+									   Index rtindex, Relation rel,
+									   List	*targetlist,
+									   List *targetAttrs,
+									   List	*remote_conds,
+									   List **params_list,
+									   List *returningList,
+									   List **retrieved_attrs);
 extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
 				 Index rtindex, Relation rel,
 				 List *returningList,
 				 List **retrieved_attrs);
+extern void deparsePushedDownDeleteSql(StringInfo buf, PlannerInfo *root,
+									   Index rtindex, Relation rel,
+									   List	*remote_conds,
+									   List **params_list,
+									   List *returningList,
+									   List **retrieved_attrs);
 extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
 extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
 				  List **retrieved_attrs);
diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql
index 1978e16..d0493e1 100644
--- a/contrib/postgres_fdw/sql/postgres_fdw.sql
+++ b/contrib/postgres_fdw/sql/postgres_fdw.sql
@@ -399,28 +399,32 @@ INSERT INTO ft2 (c1,c2,c3) SELECT c1+1000,c2+100, c3 || c3 FROM ft2 LIMIT 20;
 INSERT INTO ft2 (c1,c2,c3)
   VALUES (1101,201,'aaa'), (1102,202,'bbb'), (1103,203,'ccc') RETURNING *;
 INSERT INTO ft2 (c1,c2,c3) VALUES (1104,204,'ddd'), (1105,205,'eee');
+EXPLAIN (verbose, costs off)
+UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;              -- can be pushed down
 UPDATE ft2 SET c2 = c2 + 300, c3 = c3 || '_update3' WHERE c1 % 10 = 3;
+EXPLAIN (verbose, costs off)
+UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;  -- can be pushed down
 UPDATE ft2 SET c2 = c2 + 400, c3 = c3 || '_update7' WHERE c1 % 10 = 7 RETURNING *;
 EXPLAIN (verbose, costs off)
 UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
-  FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
+  FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;                               -- can't be pushed down
 UPDATE ft2 SET c2 = ft2.c2 + 500, c3 = ft2.c3 || '_update9', c7 = DEFAULT
   FROM ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 9;
 EXPLAIN (verbose, costs off)
-  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
+  DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;                               -- can be pushed down
 DELETE FROM ft2 WHERE c1 % 10 = 5 RETURNING c1, c4;
 EXPLAIN (verbose, costs off)
-DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
+DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;                -- can't be pushed down
 DELETE FROM ft2 USING ft1 WHERE ft1.c1 = ft2.c2 AND ft1.c1 % 10 = 2;
 SELECT c1,c2,c3,c4 FROM ft2 ORDER BY c1;
 EXPLAIN (verbose, costs off)
 INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
 INSERT INTO ft2 (c1,c2,c3) VALUES (9999,999,'foo') RETURNING tableoid::regclass;
 EXPLAIN (verbose, costs off)
-UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
+UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;             -- can be pushed down
 UPDATE ft2 SET c3 = 'bar' WHERE c1 = 9999 RETURNING tableoid::regclass;
 EXPLAIN (verbose, costs off)
-DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
+DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;                       -- can be pushed down
 DELETE FROM ft2 WHERE c1 = 9999 RETURNING tableoid::regclass;
 
 -- Test that trigger on remote table works as expected
@@ -737,6 +741,90 @@ UPDATE rem1 SET f2 = 'testo';
 -- Test returning a system attribute
 INSERT INTO rem1(f2) VALUES ('test') RETURNING ctid;
 
+-- cleanup
+DROP TRIGGER trig_row_before ON rem1;
+DROP TRIGGER trig_row_after ON rem1;
+DROP TRIGGER trig_local_before ON loc1;
+
+
+-- Test DML pushdown functionality
+
+-- Test with statement-level triggers
+CREATE TRIGGER trig_stmt_before
+	BEFORE DELETE OR INSERT OR UPDATE ON rem1
+	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+DROP TRIGGER trig_stmt_before ON rem1;
+
+CREATE TRIGGER trig_stmt_after
+	AFTER DELETE OR INSERT OR UPDATE ON rem1
+	FOR EACH STATEMENT EXECUTE PROCEDURE trigger_func();
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+DROP TRIGGER trig_stmt_after ON rem1;
+
+-- Test with row-level ON INSERT triggers
+CREATE TRIGGER trig_row_before_insert
+BEFORE INSERT ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+DROP TRIGGER trig_row_before_insert ON rem1;
+
+CREATE TRIGGER trig_row_after_insert
+AFTER INSERT ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+DROP TRIGGER trig_row_after_insert ON rem1;
+
+-- Test with row-level ON UPDATE triggers
+CREATE TRIGGER trig_row_before_update
+BEFORE UPDATE ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can't be pushed down
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+DROP TRIGGER trig_row_before_update ON rem1;
+
+CREATE TRIGGER trig_row_after_update
+AFTER UPDATE ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can't be pushed down
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can be pushed down
+DROP TRIGGER trig_row_after_update ON rem1;
+
+-- Test with row-level ON DELETE triggers
+CREATE TRIGGER trig_row_before_delete
+BEFORE DELETE ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can't be pushed down
+DROP TRIGGER trig_row_before_delete ON rem1;
+
+CREATE TRIGGER trig_row_after_delete
+AFTER DELETE ON rem1
+FOR EACH ROW EXECUTE PROCEDURE trigger_data(23,'skidoo');
+EXPLAIN (verbose, costs off)
+UPDATE rem1 set f2 = '';          -- can be pushed down
+EXPLAIN (verbose, costs off)
+DELETE FROM rem1;                 -- can't be pushed down
+DROP TRIGGER trig_row_after_delete ON rem1;
+
 -- ===================================================================
 -- test inheritance features
 -- ===================================================================
@@ -868,6 +956,13 @@ fetch from c;
 update bar set f2 = null where current of c;
 rollback;
 
+explain (verbose, costs off)
+delete from foo where f1 < 5 returning *;
+delete from foo where f1 < 5 returning *;
+explain (verbose, costs off)
+update bar set f2 = f2 + 100 returning *;
+update bar set f2 = f2 + 100 returning *;
+
 drop table foo cascade;
 drop table bar cascade;
 drop table loct1;
diff --git a/doc/src/sgml/fdwhandler.sgml b/doc/src/sgml/fdwhandler.sgml
index a6945d3..88a3c16 100644
--- a/doc/src/sgml/fdwhandler.sgml
+++ b/doc/src/sgml/fdwhandler.sgml
@@ -672,13 +672,162 @@ IsForeignRelUpdatable (Relation rel);
      <literal>NULL</>, foreign tables are assumed to be insertable, updatable,
      or deletable if the FDW provides <function>ExecForeignInsert</>,
      <function>ExecForeignUpdate</>, or <function>ExecForeignDelete</>
-     respectively.  This function is only needed if the FDW supports some
+     respectively.
+     (If the FDW optimizes a foreign table update on a foreign table using
+     <function>PlanDMLPushdown</>, it still needs to provide
+     <function>BeginDMLPushdown</>, <function>IterateDMLPushdown</> and
+     <function>EndDMLPushdown</> to execute the optimized update.)
+     This function is only needed if the FDW supports some
      tables that are updatable and some that are not.  (Even then, it's
      permissible to throw an error in the execution routine instead of
      checking in this function.  However, this function is used to determine
      updatability for display in the <literal>information_schema</> views.)
     </para>
 
+    <para>
+     If an FDW supports an optimization that executes a foreign table update
+     directly on the remote server, it should provide the following callback
+     functions in addition to the table-updating functions described above:
+    </para>
+
+    <para>
+<programlisting>
+bool
+PlanDMLPushdown (PlannerInfo *root,
+                 ModifyTable *plan,
+                 Index resultRelation,
+                 int subplan_index);
+</programlisting>
+
+     Decide whether it is safe to execute a foreign table update directly
+     on the remote server.  If so, return <literal>true</> after performing
+     planning actions needed for that.  Otherwise, return <literal>false</>.
+     This optional function is called during query planning.
+     If this function succeeds, <function>BeginDMLPushdown</>,
+     <function>IterateDMLPushdown</> and <function>EndDMLPushdown</> will be
+     called at the execution stage, instead.  Otherwise, the table update
+     will be executed using the table-updating functions described above.
+     The parameters are the same as for <function>PlanForeignModify</>.
+    </para>
+
+    <para>
+     To execute the table update directly on the remote server, this function
+     must rewrite the target subplan with a <structname>ForeignScan</> plan
+     node that executes the table update directly on the remote server.  The
+     <structfield>operation</> field of the <structname>ForeignScan</> must
+     be set to the <literal>CmdType</> enumeration appropriately; that is,
+     <literal>CMD_UPDATE</> for <command>UPDATE</>,
+     <literal>CMD_INSERT</> for <command>INSERT</>, and
+     <literal>CMD_DELETE</> for <command>DELETE</>.
+    </para>
+
+    <para>
+     See <xref linkend="fdw-planning"> for additional information.
+    </para>
+
+    <para>
+     If the <function>PlanDMLPushdown</> pointer is set to
+     <literal>NULL</>, no attempts to execute the table update directly on
+     the remote server are taken.
+    </para>
+
+    <para>
+<programlisting>
+void
+BeginDMLPushdown (ForeignScanState *node,
+                  int eflags);
+</programlisting>
+
+     Begin executing a foreign table update directly on the remote server.
+     This is called during executor startup.  It should perform any
+     initialization needed prior to the actual table update (that should be
+     done upon the first call to <function>IterateDMLPushdown</>).
+     The <structname>ForeignScanState</> node has already been created, but
+     its <structfield>fdw_state</> field is still NULL.  Information about
+     the table to update is accessible through the
+     <structname>ForeignScanState</> node (in particular, from the underlying
+     <structname>ForeignScan</> plan node, which contains any FDW-private
+     information provided by <function>PlanDMLPushdown</>).
+     <literal>eflags</> contains flag bits describing the executor's
+     operating mode for this plan node.
+    </para>
+
+    <para>
+     Note that when <literal>(eflags &amp; EXEC_FLAG_EXPLAIN_ONLY)</> is
+     true, this function should not perform any externally-visible actions;
+     it should only do the minimum required to make the node state valid
+     for <function>ExplainDMLPushdown</> and <function>EndDMLPushdown</>.
+    </para>
+
+    <para>
+     If the <function>BeginDMLPushdown</> pointer is set to
+     <literal>NULL</>, attempts to execute the table update directly on
+     the remote server will fail with an error message.
+    </para>
+
+    <para>
+<programlisting>
+TupleTableSlot *
+IterateDMLPushdown (ForeignScanState *node);
+</programlisting>
+
+     When the <command>INSERT</>, <command>UPDATE</> or <command>DELETE</>
+     query doesn't have a <literal>RETURNING</> clause, just return NULL
+     after the actual table update directly executed on the remote server.
+     When the query has the clause, fetch one result containing the data
+     needed for the <literal>RETURNING</> calculation, returning it in a
+     tuple table slot (the node's <structfield>ScanTupleSlot</> should be
+     used for this purpose).  The data that was actually inserted, updated
+     or deleted must be stored in the
+     <literal>es_result_relation_info-&gt;ri_projectReturning-&gt;pi_exprContext-&gt;ecxt_scantuple</>
+     of the node's <structname>EState</>.
+     Return NULL if no more rows are available.
+     Note that this is called in a short-lived memory context that will be
+     reset between invocations.  Create a memory context in
+     <function>BeginDMLPushdown</> if you need longer-lived storage, or use
+     the <structfield>es_query_cxt</> of the node's <structname>EState</>.
+    </para>
+
+    <para>
+     The rows returned must match the <structfield>fdw_scan_tlist</> target
+     list if one was supplied, otherwise they must match the row type of the
+     foreign table being updated.  If you choose to optimize away fetching
+     columns that are not needed for the <literal>RETURNING</> calculation,
+     you should insert nulls in those column positions, or else generate a
+     <structfield>fdw_scan_tlist</> list with those columns omitted.
+    </para>
+
+    <para>
+     Whether the query has the clause or not, the query's reported row count 
+     must be incremented by the FDW itself.  When the query doesn't has the
+     clause, the FDW must also increment the row count for the
+     <structname>ForeignScanState</> node in the <command>EXPLAIN ANALYZE</>
+     case.
+    </para>
+
+    <para>
+     If the <function>IterateDMLPushdown</> pointer is set to
+     <literal>NULL</>, attempts to execute the table update directly on
+     the remote server will fail with an error message.
+    </para>
+
+    <para>
+<programlisting>
+void
+EndDMLPushdown (ForeignScanState *node);
+</programlisting>
+
+     End the table update and release resources.  It is normally not important
+     to release palloc'd memory, but for example open files and connections
+     to remote servers should be cleaned up.
+    </para>
+
+    <para>
+     If the <function>EndDMLPushdown</> pointer is set to
+     <literal>NULL</>, attempts to execute the table update directly on
+     the remote server will fail with an error message.
+    </para>
+
    </sect2>
 
    <sect2 id="fdw-callbacks-row-locking">
@@ -866,6 +1015,29 @@ ExplainForeignModify (ModifyTableState *mtstate,
      <command>EXPLAIN</>.
     </para>
 
+    <para>
+<programlisting>
+void
+ExplainDMLPushdown (ForeignScanState *node,
+                    ExplainState *es);
+</programlisting>
+
+     Print additional <command>EXPLAIN</> output for a foreign table update
+     that is executed directly on the remote server.
+     This function can call <function>ExplainPropertyText</> and
+     related functions to add fields to the <command>EXPLAIN</> output.
+     The flag fields in <literal>es</> can be used to determine what to
+     print, and the state of the <structname>ForeignScanState</> node
+     can be inspected to provide run-time statistics in the <command>EXPLAIN
+     ANALYZE</> case.
+    </para>
+
+    <para>
+     If the <function>ExplainDMLPushdown</> pointer is set to
+     <literal>NULL</>, no additional information is printed during
+     <command>EXPLAIN</>.
+    </para>
+
    </sect2>
 
    <sect2 id="fdw-callbacks-analyze">
@@ -1147,7 +1319,8 @@ GetForeignServerByName(const char *name, bool missing_ok);
     <para>
      The FDW callback functions <function>GetForeignRelSize</>,
      <function>GetForeignPaths</>, <function>GetForeignPlan</>,
-     <function>PlanForeignModify</>, and <function>GetForeignJoinPaths</>
+     <function>PlanForeignModify</>, <function>GetForeignJoinPaths</>, and
+     <function>PlanDMLPushdown</>
      must fit into the workings of the <productname>PostgreSQL</> planner.
      Here are some notes about what they must do.
     </para>
@@ -1307,7 +1480,8 @@ GetForeignServerByName(const char *name, bool missing_ok);
 
     <para>
      When planning an <command>UPDATE</> or <command>DELETE</>,
-     <function>PlanForeignModify</> can look up the <structname>RelOptInfo</>
+     <function>PlanForeignModify</> and <function>PlanDMLPushdown</>
+     can look up the <structname>RelOptInfo</>
      struct for the foreign table and make use of the
      <literal>baserel-&gt;fdw_private</> data previously created by the
      scan-planning functions.  However, in <command>INSERT</> the target
diff --git a/doc/src/sgml/postgres-fdw.sgml b/doc/src/sgml/postgres-fdw.sgml
index a90983c..ff86137 100644
--- a/doc/src/sgml/postgres-fdw.sgml
+++ b/doc/src/sgml/postgres-fdw.sgml
@@ -484,6 +484,15 @@
    extension that's listed in the foreign server's <literal>extensions</>
    option.  Operators and functions in such clauses must
    be <literal>IMMUTABLE</> as well.
+   For an <command>UPDATE</> or <command>DELETE</> query,
+   <filename>postgres_fdw</> attempts to optimize the query execution by
+   sending the whole query to the remote server if there are no query
+   <literal>WHERE</> clauses that cannot be sent to the remote server,
+   no local joins for the query, and no row-level local <literal>BEFORE</> or
+   <literal>AFTER</> triggers on the target table.  In <command>UPDATE</>,
+   expressions to assign to target columns must use only built-in data types,
+   <literal>IMMUTABLE</> operators, or <literal>IMMUTABLE</> functions,
+   to reduce the risk of misexecution of the query.
   </para>
 
   <para>
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 25d8ca0..05d4a35 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -888,7 +888,29 @@ ExplainNode(PlanState *planstate, List *ancestors,
 			pname = sname = "WorkTable Scan";
 			break;
 		case T_ForeignScan:
-			pname = sname = "Foreign Scan";
+			sname = "Foreign Scan";
+			switch (((ForeignScan *) plan)->operation)
+			{
+				case CMD_SELECT:
+					pname = "Foreign Scan";
+					operation = "Select";
+					break;
+				case CMD_INSERT:
+					pname = "Foreign Insert";
+					operation = "Insert";
+					break;
+				case CMD_UPDATE:
+					pname = "Foreign Update";
+					operation = "Update";
+					break;
+				case CMD_DELETE:
+					pname = "Foreign Delete";
+					operation = "Delete";
+					break;
+				default:
+					pname = "???";
+					break;
+			}
 			break;
 		case T_CustomScan:
 			sname = "Custom Scan";
@@ -1636,6 +1658,12 @@ show_plan_tlist(PlanState *planstate, List *ancestors, ExplainState *es)
 		return;
 	if (IsA(plan, RecursiveUnion))
 		return;
+	/* Likewise for ForeignScan that has pushed down INSERT/UPDATE/DELETE */
+	if (IsA(plan, ForeignScan) &&
+		(((ForeignScan *) plan)->operation == CMD_INSERT ||
+		 ((ForeignScan *) plan)->operation == CMD_UPDATE ||
+		 ((ForeignScan *) plan)->operation == CMD_DELETE))
+		return;
 
 	/* Set up deparsing context */
 	context = set_deparse_context_planstate(es->deparse_cxt,
@@ -2224,8 +2252,16 @@ show_foreignscan_info(ForeignScanState *fsstate, ExplainState *es)
 	FdwRoutine *fdwroutine = fsstate->fdwroutine;
 
 	/* Let the FDW emit whatever fields it wants */
-	if (fdwroutine->ExplainForeignScan != NULL)
-		fdwroutine->ExplainForeignScan(fsstate, es);
+	if (((ForeignScan *) fsstate->ss.ps.plan)->operation != CMD_SELECT)
+	{
+		if (fdwroutine->ExplainDMLPushdown != NULL)
+			fdwroutine->ExplainDMLPushdown(fsstate, es);
+	}
+	else
+	{
+		if (fdwroutine->ExplainForeignScan != NULL)
+			fdwroutine->ExplainForeignScan(fsstate, es);
+	}
 }
 
 /*
@@ -2611,8 +2647,10 @@ show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
 			}
 		}
 
-		/* Give FDW a chance */
-		if (fdwroutine && fdwroutine->ExplainForeignModify != NULL)
+		/* Give FDW a chance if needed */
+		if (!resultRelInfo->ri_FdwPushdown &&
+			fdwroutine != NULL &&
+			fdwroutine->ExplainForeignModify != NULL)
 		{
 			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, j);
 
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 76f7297..68a3a13 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -1011,8 +1011,9 @@ InitPlan(QueryDesc *queryDesc, int eflags)
  * CheckValidRowMarkRel.
  */
 void
-CheckValidResultRel(Relation resultRel, CmdType operation)
+CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation)
 {
+	Relation	resultRel = resultRelInfo->ri_RelationDesc;
 	TriggerDesc *trigDesc = resultRel->trigdesc;
 	FdwRoutine *fdwroutine;
 
@@ -1086,7 +1087,8 @@ CheckValidResultRel(Relation resultRel, CmdType operation)
 			switch (operation)
 			{
 				case CMD_INSERT:
-					if (fdwroutine->ExecForeignInsert == NULL)
+					if (fdwroutine->ExecForeignInsert == NULL &&
+						!resultRelInfo->ri_FdwPushdown)
 						ereport(ERROR,
 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 							errmsg("cannot insert into foreign table \"%s\"",
@@ -1099,7 +1101,8 @@ CheckValidResultRel(Relation resultRel, CmdType operation)
 							   RelationGetRelationName(resultRel))));
 					break;
 				case CMD_UPDATE:
-					if (fdwroutine->ExecForeignUpdate == NULL)
+					if (fdwroutine->ExecForeignUpdate == NULL &&
+						!resultRelInfo->ri_FdwPushdown)
 						ereport(ERROR,
 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 								 errmsg("cannot update foreign table \"%s\"",
@@ -1112,7 +1115,8 @@ CheckValidResultRel(Relation resultRel, CmdType operation)
 							   RelationGetRelationName(resultRel))));
 					break;
 				case CMD_DELETE:
-					if (fdwroutine->ExecForeignDelete == NULL)
+					if (fdwroutine->ExecForeignDelete == NULL &&
+						!resultRelInfo->ri_FdwPushdown)
 						ereport(ERROR,
 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 							errmsg("cannot delete from foreign table \"%s\"",
@@ -1245,6 +1249,7 @@ InitResultRelInfo(ResultRelInfo *resultRelInfo,
 	else
 		resultRelInfo->ri_FdwRoutine = NULL;
 	resultRelInfo->ri_FdwState = NULL;
+	resultRelInfo->ri_FdwPushdown = false;
 	resultRelInfo->ri_ConstraintExprs = NULL;
 	resultRelInfo->ri_junkFilter = NULL;
 	resultRelInfo->ri_projectReturning = NULL;
diff --git a/src/backend/executor/nodeForeignscan.c b/src/backend/executor/nodeForeignscan.c
index 388c922..2cfe256 100644
--- a/src/backend/executor/nodeForeignscan.c
+++ b/src/backend/executor/nodeForeignscan.c
@@ -48,7 +48,10 @@ ForeignNext(ForeignScanState *node)
 
 	/* Call the Iterate function in short-lived context */
 	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
-	slot = node->fdwroutine->IterateForeignScan(node);
+	if (plan->operation != CMD_SELECT)
+		slot = node->fdwroutine->IterateDMLPushdown(node);
+	else
+		slot = node->fdwroutine->IterateForeignScan(node);
 	MemoryContextSwitchTo(oldcontext);
 
 	/*
@@ -226,7 +229,10 @@ ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
 	/*
 	 * Tell the FDW to initialize the scan.
 	 */
-	fdwroutine->BeginForeignScan(scanstate, eflags);
+	if (node->operation != CMD_SELECT)
+		fdwroutine->BeginDMLPushdown(scanstate, eflags);
+	else
+		fdwroutine->BeginForeignScan(scanstate, eflags);
 
 	return scanstate;
 }
@@ -240,8 +246,13 @@ ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
 void
 ExecEndForeignScan(ForeignScanState *node)
 {
+	ForeignScan *plan = (ForeignScan *) node->ss.ps.plan;
+
 	/* Let the FDW shut down */
-	node->fdwroutine->EndForeignScan(node);
+	if (plan->operation != CMD_SELECT)
+		node->fdwroutine->EndDMLPushdown(node);
+	else
+		node->fdwroutine->EndForeignScan(node);
 
 	/* Shut down any outer plan. */
 	if (outerPlanState(node))
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index 27051e8..d87cd8a 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -138,13 +138,17 @@ ExecCheckPlanOutput(Relation resultRel, List *targetList)
  * tupleSlot: slot holding tuple actually inserted/updated/deleted
  * planSlot: slot holding tuple returned by top subplan node
  *
+ * Note: If tupleSlot is NULL, the FDW should have already provided econtext's
+ * scan tuple.
+ *
  * Returns a slot holding the result tuple
  */
 static TupleTableSlot *
-ExecProcessReturning(ProjectionInfo *projectReturning,
+ExecProcessReturning(ResultRelInfo *resultRelInfo,
 					 TupleTableSlot *tupleSlot,
 					 TupleTableSlot *planSlot)
 {
+	ProjectionInfo *projectReturning = resultRelInfo->ri_projectReturning;
 	ExprContext *econtext = projectReturning->pi_exprContext;
 
 	/*
@@ -154,7 +158,20 @@ ExecProcessReturning(ProjectionInfo *projectReturning,
 	ResetExprContext(econtext);
 
 	/* Make tuple and any needed join variables available to ExecProject */
-	econtext->ecxt_scantuple = tupleSlot;
+	if (tupleSlot)
+		econtext->ecxt_scantuple = tupleSlot;
+	else
+	{
+		HeapTuple	tuple;
+
+		/*
+		 * RETURNING expressions might reference the tableoid column, so
+		 * initialize t_tableOid before evaluating them.
+		 */
+		Assert(!TupIsNull(econtext->ecxt_scantuple));
+		tuple = ExecMaterializeSlot(econtext->ecxt_scantuple);
+		tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
+	}
 	econtext->ecxt_outertuple = planSlot;
 
 	/* Compute the RETURNING expressions */
@@ -496,8 +513,7 @@ ExecInsert(ModifyTableState *mtstate,
 
 	/* Process RETURNING if present */
 	if (resultRelInfo->ri_projectReturning)
-		return ExecProcessReturning(resultRelInfo->ri_projectReturning,
-									slot, planSlot);
+		return ExecProcessReturning(resultRelInfo, slot, planSlot);
 
 	return NULL;
 }
@@ -738,8 +754,7 @@ ldelete:;
 			ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);
 		}
 
-		rslot = ExecProcessReturning(resultRelInfo->ri_projectReturning,
-									 slot, planSlot);
+		rslot = ExecProcessReturning(resultRelInfo, slot, planSlot);
 
 		/*
 		 * Before releasing the target tuple again, make sure rslot has a
@@ -1024,8 +1039,7 @@ lreplace:;
 
 	/* Process RETURNING if present */
 	if (resultRelInfo->ri_projectReturning)
-		return ExecProcessReturning(resultRelInfo->ri_projectReturning,
-									slot, planSlot);
+		return ExecProcessReturning(resultRelInfo, slot, planSlot);
 
 	return NULL;
 }
@@ -1380,6 +1394,21 @@ ExecModifyTable(ModifyTableState *node)
 				break;
 		}
 
+		/*
+		 * If ri_FdwPushdown is true, all we need to do here is compute the
+		 * RETURNING expressions.
+		 */
+		if (resultRelInfo->ri_FdwPushdown)
+		{
+			Assert(resultRelInfo->ri_projectReturning);
+
+			/* No need to provide scan tuple to ExecProcessReturning. */
+			slot = ExecProcessReturning(resultRelInfo, NULL, planSlot);
+
+			estate->es_result_relation_info = saved_resultRelInfo;
+			return slot;
+		}
+
 		EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
 		slot = planSlot;
 
@@ -1559,10 +1588,13 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 	{
 		subplan = (Plan *) lfirst(l);
 
+		/* Initialize the FdwPushdown flag */
+		resultRelInfo->ri_FdwPushdown = list_nth_int(node->fdwPushdowns, i);
+
 		/*
 		 * Verify result relation is a valid target for the current operation
 		 */
-		CheckValidResultRel(resultRelInfo->ri_RelationDesc, operation);
+		CheckValidResultRel(resultRelInfo, operation);
 
 		/*
 		 * If there are indices on the result relation, open them and save
@@ -1583,7 +1615,8 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 		mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
 
 		/* Also let FDWs init themselves for foreign-table result rels */
-		if (resultRelInfo->ri_FdwRoutine != NULL &&
+		if (!resultRelInfo->ri_FdwPushdown &&
+			resultRelInfo->ri_FdwRoutine != NULL &&
 			resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
 		{
 			List	   *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
@@ -1754,13 +1787,25 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 		erm = ExecFindRowMark(estate, rc->rti, false);
 
 		/* build ExecAuxRowMark for each subplan */
+		resultRelInfo = mtstate->resultRelInfo;
 		for (i = 0; i < nplans; i++)
 		{
 			ExecAuxRowMark *aerm;
 
+			/*
+			 * ignore subplan if the FDW pushes down the command to the remote
+			 * server
+			 */
+			if (resultRelInfo->ri_FdwPushdown)
+			{
+				resultRelInfo++;
+				continue;
+			}
+
 			subplan = mtstate->mt_plans[i]->plan;
 			aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
 			mtstate->mt_arowmarks[i] = lappend(mtstate->mt_arowmarks[i], aerm);
+			resultRelInfo++;
 		}
 	}
 
@@ -1821,6 +1866,16 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
 					ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
 										subplan->targetlist);
 
+				/*
+				 * ignore subplan if the FDW pushes down the command to the
+				 * remote server
+				 */
+				if (resultRelInfo->ri_FdwPushdown)
+				{
+					resultRelInfo++;
+					continue;
+				}
+
 				j = ExecInitJunkFilter(subplan->targetlist,
 							resultRelInfo->ri_RelationDesc->rd_att->tdhasoid,
 									   ExecInitExtraTupleSlot(estate));
@@ -1910,7 +1965,8 @@ ExecEndModifyTable(ModifyTableState *node)
 	{
 		ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
 
-		if (resultRelInfo->ri_FdwRoutine != NULL &&
+		if (!resultRelInfo->ri_FdwPushdown &&
+			resultRelInfo->ri_FdwRoutine != NULL &&
 			resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
 			resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
 														   resultRelInfo);
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index a8b79fa..98d7226 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -187,6 +187,7 @@ _copyModifyTable(const ModifyTable *from)
 	COPY_NODE_FIELD(withCheckOptionLists);
 	COPY_NODE_FIELD(returningLists);
 	COPY_NODE_FIELD(fdwPrivLists);
+	COPY_NODE_FIELD(fdwPushdowns);
 	COPY_NODE_FIELD(rowMarks);
 	COPY_SCALAR_FIELD(epqParam);
 	COPY_SCALAR_FIELD(onConflictAction);
@@ -646,6 +647,7 @@ _copyForeignScan(const ForeignScan *from)
 	/*
 	 * copy remainder of node
 	 */
+	COPY_SCALAR_FIELD(operation);
 	COPY_SCALAR_FIELD(fs_server);
 	COPY_NODE_FIELD(fdw_exprs);
 	COPY_NODE_FIELD(fdw_private);
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index d59b954..3a73f02 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -341,6 +341,7 @@ _outModifyTable(StringInfo str, const ModifyTable *node)
 	WRITE_NODE_FIELD(withCheckOptionLists);
 	WRITE_NODE_FIELD(returningLists);
 	WRITE_NODE_FIELD(fdwPrivLists);
+	WRITE_NODE_FIELD(fdwPushdowns);
 	WRITE_NODE_FIELD(rowMarks);
 	WRITE_INT_FIELD(epqParam);
 	WRITE_ENUM_FIELD(onConflictAction, OnConflictAction);
@@ -592,6 +593,7 @@ _outForeignScan(StringInfo str, const ForeignScan *node)
 
 	_outScanInfo(str, (const Scan *) node);
 
+	WRITE_ENUM_FIELD(operation, CmdType);
 	WRITE_OID_FIELD(fs_server);
 	WRITE_NODE_FIELD(fdw_exprs);
 	WRITE_NODE_FIELD(fdw_private);
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 6c46151..d413241 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -1472,6 +1472,7 @@ _readModifyTable(void)
 	READ_NODE_FIELD(withCheckOptionLists);
 	READ_NODE_FIELD(returningLists);
 	READ_NODE_FIELD(fdwPrivLists);
+	READ_NODE_FIELD(fdwPushdowns);
 	READ_NODE_FIELD(rowMarks);
 	READ_INT_FIELD(epqParam);
 	READ_ENUM_FIELD(onConflictAction, OnConflictAction);
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 54ff7f6..0dd05ca 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -3788,6 +3788,7 @@ make_foreignscan(List *qptlist,
 	plan->lefttree = outer_plan;
 	plan->righttree = NULL;
 	node->scan.scanrelid = scanrelid;
+	node->operation = CMD_SELECT;
 	/* fs_server will be filled in by create_foreignscan_plan */
 	node->fs_server = InvalidOid;
 	node->fdw_exprs = fdw_exprs;
@@ -5064,6 +5065,7 @@ make_modifytable(PlannerInfo *root,
 	Plan	   *plan = &node->plan;
 	double		total_size;
 	List	   *fdw_private_list;
+	List	   *fdwpushdown_list;
 	ListCell   *subnode;
 	ListCell   *lc;
 	int			i;
@@ -5144,12 +5146,14 @@ make_modifytable(PlannerInfo *root,
 	 * construct private plan data, and accumulate it all into a list.
 	 */
 	fdw_private_list = NIL;
+	fdwpushdown_list = NIL;
 	i = 0;
 	foreach(lc, resultRelations)
 	{
 		Index		rti = lfirst_int(lc);
 		FdwRoutine *fdwroutine;
 		List	   *fdw_private;
+		bool		fdwpushdown;
 
 		/*
 		 * If possible, we want to get the FdwRoutine from our RelOptInfo for
@@ -5176,7 +5180,23 @@ make_modifytable(PlannerInfo *root,
 				fdwroutine = NULL;
 		}
 
+		/*
+		 * If the target relation has any row-level triggers, we can't push
+		 * down the command to the remote server.
+		 */
 		if (fdwroutine != NULL &&
+			fdwroutine->PlanDMLPushdown != NULL &&
+			fdwroutine->BeginDMLPushdown != NULL &&
+			fdwroutine->IterateDMLPushdown != NULL &&
+			fdwroutine->EndDMLPushdown != NULL &&
+			!has_row_triggers(root, rti, operation))
+			fdwpushdown = fdwroutine->PlanDMLPushdown(root, node, rti, i);
+		else
+			fdwpushdown = false;
+		fdwpushdown_list = lappend_int(fdwpushdown_list, fdwpushdown);
+
+		if (!fdwpushdown &&
+			fdwroutine != NULL &&
 			fdwroutine->PlanForeignModify != NULL)
 			fdw_private = fdwroutine->PlanForeignModify(root, node, rti, i);
 		else
@@ -5185,6 +5205,7 @@ make_modifytable(PlannerInfo *root,
 		i++;
 	}
 	node->fdwPrivLists = fdw_private_list;
+	node->fdwPushdowns = fdwpushdown_list;
 
 	return node;
 }
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 0ea9fcf..8d19b37 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1520,3 +1520,50 @@ has_unique_index(RelOptInfo *rel, AttrNumber attno)
 	}
 	return false;
 }
+
+
+/*
+ * has_row_triggers
+ *
+ * Detect whether the specified relation has any row-level triggers for event.
+ */
+bool
+has_row_triggers(PlannerInfo *root, Index rti, CmdType event)
+{
+	RangeTblEntry *rte = planner_rt_fetch(rti, root);
+	Relation	relation;
+	TriggerDesc *trigDesc;
+	bool		result = false;
+
+	/* Assume we already have adequate lock */
+	relation = heap_open(rte->relid, NoLock);
+
+	trigDesc = relation->trigdesc;
+	switch (event)
+	{
+		case CMD_INSERT:
+			if (trigDesc &&
+				(trigDesc->trig_insert_after_row ||
+				 trigDesc->trig_insert_before_row))
+				result = true;
+			break;
+		case CMD_UPDATE:
+			if (trigDesc &&
+				(trigDesc->trig_update_after_row ||
+				 trigDesc->trig_update_before_row))
+				result = true;
+			break;
+		case CMD_DELETE:
+			if (trigDesc &&
+				(trigDesc->trig_delete_after_row ||
+				 trigDesc->trig_delete_before_row))
+				result = true;
+			break;
+		default:
+			elog(ERROR, "unrecognized CmdType: %d", (int) event);
+			break;
+	}
+
+	heap_close(relation, NoLock);
+	return result;
+}
diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index 1a44085..fd12df4 100644
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -184,7 +184,7 @@ extern void ExecutorEnd(QueryDesc *queryDesc);
 extern void standard_ExecutorEnd(QueryDesc *queryDesc);
 extern void ExecutorRewind(QueryDesc *queryDesc);
 extern bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation);
-extern void CheckValidResultRel(Relation resultRel, CmdType operation);
+extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation);
 extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
 				  Relation resultRelationDesc,
 				  Index resultRelationIndex,
diff --git a/src/include/foreign/fdwapi.h b/src/include/foreign/fdwapi.h
index 9fafab0..e150bea 100644
--- a/src/include/foreign/fdwapi.h
+++ b/src/include/foreign/fdwapi.h
@@ -94,6 +94,18 @@ typedef void (*EndForeignModify_function) (EState *estate,
 
 typedef int (*IsForeignRelUpdatable_function) (Relation rel);
 
+typedef bool (*PlanDMLPushdown_function) (PlannerInfo *root,
+										  ModifyTable *plan,
+										  Index resultRelation,
+										  int subplan_index);
+
+typedef void (*BeginDMLPushdown_function) (ForeignScanState *node,
+										   int eflags);
+
+typedef TupleTableSlot *(*IterateDMLPushdown_function) (ForeignScanState *node);
+
+typedef void (*EndDMLPushdown_function) (ForeignScanState *node);
+
 typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
 												LockClauseStrength strength);
 
@@ -111,6 +123,9 @@ typedef void (*ExplainForeignModify_function) (ModifyTableState *mtstate,
 														   int subplan_index,
 													struct ExplainState *es);
 
+typedef void (*ExplainDMLPushdown_function) (ForeignScanState *node,
+													struct ExplainState *es);
+
 typedef int (*AcquireSampleRowsFunc) (Relation relation, int elevel,
 											   HeapTuple *rows, int targrows,
 												  double *totalrows,
@@ -171,6 +186,10 @@ typedef struct FdwRoutine
 	ExecForeignDelete_function ExecForeignDelete;
 	EndForeignModify_function EndForeignModify;
 	IsForeignRelUpdatable_function IsForeignRelUpdatable;
+	PlanDMLPushdown_function PlanDMLPushdown;
+	BeginDMLPushdown_function BeginDMLPushdown;
+	IterateDMLPushdown_function IterateDMLPushdown;
+	EndDMLPushdown_function EndDMLPushdown;
 
 	/* Functions for SELECT FOR UPDATE/SHARE row locking */
 	GetForeignRowMarkType_function GetForeignRowMarkType;
@@ -180,6 +199,7 @@ typedef struct FdwRoutine
 	/* Support functions for EXPLAIN */
 	ExplainForeignScan_function ExplainForeignScan;
 	ExplainForeignModify_function ExplainForeignModify;
+	ExplainDMLPushdown_function ExplainDMLPushdown;
 
 	/* Support functions for ANALYZE */
 	AnalyzeForeignTable_function AnalyzeForeignTable;
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 064a050..fe160db 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -311,6 +311,7 @@ typedef struct JunkFilter
  *		TrigInstrument			optional runtime measurements for triggers
  *		FdwRoutine				FDW callback functions, if foreign table
  *		FdwState				available to save private state of FDW
+ *		FdwPushdown				true when the command is pushed down
  *		WithCheckOptions		list of WithCheckOption's to be checked
  *		WithCheckOptionExprs	list of WithCheckOption expr states
  *		ConstraintExprs			array of constraint-checking expr states
@@ -334,6 +335,7 @@ typedef struct ResultRelInfo
 	Instrumentation *ri_TrigInstrument;
 	struct FdwRoutine *ri_FdwRoutine;
 	void	   *ri_FdwState;
+	bool		ri_FdwPushdown;
 	List	   *ri_WithCheckOptions;
 	List	   *ri_WithCheckOptionExprs;
 	List	  **ri_ConstraintExprs;
diff --git a/src/include/nodes/plannodes.h b/src/include/nodes/plannodes.h
index 55d6bbe..4858c79 100644
--- a/src/include/nodes/plannodes.h
+++ b/src/include/nodes/plannodes.h
@@ -189,6 +189,7 @@ typedef struct ModifyTable
 	List	   *withCheckOptionLists;	/* per-target-table WCO lists */
 	List	   *returningLists; /* per-target-table RETURNING tlists */
 	List	   *fdwPrivLists;	/* per-target-table FDW private data lists */
+	List	   *fdwPushdowns;	/* per-target-table FDW pushdown flags */
 	List	   *rowMarks;		/* PlanRowMarks (non-locking only) */
 	int			epqParam;		/* ID of Param for EvalPlanQual re-eval */
 	OnConflictAction onConflictAction;	/* ON CONFLICT action */
@@ -531,6 +532,7 @@ typedef struct WorkTableScan
 typedef struct ForeignScan
 {
 	Scan		scan;
+	CmdType		operation;		/* SELECT/INSERT/UPDATE/DELETE */
 	Oid			fs_server;		/* OID of foreign server */
 	List	   *fdw_exprs;		/* expressions that FDW may evaluate */
 	List	   *fdw_private;	/* private data for FDW */
diff --git a/src/include/optimizer/plancat.h b/src/include/optimizer/plancat.h
index 52335fa..125274e 100644
--- a/src/include/optimizer/plancat.h
+++ b/src/include/optimizer/plancat.h
@@ -55,4 +55,6 @@ extern Selectivity join_selectivity(PlannerInfo *root,
 				 JoinType jointype,
 				 SpecialJoinInfo *sjinfo);
 
+extern bool has_row_triggers(PlannerInfo *root, Index rti, CmdType event);
+
 #endif   /* PLANCAT_H */