Using results from INSERT ... RETURNING

Hello.

Here's a patch(WIP) that implements INSERT .. RETURNING inside a CTE.
Should apply cleanly against CVS head.

The INSERT query isn't rewritten so rules and default values don't work.
Recursive CTEs don't work either.

Regards,
Marko Tiikkaja
*** a/src/backend/commands/explain.c
--- b/src/backend/commands/explain.c
***************
*** 651,656 **** explain_outNode(StringInfo str,
--- 651,659 ----
          case T_Hash:
              pname = "Hash";
              break;
+         case T_InsertReturning:
+             pname = "INSERT RETURNING";
+             break;
          default:
              pname = "???";
              break;
*** a/src/backend/executor/Makefile
--- b/src/backend/executor/Makefile
***************
*** 15,21 **** include $(top_builddir)/src/Makefile.global
  OBJS = execAmi.o execCurrent.o execGrouping.o execJunk.o execMain.o \
         execProcnode.o execQual.o execScan.o execTuples.o \
         execUtils.o functions.o instrument.o nodeAppend.o nodeAgg.o \
!        nodeBitmapAnd.o nodeBitmapOr.o \
         nodeBitmapHeapscan.o nodeBitmapIndexscan.o nodeHash.o \
         nodeHashjoin.o nodeIndexscan.o nodeMaterial.o nodeMergejoin.o \
         nodeNestloop.o nodeFunctionscan.o nodeRecursiveunion.o nodeResult.o \
--- 15,21 ----
  OBJS = execAmi.o execCurrent.o execGrouping.o execJunk.o execMain.o \
         execProcnode.o execQual.o execScan.o execTuples.o \
         execUtils.o functions.o instrument.o nodeAppend.o nodeAgg.o \
!        nodeBitmapAnd.o nodeBitmapOr.o nodeInsertReturning.o \
         nodeBitmapHeapscan.o nodeBitmapIndexscan.o nodeHash.o \
         nodeHashjoin.o nodeIndexscan.o nodeMaterial.o nodeMergejoin.o \
         nodeNestloop.o nodeFunctionscan.o nodeRecursiveunion.o nodeResult.o \
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 86,94 **** static void ExecutePlan(EState *estate, PlanState *planstate,
              DestReceiver *dest);
  static void ExecSelect(TupleTableSlot *slot,
             DestReceiver *dest, EState *estate);
! static void ExecInsert(TupleTableSlot *slot, ItemPointer tupleid,
             TupleTableSlot *planSlot,
!            DestReceiver *dest, EState *estate);
  static void ExecDelete(ItemPointer tupleid,
             TupleTableSlot *planSlot,
             DestReceiver *dest, EState *estate);
--- 86,94 ----
              DestReceiver *dest);
  static void ExecSelect(TupleTableSlot *slot,
             DestReceiver *dest, EState *estate);
! void ExecInsert(TupleTableSlot *slot, ItemPointer tupleid,
             TupleTableSlot *planSlot,
!            DestReceiver *dest, EState *estate, ResultRelInfo* resultRelInfo, bool clearReturningTuple);
  static void ExecDelete(ItemPointer tupleid,
             TupleTableSlot *planSlot,
             DestReceiver *dest, EState *estate);
***************
*** 98,104 **** static void ExecUpdate(TupleTableSlot *slot, ItemPointer tupleid,
  static void ExecProcessReturning(ProjectionInfo *projectReturning,
                       TupleTableSlot *tupleSlot,
                       TupleTableSlot *planSlot,
!                      DestReceiver *dest);
  static TupleTableSlot *EvalPlanQualNext(EState *estate);
  static void EndEvalPlanQual(EState *estate);
  static void ExecCheckRTPerms(List *rangeTable);
--- 98,105 ----
  static void ExecProcessReturning(ProjectionInfo *projectReturning,
                       TupleTableSlot *tupleSlot,
                       TupleTableSlot *planSlot,
!                      DestReceiver *dest,
!                      bool clearTuple);
  static TupleTableSlot *EvalPlanQualNext(EState *estate);
  static void EndEvalPlanQual(EState *estate);
  static void ExecCheckRTPerms(List *rangeTable);
***************
*** 190,196 **** standard_ExecutorStart(QueryDesc *queryDesc, int eflags)
          case CMD_SELECT:
              /* SELECT INTO and SELECT FOR UPDATE/SHARE need to mark tuples */
              if (queryDesc->plannedstmt->intoClause != NULL ||
!                 queryDesc->plannedstmt->rowMarks != NIL)
                  estate->es_output_cid = GetCurrentCommandId(true);
              break;

--- 191,198 ----
          case CMD_SELECT:
              /* SELECT INTO and SELECT FOR UPDATE/SHARE need to mark tuples */
              if (queryDesc->plannedstmt->intoClause != NULL ||
!                 queryDesc->plannedstmt->rowMarks != NIL ||
!                 queryDesc->plannedstmt->hasWritableCtes)
                  estate->es_output_cid = GetCurrentCommandId(true);
              break;

***************
*** 1670,1676 **** lnext:    ;
                  break;

              case CMD_INSERT:
!                 ExecInsert(slot, tupleid, planSlot, dest, estate);
                  break;

              case CMD_DELETE:
--- 1672,1678 ----
                  break;

              case CMD_INSERT:
!                 ExecInsert(slot, tupleid, planSlot, dest, estate, estate->es_result_relation_info, true);
                  break;

              case CMD_DELETE:
***************
*** 1742,1756 **** ExecSelect(TupleTableSlot *slot,
   *        index relations.
   * ----------------------------------------------------------------
   */
! static void
  ExecInsert(TupleTableSlot *slot,
             ItemPointer tupleid,
             TupleTableSlot *planSlot,
             DestReceiver *dest,
!            EState *estate)
  {
      HeapTuple    tuple;
-     ResultRelInfo *resultRelInfo;
      Relation    resultRelationDesc;
      Oid            newId;

--- 1744,1759 ----
   *        index relations.
   * ----------------------------------------------------------------
   */
! void
  ExecInsert(TupleTableSlot *slot,
             ItemPointer tupleid,
             TupleTableSlot *planSlot,
             DestReceiver *dest,
!            EState *estate,
!            ResultRelInfo* resultRelInfo,
!            bool clearReturningTuple)
  {
      HeapTuple    tuple;
      Relation    resultRelationDesc;
      Oid            newId;

***************
*** 1763,1769 **** ExecInsert(TupleTableSlot *slot,
      /*
       * get information on the (current) result relation
       */
-     resultRelInfo = estate->es_result_relation_info;
      resultRelationDesc = resultRelInfo->ri_RelationDesc;

      /*
--- 1766,1771 ----
***************
*** 1842,1848 **** ExecInsert(TupleTableSlot *slot,
      /* Process RETURNING if present */
      if (resultRelInfo->ri_projectReturning)
          ExecProcessReturning(resultRelInfo->ri_projectReturning,
!                              slot, planSlot, dest);
  }

  /* ----------------------------------------------------------------
--- 1844,1850 ----
      /* Process RETURNING if present */
      if (resultRelInfo->ri_projectReturning)
          ExecProcessReturning(resultRelInfo->ri_projectReturning,
!                              slot, planSlot, dest, clearReturningTuple);
  }

  /* ----------------------------------------------------------------
***************
*** 1968,1974 **** ldelete:;
          ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);

          ExecProcessReturning(resultRelInfo->ri_projectReturning,
!                              slot, planSlot, dest);

          ExecClearTuple(slot);
          ReleaseBuffer(delbuffer);
--- 1970,1976 ----
          ExecStoreTuple(&deltuple, slot, InvalidBuffer, false);

          ExecProcessReturning(resultRelInfo->ri_projectReturning,
!                              slot, planSlot, dest, true);

          ExecClearTuple(slot);
          ReleaseBuffer(delbuffer);
***************
*** 2140,2146 **** lreplace:;
      /* Process RETURNING if present */
      if (resultRelInfo->ri_projectReturning)
          ExecProcessReturning(resultRelInfo->ri_projectReturning,
!                              slot, planSlot, dest);
  }

  /*
--- 2142,2148 ----
      /* Process RETURNING if present */
      if (resultRelInfo->ri_projectReturning)
          ExecProcessReturning(resultRelInfo->ri_projectReturning,
!                              slot, planSlot, dest, true);
  }

  /*
***************
*** 2254,2260 **** static void
  ExecProcessReturning(ProjectionInfo *projectReturning,
                       TupleTableSlot *tupleSlot,
                       TupleTableSlot *planSlot,
!                      DestReceiver *dest)
  {
      ExprContext *econtext = projectReturning->pi_exprContext;
      TupleTableSlot *retSlot;
--- 2256,2262 ----
  ExecProcessReturning(ProjectionInfo *projectReturning,
                       TupleTableSlot *tupleSlot,
                       TupleTableSlot *planSlot,
!                      DestReceiver *dest, bool clearTuple)
  {
      ExprContext *econtext = projectReturning->pi_exprContext;
      TupleTableSlot *retSlot;
***************
*** 2275,2281 **** ExecProcessReturning(ProjectionInfo *projectReturning,
      /* Send to dest */
      (*dest->receiveSlot) (retSlot, dest);

!     ExecClearTuple(retSlot);
  }

  /*
--- 2277,2284 ----
      /* Send to dest */
      (*dest->receiveSlot) (retSlot, dest);

!     if (clearTuple)
!         ExecClearTuple(retSlot);
  }

  /*
*** a/src/backend/executor/execProcnode.c
--- b/src/backend/executor/execProcnode.c
***************
*** 286,291 **** ExecInitNode(Plan *node, EState *estate, int eflags)
--- 286,296 ----
                                                   estate, eflags);
              break;

+         case T_InsertReturning:
+             result = (PlanState *) ExecInitInsertReturning((Limit *) node,
+                                                  estate, eflags);
+             break;
+
          default:
              elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
              result = NULL;        /* keep compiler quiet */
***************
*** 451,456 **** ExecProcNode(PlanState *node)
--- 456,465 ----
              result = ExecLimit((LimitState *) node);
              break;

+         case T_InsertReturningState:
+             result = ExecInsertReturning((InsertReturningState *) node);
+             break;
+
          default:
              elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
              result = NULL;
***************
*** 627,632 **** ExecCountSlotsNode(Plan *node)
--- 636,644 ----
          case T_Limit:
              return ExecCountSlotsLimit((Limit *) node);

+         case T_InsertReturning:
+             return ExecCountSlotsInsertReturning((InsertReturning *) node);
+
          default:
              elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
              break;
***************
*** 783,788 **** ExecEndNode(PlanState *node)
--- 795,804 ----
              ExecEndLimit((LimitState *) node);
              break;

+         case T_InsertReturningState:
+             ExecEndInsertReturning((InsertReturningState *) node);
+             break;
+
          default:
              elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
              break;
*** /dev/null
--- b/src/backend/executor/nodeInsertReturning.c
***************
*** 0 ****
--- 1,120 ----
+ #include "postgres.h"
+
+ #include "executor/executor.h"
+ #include "executor/execdebug.h"
+ #include "executor/nodeInsertReturning.h"
+ #include "utils/memutils.h"
+
+ static struct DR_insertReturning
+ {
+     DestReceiver        dr;
+     TupleTableSlot      **targetSlot;
+ } receiver;
+
+ static void
+ receive(TupleTableSlot *slot, DestReceiver *self)
+ {
+     struct DR_insertReturning *myState = (struct DR_insertReturning *) self;
+
+     *myState->targetSlot = slot;
+ }
+
+ TupleTableSlot *
+ ExecInsertReturning(InsertReturningState *node)
+ {
+     EState        *estate = node->ps.state;
+
+     TupleTableSlot *slot;
+
+     /* Get a tuple from the subplan */
+     slot = ExecProcNode(outerPlanState(node));
+
+     if (TupIsNull(slot))
+         return NULL;
+
+     ExecInsert(slot, NULL, slot, (DestReceiver *) &receiver, estate, node->resultRelInfo, false);
+
+     return node->ps.ps_ResultTupleSlot;
+ }
+
+ InsertReturningState *
+ ExecInitInsertReturning(InsertReturning *node, EState *estate, int eflags)
+ {
+     InsertReturningState *resstate;
+     ExprContext *exprContext;
+     ResultRelInfo *resultRelInfo;
+     Relation resultRelation;
+
+     /*
+      * create state structure
+      */
+     resstate = makeNode(InsertReturningState);
+     resstate->ps.plan = (Plan *) node;
+     resstate->ps.state = estate;
+     resstate->ps.targetlist = node->plan.targetlist;
+
+     outerPlanState(resstate) = ExecInitNode(outerPlan(node), estate, eflags);
+
+     /*
+      * Initialize result tuple slot and assign
+      * type from the target list.
+      */
+     ExecInitResultTupleSlot(estate, &resstate->ps);
+     ExecAssignResultTypeFromTL(&resstate->ps);
+
+     /*
+      * Prepare the RETURNING expression tree for execution. This
+      * has to be done after calling ExecAssignResultTypeFromTL().
+      */
+     resstate->ps.targetlist = (List *)
+         ExecInitExpr((Expr *) node->plan.targetlist,
+                        (PlanState *) resstate);
+
+     /* Initialize result relation info */
+     resultRelInfo = (ResultRelInfo *) palloc0(sizeof(ResultRelInfo));
+     resultRelation = heap_open(node->resultRelationOid, RowExclusiveLock);
+     InitResultRelInfo(resultRelInfo, resultRelation, node->resultRelationIndex, CMD_INSERT, estate->es_instrument);
+
+     /* Initialize RETURNING projection */
+     exprContext = CreateExprContext(estate);
+     resultRelInfo->ri_projectReturning = ExecBuildProjectionInfo(resstate->ps.targetlist,
+                                 exprContext,
+                                 resstate->ps.ps_ResultTupleSlot,
+                                 NULL);
+
+     resstate->resultRelInfo = resultRelInfo;
+
+     /* Assign tuple receiver info */
+     receiver.dr.receiveSlot = receive;
+     receiver.targetSlot = &resstate->ps.ps_ResultTupleSlot;
+
+     return resstate;
+ }
+
+ int
+ ExecCountSlotsInsertReturning(InsertReturning *node)
+ {
+     return ExecCountSlotsNode(outerPlan(node)) + 2;
+ }
+
+ void
+ ExecEndInsertReturning(InsertReturningState *node)
+ {
+     heap_close(node->resultRelInfo->ri_RelationDesc, NoLock);
+     pfree(node->resultRelInfo);
+
+     /*
+      * Free the exprcontext
+      */
+     ExecFreeExprContext(&node->ps);
+
+     /*
+      * clean out the tuple table
+      */
+     ExecClearTuple(node->ps.ps_ResultTupleSlot);
+
+     /*
+      * shut down subplans
+      */
+     ExecEndNode(outerPlanState(node));
+ }
*** a/src/backend/nodes/copyfuncs.c
--- b/src/backend/nodes/copyfuncs.c
***************
*** 1391,1396 **** _copyXmlExpr(XmlExpr *from)
--- 1391,1407 ----

      return newnode;
  }
+
+ static InsertReturning *
+ _copyInsertReturning(InsertReturning *from)
+ {
+     InsertReturning    *newnode = makeNode(InsertReturning);
+
+     CopyPlanFields((Plan *) from, (Plan *) newnode);
+
+     return newnode;
+ }
+

  /*
   * _copyNullIfExpr (same as OpExpr)
***************
*** 4093,4098 **** copyObject(void *from)
--- 4104,4112 ----
          case T_XmlSerialize:
              retval = _copyXmlSerialize(from);
              break;
+         case T_InsertReturning:
+             retval = _copyInsertReturning(from);
+             break;

          default:
              elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
*** a/src/backend/nodes/nodeFuncs.c
--- b/src/backend/nodes/nodeFuncs.c
***************
*** 2354,2359 **** bool
--- 2354,2403 ----
                      return true;
              }
              break;
+         case T_InsertStmt:
+             {
+                 InsertStmt *stmt = (InsertStmt *) node;
+
+                 if (walker(stmt->relation, context))
+                     return true;
+                 if (walker(stmt->cols, context))
+                     return true;
+                 if (walker(stmt->selectStmt, context))
+                     return true;
+                 if (walker(stmt->returningList, context))
+                     return true;
+             }
+             break;
+         case T_UpdateStmt:
+             {
+                 UpdateStmt *stmt = (UpdateStmt *) node;
+
+                 if (walker(stmt->relation, context))
+                     return true;
+                 if (walker(stmt->targetList, context))
+                     return true;
+                 if (walker(stmt->whereClause, context))
+                     return true;
+                 if (walker(stmt->fromClause, context))
+                     return true;
+                 if (walker(stmt->returningList, context))
+                     return true;
+             }
+             break;
+         case T_DeleteStmt:
+             {
+                 DeleteStmt *stmt = (DeleteStmt *) node;
+
+                 if (walker(stmt->relation, context))
+                     return true;
+                 if (walker(stmt->usingClause, context))
+                     return true;
+                 if (walker(stmt->whereClause, context))
+                     return true;
+                 if (walker(stmt->returningList, context))
+                     return true;
+             }
+             break;
          case T_A_Expr:
              {
                  A_Expr       *expr = (A_Expr *) node;
*** a/src/backend/optimizer/plan/planner.c
--- b/src/backend/optimizer/plan/planner.c
***************
*** 155,160 **** standard_planner(Query *parse, int cursorOptions, ParamListInfo boundParams)
--- 155,161 ----
      glob->finalrtable = NIL;
      glob->relationOids = NIL;
      glob->invalItems = NIL;
+     glob->hasWritableCtes = false;
      glob->lastPHId = 0;
      glob->transientPlan = false;

***************
*** 224,229 **** standard_planner(Query *parse, int cursorOptions, ParamListInfo boundParams)
--- 225,231 ----
      result->resultRelations = root->resultRelations;
      result->utilityStmt = parse->utilityStmt;
      result->intoClause = parse->intoClause;
+     result->hasWritableCtes = glob->hasWritableCtes;
      result->subplans = glob->subplans;
      result->rewindPlanIDs = glob->rewindPlanIDs;
      result->returningLists = root->returningLists;
*** a/src/backend/optimizer/plan/setrefs.c
--- b/src/backend/optimizer/plan/setrefs.c
***************
*** 375,380 **** set_plan_refs(PlannerGlobal *glob, Plan *plan, int rtoffset)
--- 375,393 ----
              set_join_references(glob, (Join *) plan, rtoffset);
              break;

+         case T_InsertReturning:
+             {
+                 /*
+                  * grouping_planner() already called
+                  * set_returning_clause_references so the targetList's
+                  * references are already set.
+                  */
+                 InsertReturning *splan = (InsertReturning *) plan;
+
+                 splan->resultRelationIndex += rtoffset;
+             }
+             break;
+
          case T_Hash:
          case T_Material:
          case T_Sort:
*** a/src/backend/optimizer/plan/subselect.c
--- b/src/backend/optimizer/plan/subselect.c
***************
*** 880,885 **** SS_process_ctes(PlannerInfo *root)
--- 880,886 ----
          Bitmapset  *tmpset;
          int            paramid;
          Param       *prm;
+         InsertReturning *returningNode;

          /*
           * Ignore CTEs that are not actually referenced anywhere.
***************
*** 897,902 **** SS_process_ctes(PlannerInfo *root)
--- 898,904 ----
           */
          subquery = (Query *) copyObject(cte->ctequery);

+
          /*
           * Generate the plan for the CTE query.  Always plan for full
           * retrieval --- we don't have enough info to predict otherwise.
***************
*** 954,959 **** SS_process_ctes(PlannerInfo *root)
--- 956,985 ----
          prm = generate_new_param(root, INTERNALOID, -1);
          splan->setParam = list_make1_int(prm->paramid);

+         /* Handle INSERT .. RETURNING inside CTE */
+         if (subquery->commandType != CMD_SELECT)
+         {
+             Oid resultRelationOid;
+             Index resultRelationIndex;
+
+             Assert(subquery->commandType == CMD_INSERT);
+
+             Assert(subquery->resultRelation > 0);
+             Assert(list_length(subroot->returningLists) == 1);
+
+             returningNode = makeNode(InsertReturning);
+             returningNode->plan.lefttree = plan;
+
+             resultRelationOid = getrelid(subquery->resultRelation, subquery->rtable);
+             returningNode->resultRelationOid = resultRelationOid;
+
+             returningNode->plan.targetlist = linitial(subroot->returningLists);
+
+             root->glob->hasWritableCtes = true;
+
+             plan = returningNode;
+         }
+
          /*
           * Add the subplan and its rtable to the global lists.
           */
*** a/src/backend/parser/gram.y
--- b/src/backend/parser/gram.y
***************
*** 7026,7031 **** common_table_expr:  name opt_name_list AS select_with_parens
--- 7026,7058 ----
                  n->location = @1;
                  $$ = (Node *) n;
              }
+         | name opt_name_list AS '(' InsertStmt ')'
+             {
+                 CommonTableExpr *n = makeNode(CommonTableExpr);
+                 n->ctename = $1;
+                 n->aliascolnames = $2;
+                 n->ctequery = $5;
+                 n->location = @1;
+                 $$ = (Node *) n;
+             }
+         | name opt_name_list AS '(' UpdateStmt ')'
+             {
+                 CommonTableExpr *n = makeNode(CommonTableExpr);
+                 n->ctename = $1;
+                 n->aliascolnames = $2;
+                 n->ctequery = $5;
+                 n->location = @1;
+                 $$ = (Node *) n;
+             }
+         | name opt_name_list AS '(' DeleteStmt ')'
+             {
+                 CommonTableExpr *n = makeNode(CommonTableExpr);
+                 n->ctename = $1;
+                 n->aliascolnames = $2;
+                 n->ctequery = $5;
+                 n->location = @1;
+                 $$ = (Node *) n;
+             }
          ;

  into_clause:
*** a/src/backend/parser/parse_cte.c
--- b/src/backend/parser/parse_cte.c
***************
*** 18,23 ****
--- 18,24 ----
  #include "nodes/nodeFuncs.h"
  #include "parser/analyze.h"
  #include "parser/parse_cte.h"
+ #include "nodes/plannodes.h"
  #include "utils/builtins.h"


***************
*** 246,268 **** transformWithClause(ParseState *pstate, WithClause *withClause)
  static void
  analyzeCTE(ParseState *pstate, CommonTableExpr *cte)
  {
!     Query       *query;

      /* Analysis not done already */
!     Assert(IsA(cte->ctequery, SelectStmt));

      query = parse_sub_analyze(cte->ctequery, pstate);
      cte->ctequery = (Node *) query;

      /*
       * Check that we got something reasonable.    Many of these conditions are
       * impossible given restrictions of the grammar, but check 'em anyway.
!      * (These are the same checks as in transformRangeSubselect.)
       */
      if (!IsA(query, Query) ||
!         query->commandType != CMD_SELECT ||
!         query->utilityStmt != NULL)
!         elog(ERROR, "unexpected non-SELECT command in subquery in WITH");
      if (query->intoClause)
          ereport(ERROR,
                  (errcode(ERRCODE_SYNTAX_ERROR),
--- 247,284 ----
  static void
  analyzeCTE(ParseState *pstate, CommonTableExpr *cte)
  {
!     Query        *query;
!     List        *ctelist;

      /* Analysis not done already */
!     /* This needs to be one of SelectStmt, InsertStmt, UpdateStmt, DeleteStmt instead of:
!      * Assert(IsA(cte->ctequery, SelectStmt)); */

      query = parse_sub_analyze(cte->ctequery, pstate);
      cte->ctequery = (Node *) query;

+     if (query->commandType == CMD_SELECT)
+         ctelist = query->targetList;
+     else
+         ctelist = query->returningList;
+
      /*
       * Check that we got something reasonable.    Many of these conditions are
       * impossible given restrictions of the grammar, but check 'em anyway.
!      * (In addition to the same checks as in transformRangeSubselect,
!      * this adds checks for (INSERT|UPDATE|DELETE)...RETURNING.)
       */
      if (!IsA(query, Query) ||
!         query->utilityStmt != NULL ||
!         (query->commandType != CMD_SELECT &&
!         ((query->commandType == CMD_INSERT ||
!           query->commandType == CMD_UPDATE ||
!           query->commandType == CMD_DELETE) &&
!          query->returningList == NULL)))
!         ereport(ERROR,
!                 (errcode(ERRCODE_SYNTAX_ERROR),
!                  errmsg("unexpected non-row-returning command in subquery in WITH"),
!                  parser_errposition(pstate, 0)));
      if (query->intoClause)
          ereport(ERROR,
                  (errcode(ERRCODE_SYNTAX_ERROR),
***************
*** 273,279 **** analyzeCTE(ParseState *pstate, CommonTableExpr *cte)
      if (!cte->cterecursive)
      {
          /* Compute the output column names/types if not done yet */
!         analyzeCTETargetList(pstate, cte, query->targetList);
      }
      else
      {
--- 289,295 ----
      if (!cte->cterecursive)
      {
          /* Compute the output column names/types if not done yet */
!         analyzeCTETargetList(pstate, cte, ctelist);
      }
      else
      {
***************
*** 291,297 **** analyzeCTE(ParseState *pstate, CommonTableExpr *cte)
          lctyp = list_head(cte->ctecoltypes);
          lctypmod = list_head(cte->ctecoltypmods);
          varattno = 0;
!         foreach(lctlist, query->targetList)
          {
              TargetEntry *te = (TargetEntry *) lfirst(lctlist);
              Node       *texpr;
--- 307,313 ----
          lctyp = list_head(cte->ctecoltypes);
          lctypmod = list_head(cte->ctecoltypmods);
          varattno = 0;
!         foreach(lctlist, ctelist)
          {
              TargetEntry *te = (TargetEntry *) lfirst(lctlist);
              Node       *texpr;
*** a/src/backend/parser/parse_relation.c
--- b/src/backend/parser/parse_relation.c
***************
*** 1402,1409 **** addRangeTableEntryForCTE(ParseState *pstate,
      rte->ctelevelsup = levelsup;

      /* Self-reference if and only if CTE's parse analysis isn't completed */
!     rte->self_reference = !IsA(cte->ctequery, Query);
!     Assert(cte->cterecursive || !rte->self_reference);
      /* Bump the CTE's refcount if this isn't a self-reference */
      if (!rte->self_reference)
          cte->cterefcount++;
--- 1402,1409 ----
      rte->ctelevelsup = levelsup;

      /* Self-reference if and only if CTE's parse analysis isn't completed */
!     rte->self_reference = !IsA(cte->ctequery, Query) && !IsA(cte->ctequery, InsertReturning);
!     Assert(cte->cterecursive || !rte->self_reference || IsA(cte->ctequery, InsertReturning));
      /* Bump the CTE's refcount if this isn't a self-reference */
      if (!rte->self_reference)
          cte->cterefcount++;
*** a/src/backend/parser/parse_target.c
--- b/src/backend/parser/parse_target.c
***************
*** 310,319 **** markTargetListOrigin(ParseState *pstate, TargetEntry *tle,
              {
                  CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup);
                  TargetEntry *ste;

                  /* should be analyzed by now */
                  Assert(IsA(cte->ctequery, Query));
!                 ste = get_tle_by_resno(((Query *) cte->ctequery)->targetList,
                                         attnum);
                  if (ste == NULL || ste->resjunk)
                      elog(ERROR, "subquery %s does not have attribute %d",
--- 310,321 ----
              {
                  CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup);
                  TargetEntry *ste;
+                 Query        *query;

                  /* should be analyzed by now */
                  Assert(IsA(cte->ctequery, Query));
!                 query = (Query *) cte->ctequery;
!                 ste = get_tle_by_resno((query->commandType == CMD_SELECT) ? query->targetList : query->returningList,
                                         attnum);
                  if (ste == NULL || ste->resjunk)
                      elog(ERROR, "subquery %s does not have attribute %d",
***************
*** 1233,1243 **** expandRecordVariable(ParseState *pstate, Var *var, int levelsup)
              {
                  CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup);
                  TargetEntry *ste;

                  /* should be analyzed by now */
                  Assert(IsA(cte->ctequery, Query));
!                 ste = get_tle_by_resno(((Query *) cte->ctequery)->targetList,
!                                        attnum);
                  if (ste == NULL || ste->resjunk)
                      elog(ERROR, "subquery %s does not have attribute %d",
                           rte->eref->aliasname, attnum);
--- 1235,1252 ----
              {
                  CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup);
                  TargetEntry *ste;
+                 Query        *query;
+                 List        *ctelist;

                  /* should be analyzed by now */
                  Assert(IsA(cte->ctequery, Query));
!                 query = (Query *) cte->ctequery;
!                 if (query->commandType == CMD_SELECT)
!                     ctelist = query->targetList;
!                 else
!                     ctelist = query->returningList;
!
!                 ste = get_tle_by_resno(ctelist, attnum);
                  if (ste == NULL || ste->resjunk)
                      elog(ERROR, "subquery %s does not have attribute %d",
                           rte->eref->aliasname, attnum);
*** a/src/backend/utils/adt/ruleutils.c
--- b/src/backend/utils/adt/ruleutils.c
***************
*** 3800,3808 **** get_name_for_var_field(Var *var, int fieldno,
                  }
                  if (lc != NULL)
                  {
!                     Query       *ctequery = (Query *) cte->ctequery;
!                     TargetEntry *ste = get_tle_by_resno(ctequery->targetList,
!                                                         attnum);

                      if (ste == NULL || ste->resjunk)
                          elog(ERROR, "subquery %s does not have attribute %d",
--- 3800,3814 ----
                  }
                  if (lc != NULL)
                  {
!                     Query        *ctequery = (Query *) cte->ctequery;
!                     List        *ctelist;
!
!                     if (ctequery->commandType == CMD_SELECT)
!                         ctelist = ctequery->targetList;
!                     else
!                         ctelist = ctequery->returningList;
!
!                     TargetEntry *ste = get_tle_by_resno(ctelist, attnum);

                      if (ste == NULL || ste->resjunk)
                          elog(ERROR, "subquery %s does not have attribute %d",
*** /dev/null
--- b/src/include/executor/nodeInsertReturning.h
***************
*** 0 ****
--- 1,11 ----
+ #ifndef NODEINSERTRETURNING_H
+ #define NODEINSERTRETURNING_H
+
+ #include "nodes/execnodes.h"
+
+ extern int    ExecCountSlotsInsertReturning(InsertReturning *node);
+ extern InsertReturningState *ExecInitInsertReturning(InsertReturning *node, EState *estate, int eflags);
+ extern TupleTableSlot *ExecInsertReturning(InsertReturningState *node);
+ extern void ExecEndInsertReturning(InsertReturningState *node);
+
+ #endif
*** a/src/include/nodes/execnodes.h
--- b/src/include/nodes/execnodes.h
***************
*** 978,983 **** typedef struct ResultState
--- 978,994 ----
  } ResultState;

  /* ----------------
+  *     InsertReturningState information
+  * ----------------
+  */
+ typedef struct InsertReturningState
+ {
+     PlanState        ps;                /* its first field is NodeTag */
+     ResultRelInfo  *resultRelInfo;
+ } InsertReturningState;
+
+
+ /* ----------------
   *     AppendState information
   *
   *        nplans            how many plans are in the list
*** a/src/include/nodes/nodes.h
--- b/src/include/nodes/nodes.h
***************
*** 71,76 **** typedef enum NodeTag
--- 71,77 ----
      T_Hash,
      T_SetOp,
      T_Limit,
+     T_InsertReturning,
      /* this one isn't a subclass of Plan: */
      T_PlanInvalItem,

***************
*** 190,195 **** typedef enum NodeTag
--- 191,197 ----
      T_NullTestState,
      T_CoerceToDomainState,
      T_DomainConstraintState,
+     T_InsertReturningState,

      /*
       * TAGS FOR PLANNER NODES (relation.h)
*** a/src/include/nodes/plannodes.h
--- b/src/include/nodes/plannodes.h
***************
*** 53,58 **** typedef struct PlannedStmt
--- 53,60 ----

      IntoClause *intoClause;        /* target for SELECT INTO / CREATE TABLE AS */

+     bool        hasWritableCtes; /* true if there's an (INSERT|UPDATE|DELETE) .. RETURNING inside a CTE */
+
      List       *subplans;        /* Plan trees for SubPlan expressions */

      Bitmapset  *rewindPlanIDs;    /* indices of subplans that require REWIND */
***************
*** 164,169 **** typedef struct Result
--- 166,179 ----
      Node       *resconstantqual;
  } Result;

+ typedef struct InsertReturning
+ {
+     Plan       plan;
+
+     Oid            resultRelationOid;
+     int            resultRelationIndex; /* rtable index of the result relation*/
+ } InsertReturning;
+
  /* ----------------
   *     Append node -
   *        Generate the concatenation of the results of sub-plans.
*** a/src/include/nodes/relation.h
--- b/src/include/nodes/relation.h
***************
*** 76,81 **** typedef struct PlannerGlobal
--- 76,83 ----

      List       *invalItems;        /* other dependencies, as PlanInvalItems */

+     bool        hasWritableCtes; /* is there an (INSERT|UPDATE|DELETE) .. RETURNING inside a CTE? */
+
      Index        lastPHId;        /* highest PlaceHolderVar ID assigned */

      bool        transientPlan;    /* redo plan when TransactionXmin changes? */