/src/postgres/src/backend/parser/analyze.c

Source
/*-------------------------------------------------------------------------
 *
 * analyze.c
 *    transform the raw parse tree into a query tree
 *
 * For optimizable statements, we are careful to obtain a suitable lock on
 * each referenced table, and other modules of the backend preserve or
 * re-obtain these locks before depending on the results.  It is therefore
 * okay to do significant semantic analysis of these statements.  For
 * utility commands, no locks are obtained here (and if they were, we could
 * not be sure we'd still have them at execution).  Hence the general rule
 * for utility commands is to just dump them into a Query node untransformed.
 * DECLARE CURSOR, EXPLAIN, and CREATE TABLE AS are exceptions because they
 * contain optimizable statements, which we should transform.
 *
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *  src/backend/parser/analyze.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "access/stratnum.h"
#include "access/sysattr.h"
#include "catalog/dependency.h"
#include "catalog/pg_am.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/queryjumble.h"
#include "optimizer/optimizer.h"
#include "parser/analyze.h"
#include "parser/parse_agg.h"
#include "parser/parse_clause.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_cte.h"
#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_merge.h"
#include "parser/parse_oper.h"
#include "parser/parse_param.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "parser/parsetree.h"
#include "utils/backend_status.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/rangetypes.h"
#include "utils/rel.h"
#include "utils/syscache.h"


/* Passthrough data for transformPLAssignStmtTarget */
typedef struct SelectStmtPassthrough
{
  PLAssignStmt *stmt;     /* the assignment statement */
  Node     *target;     /* node representing the target variable */
  List     *indirection;  /* indirection yet to be applied to target */
} SelectStmtPassthrough;

/* Hook for plugins to get control at end of parse analysis */
post_parse_analyze_hook_type post_parse_analyze_hook = NULL;

static Query *transformOptionalSelectInto(ParseState *pstate, Node *parseTree);
static Query *transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt);
static Query *transformInsertStmt(ParseState *pstate, InsertStmt *stmt);
static OnConflictExpr *transformOnConflictClause(ParseState *pstate,
                         OnConflictClause *onConflictClause);
static ForPortionOfExpr *transformForPortionOfClause(ParseState *pstate,
                           int rtindex,
                           const ForPortionOfClause *forPortionOf,
                           const Node *whereClause,
                           bool isUpdate);
static int  count_rowexpr_columns(ParseState *pstate, Node *expr);
static Query *transformSelectStmt(ParseState *pstate, SelectStmt *stmt,
                  SelectStmtPassthrough *passthru);
static Query *transformValuesClause(ParseState *pstate, SelectStmt *stmt);
static Query *transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt);
static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
                     bool isTopLevel, List **targetlist);
static void determineRecursiveColTypes(ParseState *pstate,
                     Node *larg, List *nrtargetlist);
static Query *transformReturnStmt(ParseState *pstate, ReturnStmt *stmt);
static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
static Query *transformPLAssignStmt(ParseState *pstate,
                  PLAssignStmt *stmt);
static List *transformPLAssignStmtTarget(ParseState *pstate, List *tlist,
                     SelectStmtPassthrough *passthru);
static Query *transformDeclareCursorStmt(ParseState *pstate,
                     DeclareCursorStmt *stmt);
static Query *transformExplainStmt(ParseState *pstate,
                   ExplainStmt *stmt);
static Query *transformCreateTableAsStmt(ParseState *pstate,
                     CreateTableAsStmt *stmt);
static Query *transformCallStmt(ParseState *pstate,
                CallStmt *stmt);
static void transformLockingClause(ParseState *pstate, Query *qry,
                   LockingClause *lc, bool pushedDown);
#ifdef DEBUG_NODE_TESTS_ENABLED
static bool test_raw_expression_coverage(Node *node, void *context);
#endif


/*
 * parse_analyze_fixedparams
 *    Analyze a raw parse tree and transform it to Query form.
 *
 * Optionally, information about $n parameter types can be supplied.
 * References to $n indexes not defined by paramTypes[] are disallowed.
 *
 * The result is a Query node.  Optimizable statements require considerable
 * transformation, while utility-type statements are simply hung off
 * a dummy CMD_UTILITY Query node.
 */
Query *
parse_analyze_fixedparams(RawStmt *parseTree, const char *sourceText,
              const Oid *paramTypes, int numParams,
              QueryEnvironment *queryEnv)
{
  ParseState *pstate = make_parsestate(NULL);
  Query    *query;
  JumbleState *jstate = NULL;

  Assert(sourceText != NULL); /* required as of 8.4 */

  pstate->p_sourcetext = sourceText;

  if (numParams > 0)
    setup_parse_fixed_parameters(pstate, paramTypes, numParams);

  pstate->p_queryEnv = queryEnv;

  query = transformTopLevelStmt(pstate, parseTree);

  if (IsQueryIdEnabled())
    jstate = JumbleQuery(query);

  if (post_parse_analyze_hook)
    (*post_parse_analyze_hook) (pstate, query, jstate);

  free_parsestate(pstate);

  pgstat_report_query_id(query->queryId, false);

  return query;
}

/*
 * parse_analyze_varparams
 *
 * This variant is used when it's okay to deduce information about $n
 * symbol datatypes from context.  The passed-in paramTypes[] array can
 * be modified or enlarged (via repalloc).
 */
Query *
parse_analyze_varparams(RawStmt *parseTree, const char *sourceText,
            Oid **paramTypes, int *numParams,
            QueryEnvironment *queryEnv)
{
  ParseState *pstate = make_parsestate(NULL);
  Query    *query;
  JumbleState *jstate = NULL;

  Assert(sourceText != NULL); /* required as of 8.4 */

  pstate->p_sourcetext = sourceText;

  setup_parse_variable_parameters(pstate, paramTypes, numParams);

  pstate->p_queryEnv = queryEnv;

  query = transformTopLevelStmt(pstate, parseTree);

  /* make sure all is well with parameter types */
  check_variable_parameters(pstate, query);

  if (IsQueryIdEnabled())
    jstate = JumbleQuery(query);

  if (post_parse_analyze_hook)
    (*post_parse_analyze_hook) (pstate, query, jstate);

  free_parsestate(pstate);

  pgstat_report_query_id(query->queryId, false);

  return query;
}

/*
 * parse_analyze_withcb
 *
 * This variant is used when the caller supplies their own parser callback to
 * resolve parameters and possibly other things.
 */
Query *
parse_analyze_withcb(RawStmt *parseTree, const char *sourceText,
           ParserSetupHook parserSetup,
           void *parserSetupArg,
           QueryEnvironment *queryEnv)
{
  ParseState *pstate = make_parsestate(NULL);
  Query    *query;
  JumbleState *jstate = NULL;

  Assert(sourceText != NULL); /* required as of 8.4 */

  pstate->p_sourcetext = sourceText;
  pstate->p_queryEnv = queryEnv;
  (*parserSetup) (pstate, parserSetupArg);

  query = transformTopLevelStmt(pstate, parseTree);

  if (IsQueryIdEnabled())
    jstate = JumbleQuery(query);

  if (post_parse_analyze_hook)
    (*post_parse_analyze_hook) (pstate, query, jstate);

  free_parsestate(pstate);

  pgstat_report_query_id(query->queryId, false);

  return query;
}


/*
 * parse_sub_analyze
 *    Entry point for recursively analyzing a sub-statement.
 */
Query *
parse_sub_analyze(Node *parseTree, ParseState *parentParseState,
          CommonTableExpr *parentCTE,
          bool locked_from_parent,
          bool resolve_unknowns)
{
  ParseState *pstate = make_parsestate(parentParseState);
  Query    *query;

  pstate->p_parent_cte = parentCTE;
  pstate->p_locked_from_parent = locked_from_parent;
  pstate->p_resolve_unknowns = resolve_unknowns;

  query = transformStmt(pstate, parseTree);

  free_parsestate(pstate);

  return query;
}

/*
 * transformTopLevelStmt -
 *    transform a Parse tree into a Query tree.
 *
 * This function is just responsible for transferring statement location data
 * from the RawStmt into the finished Query.
 */
Query *
transformTopLevelStmt(ParseState *pstate, RawStmt *parseTree)
{
  Query    *result;

  /* We're at top level, so allow SELECT INTO */
  result = transformOptionalSelectInto(pstate, parseTree->stmt);

  result->stmt_location = parseTree->stmt_location;
  result->stmt_len = parseTree->stmt_len;

  return result;
}

/*
 * transformOptionalSelectInto -
 *    If SELECT has INTO, convert it to CREATE TABLE AS.
 *
 * The only thing we do here that we don't do in transformStmt() is to
 * convert SELECT ... INTO into CREATE TABLE AS.  Since utility statements
 * aren't allowed within larger statements, this is only allowed at the top
 * of the parse tree, and so we only try it before entering the recursive
 * transformStmt() processing.
 */
static Query *
transformOptionalSelectInto(ParseState *pstate, Node *parseTree)
{
  if (IsA(parseTree, SelectStmt))
  {
    SelectStmt *stmt = (SelectStmt *) parseTree;

    /* If it's a set-operation tree, drill down to leftmost SelectStmt */
    while (stmt && stmt->op != SETOP_NONE)
      stmt = stmt->larg;
    Assert(stmt && IsA(stmt, SelectStmt) && stmt->larg == NULL);

    if (stmt->intoClause)
    {
      CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);

      ctas->query = parseTree;
      ctas->into = stmt->intoClause;
      ctas->objtype = OBJECT_TABLE;
      ctas->is_select_into = true;

      /*
       * Remove the intoClause from the SelectStmt.  This makes it safe
       * for transformSelectStmt to complain if it finds intoClause set
       * (implying that the INTO appeared in a disallowed place).
       */
      stmt->intoClause = NULL;

      parseTree = (Node *) ctas;
    }
  }

  return transformStmt(pstate, parseTree);
}

/*
 * transformStmt -
 *    recursively transform a Parse tree into a Query tree.
 */
Query *
transformStmt(ParseState *pstate, Node *parseTree)
{
  Query    *result;

#ifdef DEBUG_NODE_TESTS_ENABLED

  /*
   * We apply debug_raw_expression_coverage_test testing to basic DML
   * statements; we can't just run it on everything because
   * raw_expression_tree_walker() doesn't claim to handle utility
   * statements.
   */
  if (Debug_raw_expression_coverage_test)
  {
    switch (nodeTag(parseTree))
    {
      case T_SelectStmt:
      case T_InsertStmt:
      case T_UpdateStmt:
      case T_DeleteStmt:
      case T_MergeStmt:
        (void) test_raw_expression_coverage(parseTree, NULL);
        break;
      default:
        break;
    }
  }
#endif              /* DEBUG_NODE_TESTS_ENABLED */

  /*
   * Caution: when changing the set of statement types that have non-default
   * processing here, see also stmt_requires_parse_analysis() and
   * analyze_requires_snapshot().
   */
  switch (nodeTag(parseTree))
  {
      /*
       * Optimizable statements
       */
    case T_InsertStmt:
      result = transformInsertStmt(pstate, (InsertStmt *) parseTree);
      break;

    case T_DeleteStmt:
      result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree);
      break;

    case T_UpdateStmt:
      result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree);
      break;

    case T_MergeStmt:
      result = transformMergeStmt(pstate, (MergeStmt *) parseTree);
      break;

    case T_SelectStmt:
      {
        SelectStmt *n = (SelectStmt *) parseTree;

        if (n->valuesLists)
          result = transformValuesClause(pstate, n);
        else if (n->op == SETOP_NONE)
          result = transformSelectStmt(pstate, n, NULL);
        else
          result = transformSetOperationStmt(pstate, n);
      }
      break;

    case T_ReturnStmt:
      result = transformReturnStmt(pstate, (ReturnStmt *) parseTree);
      break;

    case T_PLAssignStmt:
      result = transformPLAssignStmt(pstate,
                       (PLAssignStmt *) parseTree);
      break;

      /*
       * Special cases
       */
    case T_DeclareCursorStmt:
      result = transformDeclareCursorStmt(pstate,
                        (DeclareCursorStmt *) parseTree);
      break;

    case T_ExplainStmt:
      result = transformExplainStmt(pstate,
                      (ExplainStmt *) parseTree);
      break;

    case T_CreateTableAsStmt:
      result = transformCreateTableAsStmt(pstate,
                        (CreateTableAsStmt *) parseTree);
      break;

    case T_CallStmt:
      result = transformCallStmt(pstate,
                     (CallStmt *) parseTree);
      break;

    default:

      /*
       * other statements don't require any transformation; just return
       * the original parsetree with a Query node plastered on top.
       */
      result = makeNode(Query);
      result->commandType = CMD_UTILITY;
      result->utilityStmt = parseTree;
      break;
  }

  /* Mark as original query until we learn differently */
  result->querySource = QSRC_ORIGINAL;
  result->canSetTag = true;

  return result;
}

/*
 * stmt_requires_parse_analysis
 *    Returns true if parse analysis will do anything non-trivial
 *    with the given raw parse tree.
 *
 * Generally, this should return true for any statement type for which
 * transformStmt() does more than wrap a CMD_UTILITY Query around it.
 * When it returns false, the caller can assume that there is no situation
 * in which parse analysis of the raw statement could need to be re-done.
 *
 * Currently, since the rewriter and planner do nothing for CMD_UTILITY
 * Queries, a false result means that the entire parse analysis/rewrite/plan
 * pipeline will never need to be re-done.  If that ever changes, callers
 * will likely need adjustment.
 */
bool
stmt_requires_parse_analysis(RawStmt *parseTree)
{
  bool    result;

  switch (nodeTag(parseTree->stmt))
  {
      /*
       * Optimizable statements
       */
    case T_InsertStmt:
    case T_DeleteStmt:
    case T_UpdateStmt:
    case T_MergeStmt:
    case T_SelectStmt:
    case T_ReturnStmt:
    case T_PLAssignStmt:
      result = true;
      break;

      /*
       * Special cases
       */
    case T_DeclareCursorStmt:
    case T_ExplainStmt:
    case T_CreateTableAsStmt:
    case T_CallStmt:
      result = true;
      break;

    default:
      /* all other statements just get wrapped in a CMD_UTILITY Query */
      result = false;
      break;
  }

  return result;
}

/*
 * analyze_requires_snapshot
 *    Returns true if a snapshot must be set before doing parse analysis
 *    on the given raw parse tree.
 */
bool
analyze_requires_snapshot(RawStmt *parseTree)
{
  /*
   * Currently, this should return true in exactly the same cases that
   * stmt_requires_parse_analysis() does, so we just invoke that function
   * rather than duplicating it.  We keep the two entry points separate for
   * clarity of callers, since from the callers' standpoint these are
   * different conditions.
   *
   * While there may someday be a statement type for which transformStmt()
   * does something nontrivial and yet no snapshot is needed for that
   * processing, it seems likely that making such a choice would be fragile.
   * If you want to install an exception, document the reasoning for it in a
   * comment.
   */
  return stmt_requires_parse_analysis(parseTree);
}

/*
 * query_requires_rewrite_plan()
 *    Returns true if rewriting or planning is non-trivial for this Query.
 *
 * This is much like stmt_requires_parse_analysis(), but applies one step
 * further down the pipeline.
 *
 * We do not provide an equivalent of analyze_requires_snapshot(): callers
 * can assume that any rewriting or planning activity needs a snapshot.
 */
bool
query_requires_rewrite_plan(Query *query)
{
  bool    result;

  if (query->commandType != CMD_UTILITY)
  {
    /* All optimizable statements require rewriting/planning */
    result = true;
  }
  else
  {
    /* This list should match stmt_requires_parse_analysis() */
    switch (nodeTag(query->utilityStmt))
    {
      case T_DeclareCursorStmt:
      case T_ExplainStmt:
      case T_CreateTableAsStmt:
      case T_CallStmt:
        result = true;
        break;
      default:
        result = false;
        break;
    }
  }
  return result;
}

/*
 * transformDeleteStmt -
 *    transforms a Delete Statement
 */
static Query *
transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
{
  Query    *qry = makeNode(Query);
  ParseNamespaceItem *nsitem;
  Node     *qual;

  qry->commandType = CMD_DELETE;

  /* process the WITH clause independently of all else */
  if (stmt->withClause)
  {
    qry->hasRecursive = stmt->withClause->recursive;
    qry->cteList = transformWithClause(pstate, stmt->withClause);
    qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
  }

  /* set up range table with just the result rel */
  qry->resultRelation = setTargetTable(pstate, stmt->relation,
                     stmt->relation->inh,
                     true,
                     ACL_DELETE);
  nsitem = pstate->p_target_nsitem;

  /* disallow DELETE ... WHERE CURRENT OF on a view */
  if (stmt->whereClause &&
    IsA(stmt->whereClause, CurrentOfExpr) &&
    pstate->p_target_relation->rd_rel->relkind == RELKIND_VIEW)
    ereport(ERROR,
        errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        errmsg("WHERE CURRENT OF on a view is not implemented"));

  /* there's no DISTINCT in DELETE */
  qry->distinctClause = NIL;

  /* subqueries in USING cannot access the result relation */
  nsitem->p_lateral_only = true;
  nsitem->p_lateral_ok = false;

  /*
   * The USING clause is non-standard SQL syntax, and is equivalent in
   * functionality to the FROM list that can be specified for UPDATE. The
   * USING keyword is used rather than FROM because FROM is already a
   * keyword in the DELETE syntax.
   */
  transformFromClause(pstate, stmt->usingClause);

  /* remaining clauses can reference the result relation normally */
  nsitem->p_lateral_only = false;
  nsitem->p_lateral_ok = true;

  if (stmt->forPortionOf)
    qry->forPortionOf = transformForPortionOfClause(pstate,
                            qry->resultRelation,
                            stmt->forPortionOf,
                            stmt->whereClause,
                            false);

  qual = transformWhereClause(pstate, stmt->whereClause,
                EXPR_KIND_WHERE, "WHERE");

  transformReturningClause(pstate, qry, stmt->returningClause,
               EXPR_KIND_RETURNING);

  /* done building the range table and jointree */
  qry->rtable = pstate->p_rtable;
  qry->rteperminfos = pstate->p_rteperminfos;
  qry->jointree = makeFromExpr(pstate->p_joinlist, qual);

  qry->hasSubLinks = pstate->p_hasSubLinks;
  qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
  qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
  qry->hasAggs = pstate->p_hasAggs;

  assign_query_collations(pstate, qry);

  /* this must be done after collations, for reliable comparison of exprs */
  if (pstate->p_hasAggs)
    parseCheckAggregates(pstate, qry);

  return qry;
}

/*
 * transformInsertStmt -
 *    transform an Insert Statement
 */
static Query *
transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
{
  Query    *qry = makeNode(Query);
  SelectStmt *selectStmt = (SelectStmt *) stmt->selectStmt;
  List     *exprList = NIL;
  bool    isGeneralSelect;
  List     *sub_rtable;
  List     *sub_rteperminfos;
  List     *sub_namespace;
  List     *icolumns;
  List     *attrnos;
  ParseNamespaceItem *nsitem;
  RTEPermissionInfo *perminfo;
  ListCell   *icols;
  ListCell   *attnos;
  ListCell   *lc;
  bool    requiresUpdatePerm;
  AclMode   targetPerms;

  /* There can't be any outer WITH to worry about */
  Assert(pstate->p_ctenamespace == NIL);

  qry->commandType = CMD_INSERT;

  /* process the WITH clause independently of all else */
  if (stmt->withClause)
  {
    qry->hasRecursive = stmt->withClause->recursive;
    qry->cteList = transformWithClause(pstate, stmt->withClause);
    qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
  }

  qry->override = stmt->override;

  /*
   * ON CONFLICT DO UPDATE and ON CONFLICT DO SELECT FOR UPDATE/SHARE
   * require UPDATE permission on the target relation.
   */
  requiresUpdatePerm = (stmt->onConflictClause &&
              (stmt->onConflictClause->action == ONCONFLICT_UPDATE ||
               (stmt->onConflictClause->action == ONCONFLICT_SELECT &&
              stmt->onConflictClause->lockStrength != LCS_NONE)));

  /*
   * We have three cases to deal with: DEFAULT VALUES (selectStmt == NULL),
   * VALUES list, or general SELECT input.  We special-case VALUES, both for
   * efficiency and so we can handle DEFAULT specifications.
   *
   * The grammar allows attaching ORDER BY, LIMIT, FOR UPDATE, or WITH to a
   * VALUES clause.  If we have any of those, treat it as a general SELECT;
   * so it will work, but you can't use DEFAULT items together with those.
   */
  isGeneralSelect = (selectStmt && (selectStmt->valuesLists == NIL ||
                    selectStmt->sortClause != NIL ||
                    selectStmt->limitOffset != NULL ||
                    selectStmt->limitCount != NULL ||
                    selectStmt->lockingClause != NIL ||
                    selectStmt->withClause != NULL));

  /*
   * If a non-nil rangetable/namespace was passed in, and we are doing
   * INSERT/SELECT, arrange to pass the rangetable/rteperminfos/namespace
   * down to the SELECT.  This can only happen if we are inside a CREATE
   * RULE, and in that case we want the rule's OLD and NEW rtable entries to
   * appear as part of the SELECT's rtable, not as outer references for it.
   * (Kluge!) The SELECT's joinlist is not affected however.  We must do
   * this before adding the target table to the INSERT's rtable.
   */
  if (isGeneralSelect)
  {
    sub_rtable = pstate->p_rtable;
    pstate->p_rtable = NIL;
    sub_rteperminfos = pstate->p_rteperminfos;
    pstate->p_rteperminfos = NIL;
    sub_namespace = pstate->p_namespace;
    pstate->p_namespace = NIL;
  }
  else
  {
    sub_rtable = NIL;   /* not used, but keep compiler quiet */
    sub_rteperminfos = NIL;
    sub_namespace = NIL;
  }

  /*
   * Must get write lock on INSERT target table before scanning SELECT, else
   * we will grab the wrong kind of initial lock if the target table is also
   * mentioned in the SELECT part.  Note that the target table is not added
   * to the joinlist or namespace.
   */
  targetPerms = ACL_INSERT;
  if (requiresUpdatePerm)
    targetPerms |= ACL_UPDATE;
  qry->resultRelation = setTargetTable(pstate, stmt->relation,
                     false, false, targetPerms);

  /* Validate stmt->cols list, or build default list if no list given */
  icolumns = checkInsertTargets(pstate, stmt->cols, &attrnos);
  Assert(list_length(icolumns) == list_length(attrnos));

  /*
   * Determine which variant of INSERT we have.
   */
  if (selectStmt == NULL)
  {
    /*
     * We have INSERT ... DEFAULT VALUES.  We can handle this case by
     * emitting an empty targetlist --- all columns will be defaulted when
     * the planner expands the targetlist.
     */
    exprList = NIL;
  }
  else if (isGeneralSelect)
  {
    /*
     * We make the sub-pstate a child of the outer pstate so that it can
     * see any Param definitions supplied from above.  Since the outer
     * pstate's rtable and namespace are presently empty, there are no
     * side-effects of exposing names the sub-SELECT shouldn't be able to
     * see.
     */
    ParseState *sub_pstate = make_parsestate(pstate);
    Query    *selectQuery;

    /*
     * Process the source SELECT.
     *
     * It is important that this be handled just like a standalone SELECT;
     * otherwise the behavior of SELECT within INSERT might be different
     * from a stand-alone SELECT. (Indeed, Postgres up through 6.5 had
     * bugs of just that nature...)
     *
     * The sole exception is that we prevent resolving unknown-type
     * outputs as TEXT.  This does not change the semantics since if the
     * column type matters semantically, it would have been resolved to
     * something else anyway.  Doing this lets us resolve such outputs as
     * the target column's type, which we handle below.
     */
    sub_pstate->p_rtable = sub_rtable;
    sub_pstate->p_rteperminfos = sub_rteperminfos;
    sub_pstate->p_joinexprs = NIL; /* sub_rtable has no joins */
    sub_pstate->p_nullingrels = NIL;
    sub_pstate->p_namespace = sub_namespace;
    sub_pstate->p_resolve_unknowns = false;

    selectQuery = transformStmt(sub_pstate, stmt->selectStmt);

    free_parsestate(sub_pstate);

    /* The grammar should have produced a SELECT */
    if (!IsA(selectQuery, Query) ||
      selectQuery->commandType != CMD_SELECT)
      elog(ERROR, "unexpected non-SELECT command in INSERT ... SELECT");

    /*
     * Make the source be a subquery in the INSERT's rangetable, and add
     * it to the INSERT's joinlist (but not the namespace).
     */
    nsitem = addRangeTableEntryForSubquery(pstate,
                         selectQuery,
                         NULL,
                         false,
                         false);
    addNSItemToQuery(pstate, nsitem, true, false, false);

    /*----------
     * Generate an expression list for the INSERT that selects all the
     * non-resjunk columns from the subquery.  (INSERT's tlist must be
     * separate from the subquery's tlist because we may add columns,
     * insert datatype coercions, etc.)
     *
     * HACK: unknown-type constants and params in the SELECT's targetlist
     * are copied up as-is rather than being referenced as subquery
     * outputs.  This is to ensure that when we try to coerce them to
     * the target column's datatype, the right things happen (see
     * special cases in coerce_type).  Otherwise, this fails:
     *    INSERT INTO foo SELECT 'bar', ... FROM baz
     *----------
     */
    exprList = NIL;
    foreach(lc, selectQuery->targetList)
    {
      TargetEntry *tle = (TargetEntry *) lfirst(lc);
      Expr     *expr;

      if (tle->resjunk)
        continue;
      if (tle->expr &&
        (IsA(tle->expr, Const) || IsA(tle->expr, Param)) &&
        exprType((Node *) tle->expr) == UNKNOWNOID)
        expr = tle->expr;
      else
      {
        Var      *var = makeVarFromTargetEntry(nsitem->p_rtindex, tle);

        var->location = exprLocation((Node *) tle->expr);
        expr = (Expr *) var;
      }
      exprList = lappend(exprList, expr);
    }

    /* Prepare row for assignment to target table */
    exprList = transformInsertRow(pstate, exprList,
                    stmt->cols,
                    icolumns, attrnos,
                    false);
  }
  else if (list_length(selectStmt->valuesLists) > 1)
  {
    /*
     * Process INSERT ... VALUES with multiple VALUES sublists. We
     * generate a VALUES RTE holding the transformed expression lists, and
     * build up a targetlist containing Vars that reference the VALUES
     * RTE.
     */
    List     *exprsLists = NIL;
    List     *coltypes = NIL;
    List     *coltypmods = NIL;
    List     *colcollations = NIL;
    int     sublist_length = -1;
    bool    lateral = false;

    Assert(selectStmt->intoClause == NULL);

    foreach(lc, selectStmt->valuesLists)
    {
      List     *sublist = (List *) lfirst(lc);

      /*
       * Do basic expression transformation (same as a ROW() expr, but
       * allow SetToDefault at top level)
       */
      sublist = transformExpressionList(pstate, sublist,
                        EXPR_KIND_VALUES, true);

      /*
       * All the sublists must be the same length, *after*
       * transformation (which might expand '*' into multiple items).
       * The VALUES RTE can't handle anything different.
       */
      if (sublist_length < 0)
      {
        /* Remember post-transformation length of first sublist */
        sublist_length = list_length(sublist);
      }
      else if (sublist_length != list_length(sublist))
      {
        ereport(ERROR,
            (errcode(ERRCODE_SYNTAX_ERROR),
             errmsg("VALUES lists must all be the same length"),
             parser_errposition(pstate,
                      exprLocation((Node *) sublist))));
      }

      /*
       * Prepare row for assignment to target table.  We process any
       * indirection on the target column specs normally but then strip
       * off the resulting field/array assignment nodes, since we don't
       * want the parsed statement to contain copies of those in each
       * VALUES row.  (It's annoying to have to transform the
       * indirection specs over and over like this, but avoiding it
       * would take some really messy refactoring of
       * transformAssignmentIndirection.)
       */
      sublist = transformInsertRow(pstate, sublist,
                     stmt->cols,
                     icolumns, attrnos,
                     true);

      /*
       * We must assign collations now because assign_query_collations
       * doesn't process rangetable entries.  We just assign all the
       * collations independently in each row, and don't worry about
       * whether they are consistent vertically.  The outer INSERT query
       * isn't going to care about the collations of the VALUES columns,
       * so it's not worth the effort to identify a common collation for
       * each one here.  (But note this does have one user-visible
       * consequence: INSERT ... VALUES won't complain about conflicting
       * explicit COLLATEs in a column, whereas the same VALUES
       * construct in another context would complain.)
       */
      assign_list_collations(pstate, sublist);

      exprsLists = lappend(exprsLists, sublist);
    }

    /*
     * Construct column type/typmod/collation lists for the VALUES RTE.
     * Every expression in each column has been coerced to the type/typmod
     * of the corresponding target column or subfield, so it's sufficient
     * to look at the exprType/exprTypmod of the first row.  We don't care
     * about the collation labeling, so just fill in InvalidOid for that.
     */
    foreach(lc, (List *) linitial(exprsLists))
    {
      Node     *val = (Node *) lfirst(lc);

      coltypes = lappend_oid(coltypes, exprType(val));
      coltypmods = lappend_int(coltypmods, exprTypmod(val));
      colcollations = lappend_oid(colcollations, InvalidOid);
    }

    /*
     * Ordinarily there can't be any current-level Vars in the expression
     * lists, because the namespace was empty ... but if we're inside
     * CREATE RULE, then NEW/OLD references might appear.  In that case we
     * have to mark the VALUES RTE as LATERAL.
     */
    if (list_length(pstate->p_rtable) != 1 &&
      contain_vars_of_level((Node *) exprsLists, 0))
      lateral = true;

    /*
     * Generate the VALUES RTE
     */
    nsitem = addRangeTableEntryForValues(pstate, exprsLists,
                       coltypes, coltypmods, colcollations,
                       NULL, lateral, true);
    addNSItemToQuery(pstate, nsitem, true, false, false);

    /*
     * Generate list of Vars referencing the RTE
     */
    exprList = expandNSItemVars(pstate, nsitem, 0, -1, NULL);

    /*
     * Re-apply any indirection on the target column specs to the Vars
     */
    exprList = transformInsertRow(pstate, exprList,
                    stmt->cols,
                    icolumns, attrnos,
                    false);
  }
  else
  {
    /*
     * Process INSERT ... VALUES with a single VALUES sublist.  We treat
     * this case separately for efficiency.  The sublist is just computed
     * directly as the Query's targetlist, with no VALUES RTE.  So it
     * works just like a SELECT without any FROM.
     */
    List     *valuesLists = selectStmt->valuesLists;

    Assert(list_length(valuesLists) == 1);
    Assert(selectStmt->intoClause == NULL);

    /*
     * Do basic expression transformation (same as a ROW() expr, but allow
     * SetToDefault at top level)
     */
    exprList = transformExpressionList(pstate,
                       (List *) linitial(valuesLists),
                       EXPR_KIND_VALUES_SINGLE,
                       true);

    /* Prepare row for assignment to target table */
    exprList = transformInsertRow(pstate, exprList,
                    stmt->cols,
                    icolumns, attrnos,
                    false);
  }

  /*
   * Generate query's target list using the computed list of expressions.
   * Also, mark all the target columns as needing insert permissions.
   */
  perminfo = pstate->p_target_nsitem->p_perminfo;
  qry->targetList = NIL;
  Assert(list_length(exprList) <= list_length(icolumns));
  forthree(lc, exprList, icols, icolumns, attnos, attrnos)
  {
    Expr     *expr = (Expr *) lfirst(lc);
    ResTarget  *col = lfirst_node(ResTarget, icols);
    AttrNumber  attr_num = (AttrNumber) lfirst_int(attnos);
    TargetEntry *tle;

    tle = makeTargetEntry(expr,
                attr_num,
                col->name,
                false);
    qry->targetList = lappend(qry->targetList, tle);

    perminfo->insertedCols = bms_add_member(perminfo->insertedCols,
                        attr_num - FirstLowInvalidHeapAttributeNumber);
  }

  /*
   * If we have any clauses yet to process, set the query namespace to
   * contain only the target relation, removing any entries added in a
   * sub-SELECT or VALUES list.
   */
  if (stmt->onConflictClause || stmt->returningClause)
  {
    pstate->p_namespace = NIL;
    addNSItemToQuery(pstate, pstate->p_target_nsitem,
             false, true, true);
  }

  /* ON CONFLICT DO SELECT requires a RETURNING clause */
  if (stmt->onConflictClause &&
    stmt->onConflictClause->action == ONCONFLICT_SELECT &&
    !stmt->returningClause)
    ereport(ERROR,
        errcode(ERRCODE_SYNTAX_ERROR),
        errmsg("ON CONFLICT DO SELECT requires a RETURNING clause"),
        parser_errposition(pstate, stmt->onConflictClause->location));

  /* Process ON CONFLICT, if any. */
  if (stmt->onConflictClause)
    qry->onConflict = transformOnConflictClause(pstate,
                          stmt->onConflictClause);

  /* Process RETURNING, if any. */
  if (stmt->returningClause)
    transformReturningClause(pstate, qry, stmt->returningClause,
                 EXPR_KIND_RETURNING);

  /* done building the range table and jointree */
  qry->rtable = pstate->p_rtable;
  qry->rteperminfos = pstate->p_rteperminfos;
  qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);

  qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
  qry->hasSubLinks = pstate->p_hasSubLinks;

  assign_query_collations(pstate, qry);

  return qry;
}

/*
 * Prepare an INSERT row for assignment to the target table.
 *
 * exprlist: transformed expressions for source values; these might come from
 * a VALUES row, or be Vars referencing a sub-SELECT or VALUES RTE output.
 * stmtcols: original target-columns spec for INSERT (we just test for NIL)
 * icolumns: effective target-columns spec (list of ResTarget)
 * attrnos: integer column numbers (must be same length as icolumns)
 * strip_indirection: if true, remove any field/array assignment nodes
 */
List *
transformInsertRow(ParseState *pstate, List *exprlist,
           List *stmtcols, List *icolumns, List *attrnos,
           bool strip_indirection)
{
  List     *result;
  ListCell   *lc;
  ListCell   *icols;
  ListCell   *attnos;

  /*
   * Check length of expr list.  It must not have more expressions than
   * there are target columns.  We allow fewer, but only if no explicit
   * columns list was given (the remaining columns are implicitly
   * defaulted).  Note we must check this *after* transformation because
   * that could expand '*' into multiple items.
   */
  if (list_length(exprlist) > list_length(icolumns))
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg("INSERT has more expressions than target columns"),
         parser_errposition(pstate,
                  exprLocation(list_nth(exprlist,
                              list_length(icolumns))))));
  if (stmtcols != NIL &&
    list_length(exprlist) < list_length(icolumns))
  {
    /*
     * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
     * where the user accidentally created a RowExpr instead of separate
     * columns.  Add a suitable hint if that seems to be the problem,
     * because the main error message is quite misleading for this case.
     * (If there's no stmtcols, you'll get something about data type
     * mismatch, which is less misleading so we don't worry about giving a
     * hint in that case.)
     */
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg("INSERT has more target columns than expressions"),
         ((list_length(exprlist) == 1 &&
           count_rowexpr_columns(pstate, linitial(exprlist)) ==
           list_length(icolumns)) ?
          errhint("The insertion source is a row expression containing the same number of columns expected by the INSERT. Did you accidentally use extra parentheses?") : 0),
         parser_errposition(pstate,
                  exprLocation(list_nth(icolumns,
                              list_length(exprlist))))));
  }

  /*
   * Prepare columns for assignment to target table.
   */
  result = NIL;
  forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
  {
    Expr     *expr = (Expr *) lfirst(lc);
    ResTarget  *col = lfirst_node(ResTarget, icols);
    int     attno = lfirst_int(attnos);

    expr = transformAssignedExpr(pstate, expr,
                   EXPR_KIND_INSERT_TARGET,
                   col->name,
                   attno,
                   col->indirection,
                   col->location);

    if (strip_indirection)
    {
      /*
       * We need to remove top-level FieldStores and SubscriptingRefs,
       * as well as any CoerceToDomain appearing above one of those ---
       * but not a CoerceToDomain that isn't above one of those.
       */
      while (expr)
      {
        Expr     *subexpr = expr;

        while (IsA(subexpr, CoerceToDomain))
        {
          subexpr = ((CoerceToDomain *) subexpr)->arg;
        }
        if (IsA(subexpr, FieldStore))
        {
          FieldStore *fstore = (FieldStore *) subexpr;

          expr = (Expr *) linitial(fstore->newvals);
        }
        else if (IsA(subexpr, SubscriptingRef))
        {
          SubscriptingRef *sbsref = (SubscriptingRef *) subexpr;

          if (sbsref->refassgnexpr == NULL)
            break;

          expr = sbsref->refassgnexpr;
        }
        else
          break;
      }
    }

    result = lappend(result, expr);
  }

  return result;
}

/*
 * transformOnConflictClause -
 *    transforms an OnConflictClause in an INSERT
 */
static OnConflictExpr *
transformOnConflictClause(ParseState *pstate,
              OnConflictClause *onConflictClause)
{
  ParseNamespaceItem *exclNSItem = NULL;
  List     *arbiterElems;
  Node     *arbiterWhere;
  Oid     arbiterConstraint;
  List     *onConflictSet = NIL;
  Node     *onConflictWhere = NULL;
  int     exclRelIndex = 0;
  List     *exclRelTlist = NIL;
  OnConflictExpr *result;

  /*
   * If this is ON CONFLICT DO SELECT/UPDATE, first create the range table
   * entry for the EXCLUDED pseudo relation, so that that will be present
   * while processing arbiter expressions.  (You can't actually reference it
   * from there, but this provides a useful error message if you try.)
   */
  if (onConflictClause->action == ONCONFLICT_UPDATE ||
    onConflictClause->action == ONCONFLICT_SELECT)
  {
    Relation  targetrel = pstate->p_target_relation;
    RangeTblEntry *exclRte;

    exclNSItem = addRangeTableEntryForRelation(pstate,
                           targetrel,
                           RowExclusiveLock,
                           makeAlias("excluded", NIL),
                           false, false);
    exclRte = exclNSItem->p_rte;
    exclRelIndex = exclNSItem->p_rtindex;

    /*
     * relkind is set to composite to signal that we're not dealing with
     * an actual relation, and no permission checks are required on it.
     * (We'll check the actual target relation, instead.)
     */
    exclRte->relkind = RELKIND_COMPOSITE_TYPE;

    /* Create EXCLUDED rel's targetlist for use by EXPLAIN */
    exclRelTlist = BuildOnConflictExcludedTargetlist(targetrel,
                             exclRelIndex);
  }

  /* Process the arbiter clause, ON CONFLICT ON (...) */
  transformOnConflictArbiter(pstate, onConflictClause, &arbiterElems,
                 &arbiterWhere, &arbiterConstraint);

  /* Process DO SELECT/UPDATE */
  if (onConflictClause->action == ONCONFLICT_UPDATE ||
    onConflictClause->action == ONCONFLICT_SELECT)
  {
    /*
     * Add the EXCLUDED pseudo relation to the query namespace, making it
     * available in SET and WHERE subexpressions.
     */
    addNSItemToQuery(pstate, exclNSItem, false, true, true);

    /* Process the UPDATE SET clause */
    if (onConflictClause->action == ONCONFLICT_UPDATE)
      onConflictSet =
        transformUpdateTargetList(pstate, onConflictClause->targetList, NULL);

    /* Process the SELECT/UPDATE WHERE clause */
    onConflictWhere = transformWhereClause(pstate,
                         onConflictClause->whereClause,
                         EXPR_KIND_WHERE, "WHERE");

    /*
     * Remove the EXCLUDED pseudo relation from the query namespace, since
     * it's not supposed to be available in RETURNING.  (Maybe someday we
     * could allow that, and drop this step.)
     */
    Assert((ParseNamespaceItem *) llast(pstate->p_namespace) == exclNSItem);
    pstate->p_namespace = list_delete_last(pstate->p_namespace);
  }

  /* Finally, build ON CONFLICT DO [NOTHING | SELECT | UPDATE] expression */
  result = makeNode(OnConflictExpr);

  result->action = onConflictClause->action;
  result->arbiterElems = arbiterElems;
  result->arbiterWhere = arbiterWhere;
  result->constraint = arbiterConstraint;
  result->lockStrength = onConflictClause->lockStrength;
  result->onConflictSet = onConflictSet;
  result->onConflictWhere = onConflictWhere;
  result->exclRelIndex = exclRelIndex;
  result->exclRelTlist = exclRelTlist;

  return result;
}

/*
 * transformForPortionOfClause
 *
 *    Transforms a ForPortionOfClause in an UPDATE/DELETE statement.
 *
 *    - Look up the range/period requested.
 *    - Build a compatible range value from the FROM and TO expressions.
 *    - Build an "overlaps" expression for filtering, used later by the
 *    rewriter.
 *    - For UPDATEs, build an "intersects" expression the rewriter can add
 *    to the targetList to change the temporal bounds.
 */
static ForPortionOfExpr *
transformForPortionOfClause(ParseState *pstate,
              int rtindex,
              const ForPortionOfClause *forPortionOf,
              const Node *whereClause,
              bool isUpdate)
{
  Relation  targetrel = pstate->p_target_relation;
  int     range_attno = InvalidAttrNumber;
  Form_pg_attribute attr;
  Oid     attbasetype;
  Oid     opclass;
  Oid     opfamily;
  Oid     opcintype;
  Oid     funcid = InvalidOid;
  StrategyNumber strat;
  Oid     opid;
  OpExpr     *op;
  ForPortionOfExpr *result;
  Var      *rangeVar;

  /* disallow FOR PORTION OF ... WHERE CURRENT OF */
  if (whereClause && IsA(whereClause, CurrentOfExpr))
    ereport(ERROR,
        errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        errmsg("WHERE CURRENT OF with FOR PORTION OF is not implemented"));

  result = makeNode(ForPortionOfExpr);

  /* Look up the FOR PORTION OF name requested. */
  range_attno = attnameAttNum(targetrel, forPortionOf->range_name, false);
  if (range_attno == InvalidAttrNumber)
    ereport(ERROR,
        (errcode(ERRCODE_UNDEFINED_COLUMN),
         errmsg("column \"%s\" of relation \"%s\" does not exist",
            forPortionOf->range_name,
            RelationGetRelationName(targetrel)),
         parser_errposition(pstate, forPortionOf->location)));
  attr = TupleDescAttr(targetrel->rd_att, range_attno - 1);

  attbasetype = getBaseType(attr->atttypid);

  rangeVar = makeVar(rtindex,
             range_attno,
             attr->atttypid,
             attr->atttypmod,
             attr->attcollation,
             0);
  rangeVar->location = forPortionOf->location;
  result->rangeVar = rangeVar;

  /* Require SELECT privilege on the application-time column. */
  markVarForSelectPriv(pstate, rangeVar);

  /*
   * Use the basetype for the target, which shouldn't be required to follow
   * domain rules. The table's column type is in the Var if we need it.
   */
  result->rangeType = attbasetype;
  result->isDomain = attbasetype != attr->atttypid;

  if (forPortionOf->target)
  {
    Oid     declared_target_type = attbasetype;
    Oid     actual_target_type;

    /*
     * We were already given an expression for the target, so we don't
     * have to build anything. We still have to make sure we got the right
     * type. NULL will be caught be the executor.
     */

    result->targetRange = transformExpr(pstate,
                      forPortionOf->target,
                      EXPR_KIND_FOR_PORTION);

    actual_target_type = exprType(result->targetRange);

    if (!can_coerce_type(1, &actual_target_type, &declared_target_type, COERCION_IMPLICIT))
      ereport(ERROR,
          (errcode(ERRCODE_DATATYPE_MISMATCH),
           errmsg("could not coerce FOR PORTION OF target from %s to %s",
              format_type_be(actual_target_type),
              format_type_be(declared_target_type)),
           parser_errposition(pstate, exprLocation(forPortionOf->target))));

    result->targetRange = coerce_type(pstate,
                      result->targetRange,
                      actual_target_type,
                      declared_target_type,
                      -1,
                      COERCION_IMPLICIT,
                      COERCE_IMPLICIT_CAST,
                      exprLocation(forPortionOf->target));

    /*
     * XXX: For now we only support ranges and multiranges, so we fail on
     * anything else.
     */
    if (!type_is_range(attbasetype) && !type_is_multirange(attbasetype))
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
           errmsg("column \"%s\" of relation \"%s\" is not a range or multirange type",
              forPortionOf->range_name,
              RelationGetRelationName(targetrel)),
           parser_errposition(pstate, forPortionOf->location)));

  }
  else
  {
    Oid     rngsubtype;
    Oid     declared_arg_types[2];
    Oid     actual_arg_types[2];
    List     *args;

    /*
     * Make sure it's a range column. XXX: We could support this syntax on
     * multirange columns too, if we just built a one-range multirange
     * from the FROM/TO phrases.
     */
    if (!type_is_range(attbasetype))
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
           errmsg("column \"%s\" of relation \"%s\" is not a range type",
              forPortionOf->range_name,
              RelationGetRelationName(targetrel)),
           parser_errposition(pstate, forPortionOf->location)));

    rngsubtype = get_range_subtype(attbasetype);
    declared_arg_types[0] = rngsubtype;
    declared_arg_types[1] = rngsubtype;

    /*
     * Build a range from the FROM ... TO ... bounds. This should give a
     * constant result, so we accept functions like NOW() but not column
     * references, subqueries, etc.
     */
    result->targetFrom = transformExpr(pstate,
                       forPortionOf->target_start,
                       EXPR_KIND_FOR_PORTION);
    result->targetTo = transformExpr(pstate,
                     forPortionOf->target_end,
                     EXPR_KIND_FOR_PORTION);
    actual_arg_types[0] = exprType(result->targetFrom);
    actual_arg_types[1] = exprType(result->targetTo);
    args = list_make2(copyObject(result->targetFrom),
              copyObject(result->targetTo));

    /*
     * Check the bound types separately, for better error message and
     * location
     */
    if (!can_coerce_type(1, actual_arg_types, declared_arg_types, COERCION_IMPLICIT))
      ereport(ERROR,
          (errcode(ERRCODE_DATATYPE_MISMATCH),
           errmsg("could not coerce FOR PORTION OF %s bound from %s to %s",
              "FROM",
              format_type_be(actual_arg_types[0]),
              format_type_be(declared_arg_types[0])),
           parser_errposition(pstate, exprLocation(forPortionOf->target_start))));
    if (!can_coerce_type(1, &actual_arg_types[1], &declared_arg_types[1], COERCION_IMPLICIT))
      ereport(ERROR,
          (errcode(ERRCODE_DATATYPE_MISMATCH),
           errmsg("could not coerce FOR PORTION OF %s bound from %s to %s",
              "TO",
              format_type_be(actual_arg_types[1]),
              format_type_be(declared_arg_types[1])),
           parser_errposition(pstate, exprLocation(forPortionOf->target_end))));

    make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);
    result->targetRange = (Node *) makeFuncExpr(get_range_constructor2(attbasetype),
                          attbasetype,
                          args,
                          InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL);
  }

  /*
   * Build overlapsExpr to use as an extra qual. This means we only hit rows
   * matching the FROM & TO bounds. We must look up the overlaps operator
   * (usually "&&").
   */
  opclass = GetDefaultOpClass(attr->atttypid, GIST_AM_OID);
  if (!OidIsValid(opclass))
    ereport(ERROR,
        (errcode(ERRCODE_UNDEFINED_OBJECT),
         errmsg("data type %s has no default operator class for access method \"%s\"",
            format_type_be(attr->atttypid), "gist"),
         errhint("You must define a default operator class for the data type.")));

  /* Look up the operators and functions we need. */
  GetOperatorFromCompareType(opclass, InvalidOid, COMPARE_OVERLAP, &opid, &strat);
  op = makeNode(OpExpr);
  op->opno = opid;
  op->opfuncid = get_opcode(opid);
  op->opresulttype = BOOLOID;
  op->args = list_make2(copyObject(rangeVar), copyObject(result->targetRange));
  result->overlapsExpr = (Node *) op;

  /*
   * Look up the without_portion func. This computes the bounds of temporal
   * leftovers.
   *
   * XXX: Find a more extensible way to look up the function, permitting
   * user-defined types. An opclass support function doesn't make sense,
   * since there is no index involved. Perhaps a type support function.
   */
  if (get_opclass_opfamily_and_input_type(opclass, &opfamily, &opcintype))
    switch (opcintype)
    {
      case ANYRANGEOID:
        result->withoutPortionProc = F_RANGE_MINUS_MULTI;
        break;
      case ANYMULTIRANGEOID:
        result->withoutPortionProc = F_MULTIRANGE_MINUS_MULTI;
        break;
      default:
        elog(ERROR, "unexpected opcintype: %u", opcintype);
    }
  else
    elog(ERROR, "unexpected opclass: %u", opclass);

  if (isUpdate)
  {
    /*
     * Now make sure we update the start/end time of the record. For a
     * range col (r) this is `r = r * targetRange` (where * is the
     * intersect operator).
     */
    Oid     intersectoperoid;
    List     *funcArgs;
    Node     *rangeTLEExpr;
    TargetEntry *tle;
    RTEPermissionInfo *target_perminfo = pstate->p_target_nsitem->p_perminfo;

    /*
     * Whatever operator is used for intersect by temporal foreign keys,
     * we can use its backing procedure for intersects in FOR PORTION OF.
     * XXX: Share code with FindFKPeriodOpers?
     */
    switch (opcintype)
    {
      case ANYRANGEOID:
        intersectoperoid = OID_RANGE_INTERSECT_RANGE_OP;
        break;
      case ANYMULTIRANGEOID:
        intersectoperoid = OID_MULTIRANGE_INTERSECT_MULTIRANGE_OP;
        break;
      default:
        elog(ERROR, "unexpected opcintype: %u", opcintype);
    }
    funcid = get_opcode(intersectoperoid);
    if (!OidIsValid(funcid))
      ereport(ERROR,
          errcode(ERRCODE_UNDEFINED_OBJECT),
          errmsg("could not identify an intersect function for type %s",
               format_type_be(opcintype)));

    funcArgs = list_make2(copyObject(rangeVar),
                copyObject(result->targetRange));
    rangeTLEExpr = (Node *) makeFuncExpr(funcid, attbasetype, funcArgs,
                       InvalidOid, InvalidOid,
                       COERCE_EXPLICIT_CALL);

    /*
     * Coerce to domain if necessary. If we skip this, we will allow
     * updating to forbidden values.
     */
    rangeTLEExpr = coerce_type(pstate,
                   rangeTLEExpr,
                   attbasetype,
                   attr->atttypid,
                   -1,
                   COERCION_IMPLICIT,
                   COERCE_IMPLICIT_CAST,
                   exprLocation(forPortionOf->target));

    /* Make a TLE to set the range column */
    result->rangeTargetList = NIL;
    tle = makeTargetEntry((Expr *) rangeTLEExpr, range_attno,
                forPortionOf->range_name, false);
    result->rangeTargetList = lappend(result->rangeTargetList, tle);

    /* Mark the range column as requiring update permissions */
    target_perminfo->updatedCols = bms_add_member(target_perminfo->updatedCols,
                            range_attno - FirstLowInvalidHeapAttributeNumber);
  }
  else
    result->rangeTargetList = NIL;

  result->location = forPortionOf->location;
  result->targetLocation = forPortionOf->target_location;

  return result;
}

/*
 * BuildOnConflictExcludedTargetlist
 *    Create target list for the EXCLUDED pseudo-relation of ON CONFLICT,
 *    representing the columns of targetrel with varno exclRelIndex.
 *
 * Note: Exported for use in the rewriter.
 */
List *
BuildOnConflictExcludedTargetlist(Relation targetrel,
                  Index exclRelIndex)
{
  List     *result = NIL;
  int     attno;
  Var      *var;
  TargetEntry *te;

  /*
   * Note that resnos of the tlist must correspond to attnos of the
   * underlying relation, hence we need entries for dropped columns too.
   */
  for (attno = 0; attno < RelationGetNumberOfAttributes(targetrel); attno++)
  {
    Form_pg_attribute attr = TupleDescAttr(targetrel->rd_att, attno);
    char     *name;

    if (attr->attisdropped)
    {
      /*
       * can't use atttypid here, but it doesn't really matter what type
       * the Const claims to be.
       */
      var = (Var *) makeNullConst(INT4OID, -1, InvalidOid);
      name = NULL;
    }
    else
    {
      var = makeVar(exclRelIndex, attno + 1,
              attr->atttypid, attr->atttypmod,
              attr->attcollation,
              0);
      name = pstrdup(NameStr(attr->attname));
    }

    te = makeTargetEntry((Expr *) var,
               attno + 1,
               name,
               false);

    result = lappend(result, te);
  }

  /*
   * Add a whole-row-Var entry to support references to "EXCLUDED.*".  Like
   * the other entries in the EXCLUDED tlist, its resno must match the Var's
   * varattno, else the wrong things happen while resolving references in
   * setrefs.c.  This is against normal conventions for targetlists, but
   * it's okay since we don't use this as a real tlist.
   */
  var = makeVar(exclRelIndex, InvalidAttrNumber,
          targetrel->rd_rel->reltype,
          -1, InvalidOid, 0);
  te = makeTargetEntry((Expr *) var, InvalidAttrNumber, NULL, true);
  result = lappend(result, te);

  return result;
}


/*
 * count_rowexpr_columns -
 *    get number of columns contained in a ROW() expression;
 *    return -1 if expression isn't a RowExpr or a Var referencing one.
 *
 * This is currently used only for hint purposes, so we aren't terribly
 * tense about recognizing all possible cases.  The Var case is interesting
 * because that's what we'll get in the INSERT ... SELECT (...) case.
 */
static int
count_rowexpr_columns(ParseState *pstate, Node *expr)
{
  if (expr == NULL)
    return -1;
  if (IsA(expr, RowExpr))
    return list_length(((RowExpr *) expr)->args);
  if (IsA(expr, Var))
  {
    Var      *var = (Var *) expr;
    AttrNumber  attnum = var->varattno;

    if (attnum > 0 && var->vartype == RECORDOID)
    {
      RangeTblEntry *rte;

      rte = GetRTEByRangeTablePosn(pstate, var->varno, var->varlevelsup);
      if (rte->rtekind == RTE_SUBQUERY)
      {
        /* Subselect-in-FROM: examine sub-select's output expr */
        TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList,
                          attnum);

        if (ste == NULL || ste->resjunk)
          return -1;
        expr = (Node *) ste->expr;
        if (IsA(expr, RowExpr))
          return list_length(((RowExpr *) expr)->args);
      }
    }
  }
  return -1;
}


/*
 * transformSelectStmt -
 *    transforms a Select Statement
 *
 * This function is also used to transform the source expression of a
 * PLAssignStmt.  In that usage, passthru is non-NULL and we need to
 * call transformPLAssignStmtTarget after the initial transformation of the
 * SELECT's targetlist.  (We could generalize this into an arbitrary callback
 * function, but for now that would just be more notation with no benefit.)
 * All the rest is the same as a regular SelectStmt.
 *
 * Note: this covers only cases with no set operations and no VALUES lists;
 * see below for the other cases.
 */
static Query *
transformSelectStmt(ParseState *pstate, SelectStmt *stmt,
          SelectStmtPassthrough *passthru)
{
  Query    *qry = makeNode(Query);
  Node     *qual;
  ListCell   *l;

  qry->commandType = CMD_SELECT;

  /* process the WITH clause independently of all else */
  if (stmt->withClause)
  {
    qry->hasRecursive = stmt->withClause->recursive;
    qry->cteList = transformWithClause(pstate, stmt->withClause);
    qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
  }

  /* Complain if we get called from someplace where INTO is not allowed */
  if (stmt->intoClause)
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg("SELECT ... INTO is not allowed here"),
         parser_errposition(pstate,
                  exprLocation((Node *) stmt->intoClause))));

  /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
  pstate->p_locking_clause = stmt->lockingClause;

  /* make WINDOW info available for window functions, too */
  pstate->p_windowdefs = stmt->windowClause;

  /* process the FROM clause */
  transformFromClause(pstate, stmt->fromClause);

  /* transform targetlist */
  qry->targetList = transformTargetList(pstate, stmt->targetList,
                      EXPR_KIND_SELECT_TARGET);

  /*
   * If we're within a PLAssignStmt, do further transformation of the
   * targetlist; that has to happen before we consider sorting or grouping.
   * Otherwise, mark column origins (which are useless in a PLAssignStmt).
   */
  if (passthru)
    qry->targetList = transformPLAssignStmtTarget(pstate, qry->targetList,
                            passthru);
  else
    markTargetListOrigins(pstate, qry->targetList);

  /* transform WHERE */
  qual = transformWhereClause(pstate, stmt->whereClause,
                EXPR_KIND_WHERE, "WHERE");

  /* initial processing of HAVING clause is much like WHERE clause */
  qry->havingQual = transformWhereClause(pstate, stmt->havingClause,
                       EXPR_KIND_HAVING, "HAVING");

  /*
   * Transform sorting/grouping stuff.  Do ORDER BY first because both
   * transformGroupClause and transformDistinctClause need the results. Note
   * that these functions can also change the targetList, so it's passed to
   * them by reference.
   */
  qry->sortClause = transformSortClause(pstate,
                      stmt->sortClause,
                      &qry->targetList,
                      EXPR_KIND_ORDER_BY,
                      false /* allow SQL92 rules */ );

  qry->groupClause = transformGroupClause(pstate,
                      stmt->groupClause,
                      &qry->groupingSets,
                      &qry->targetList,
                      qry->sortClause,
                      EXPR_KIND_GROUP_BY,
                      false /* allow SQL92 rules */ );
  qry->groupDistinct = stmt->groupDistinct;

  if (stmt->distinctClause == NIL)
  {
    qry->distinctClause = NIL;
    qry->hasDistinctOn = false;
  }
  else if (linitial(stmt->distinctClause) == NULL)
  {
    /* We had SELECT DISTINCT */
    qry->distinctClause = transformDistinctClause(pstate,
                            &qry->targetList,
                            qry->sortClause,
                            false);
    qry->hasDistinctOn = false;
  }
  else
  {
    /* We had SELECT DISTINCT ON */
    qry->distinctClause = transformDistinctOnClause(pstate,
                            stmt->distinctClause,
                            &qry->targetList,
                            qry->sortClause);
    qry->hasDistinctOn = true;
  }

  /* transform LIMIT */
  qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
                      EXPR_KIND_OFFSET, "OFFSET",
                      stmt->limitOption);
  qry->limitCount = transformLimitClause(pstate, stmt->limitCount,
                       EXPR_KIND_LIMIT, "LIMIT",
                       stmt->limitOption);
  qry->limitOption = stmt->limitOption;

  /* transform window clauses after we have seen all window functions */
  qry->windowClause = transformWindowDefinitions(pstate,
                           pstate->p_windowdefs,
                           &qry->targetList);

  /* resolve any still-unresolved output columns as being type text */
  if (pstate->p_resolve_unknowns)
    resolveTargetListUnknowns(pstate, qry->targetList);

  qry->rtable = pstate->p_rtable;
  qry->rteperminfos = pstate->p_rteperminfos;
  qry->jointree = makeFromExpr(pstate->p_joinlist, qual);

  qry->hasSubLinks = pstate->p_hasSubLinks;
  qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
  qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
  qry->hasAggs = pstate->p_hasAggs;

  foreach(l, stmt->lockingClause)
  {
    transformLockingClause(pstate, qry,
                 (LockingClause *) lfirst(l), false);
  }

  assign_query_collations(pstate, qry);

  /* this must be done after collations, for reliable comparison of exprs */
  if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual)
    parseCheckAggregates(pstate, qry);

  return qry;
}

/*
 * transformValuesClause -
 *    transforms a VALUES clause that's being used as a standalone SELECT
 *
 * We build a Query containing a VALUES RTE, rather as if one had written
 *      SELECT * FROM (VALUES ...) AS "*VALUES*"
 */
static Query *
transformValuesClause(ParseState *pstate, SelectStmt *stmt)
{
  Query    *qry = makeNode(Query);
  List     *exprsLists = NIL;
  List     *coltypes = NIL;
  List     *coltypmods = NIL;
  List     *colcollations = NIL;
  List    **colexprs = NULL;
  int     sublist_length = -1;
  bool    lateral = false;
  ParseNamespaceItem *nsitem;
  ListCell   *lc;
  ListCell   *lc2;
  int     i;

  qry->commandType = CMD_SELECT;

  /* Most SELECT stuff doesn't apply in a VALUES clause */
  Assert(stmt->distinctClause == NIL);
  Assert(stmt->intoClause == NULL);
  Assert(stmt->targetList == NIL);
  Assert(stmt->fromClause == NIL);
  Assert(stmt->whereClause == NULL);
  Assert(stmt->groupClause == NIL);
  Assert(stmt->havingClause == NULL);
  Assert(stmt->windowClause == NIL);
  Assert(stmt->op == SETOP_NONE);

  /* process the WITH clause independently of all else */
  if (stmt->withClause)
  {
    qry->hasRecursive = stmt->withClause->recursive;
    qry->cteList = transformWithClause(pstate, stmt->withClause);
    qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
  }

  /*
   * For each row of VALUES, transform the raw expressions.
   *
   * Note that the intermediate representation we build is column-organized
   * not row-organized.  That simplifies the type and collation processing
   * below.
   */
  foreach(lc, stmt->valuesLists)
  {
    List     *sublist = (List *) lfirst(lc);

    /*
     * Do basic expression transformation (same as a ROW() expr, but here
     * we disallow SetToDefault)
     */
    sublist = transformExpressionList(pstate, sublist,
                      EXPR_KIND_VALUES, false);

    /*
     * All the sublists must be the same length, *after* transformation
     * (which might expand '*' into multiple items).  The VALUES RTE can't
     * handle anything different.
     */
    if (sublist_length < 0)
    {
      /* Remember post-transformation length of first sublist */
      sublist_length = list_length(sublist);
      /* and allocate array for per-column lists */
      colexprs = (List **) palloc0(sublist_length * sizeof(List *));
    }
    else if (sublist_length != list_length(sublist))
    {
      ereport(ERROR,
          (errcode(ERRCODE_SYNTAX_ERROR),
           errmsg("VALUES lists must all be the same length"),
           parser_errposition(pstate,
                    exprLocation((Node *) sublist))));
    }

    /* Build per-column expression lists */
    i = 0;
    foreach(lc2, sublist)
    {
      Node     *col = (Node *) lfirst(lc2);

      colexprs[i] = lappend(colexprs[i], col);
      i++;
    }

    /* Release sub-list's cells to save memory */
    list_free(sublist);

    /* Prepare an exprsLists element for this row */
    exprsLists = lappend(exprsLists, NIL);
  }

  /*
   * Now resolve the common types of the columns, and coerce everything to
   * those types.  Then identify the common typmod and common collation, if
   * any, of each column.
   *
   * We must do collation processing now because (1) assign_query_collations
   * doesn't process rangetable entries, and (2) we need to label the VALUES
   * RTE with column collations for use in the outer query.  We don't
   * consider conflict of implicit collations to be an error here; instead
   * the column will just show InvalidOid as its collation, and you'll get a
   * failure later if that results in failure to resolve a collation.
   *
   * Note we modify the per-column expression lists in-place.
   */
  for (i = 0; i < sublist_length; i++)
  {
    Oid     coltype;
    int32   coltypmod;
    Oid     colcoll;

    coltype = select_common_type(pstate, colexprs[i], "VALUES", NULL);

    foreach(lc, colexprs[i])
    {
      Node     *col = (Node *) lfirst(lc);

      col = coerce_to_common_type(pstate, col, coltype, "VALUES");
      lfirst(lc) = col;
    }

    coltypmod = select_common_typmod(pstate, colexprs[i], coltype);
    colcoll = select_common_collation(pstate, colexprs[i], true);

    coltypes = lappend_oid(coltypes, coltype);
    coltypmods = lappend_int(coltypmods, coltypmod);
    colcollations = lappend_oid(colcollations, colcoll);
  }

  /*
   * Finally, rearrange the coerced expressions into row-organized lists.
   */
  for (i = 0; i < sublist_length; i++)
  {
    forboth(lc, colexprs[i], lc2, exprsLists)
    {
      Node     *col = (Node *) lfirst(lc);
      List     *sublist = lfirst(lc2);

      sublist = lappend(sublist, col);
      lfirst(lc2) = sublist;
    }
    list_free(colexprs[i]);
  }

  /*
   * Ordinarily there can't be any current-level Vars in the expression
   * lists, because the namespace was empty ... but if we're inside CREATE
   * RULE, then NEW/OLD references might appear.  In that case we have to
   * mark the VALUES RTE as LATERAL.
   */
  if (pstate->p_rtable != NIL &&
    contain_vars_of_level((Node *) exprsLists, 0))
    lateral = true;

  /*
   * Generate the VALUES RTE
   */
  nsitem = addRangeTableEntryForValues(pstate, exprsLists,
                     coltypes, coltypmods, colcollations,
                     NULL, lateral, true);
  addNSItemToQuery(pstate, nsitem, true, true, true);

  /*
   * Generate a targetlist as though expanding "*"
   */
  Assert(pstate->p_next_resno == 1);
  qry->targetList = expandNSItemAttrs(pstate, nsitem, 0, true, -1);

  /*
   * The grammar allows attaching ORDER BY, LIMIT, and FOR UPDATE to a
   * VALUES, so cope.
   */
  qry->sortClause = transformSortClause(pstate,
                      stmt->sortClause,
                      &qry->targetList,
                      EXPR_KIND_ORDER_BY,
                      false /* allow SQL92 rules */ );

  qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
                      EXPR_KIND_OFFSET, "OFFSET",
                      stmt->limitOption);
  qry->limitCount = transformLimitClause(pstate, stmt->limitCount,
                       EXPR_KIND_LIMIT, "LIMIT",
                       stmt->limitOption);
  qry->limitOption = stmt->limitOption;

  if (stmt->lockingClause)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s cannot be applied to VALUES",
            LCS_asString(((LockingClause *)
                    linitial(stmt->lockingClause))->strength))));

  qry->rtable = pstate->p_rtable;
  qry->rteperminfos = pstate->p_rteperminfos;
  qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);

  qry->hasSubLinks = pstate->p_hasSubLinks;

  assign_query_collations(pstate, qry);

  return qry;
}

/*
 * transformSetOperationStmt -
 *    transforms a set-operations tree
 *
 * A set-operation tree is just a SELECT, but with UNION/INTERSECT/EXCEPT
 * structure to it.  We must transform each leaf SELECT and build up a top-
 * level Query that contains the leaf SELECTs as subqueries in its rangetable.
 * The tree of set operations is converted into the setOperations field of
 * the top-level Query.
 */
static Query *
transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt)
{
  Query    *qry = makeNode(Query);
  SelectStmt *leftmostSelect;
  int     leftmostRTI;
  Query    *leftmostQuery;
  SetOperationStmt *sostmt;
  List     *sortClause;
  Node     *limitOffset;
  Node     *limitCount;
  List     *lockingClause;
  WithClause *withClause;
  Node     *node;
  ListCell   *left_tlist,
         *lct,
         *lcm,
         *lcc,
         *l;
  List     *targetvars,
         *targetnames,
         *sv_namespace;
  int     sv_rtable_length;
  ParseNamespaceItem *jnsitem;
  ParseNamespaceColumn *sortnscolumns;
  int     sortcolindex;
  int     tllen;

  qry->commandType = CMD_SELECT;

  /*
   * Find leftmost leaf SelectStmt.  We currently only need to do this in
   * order to deliver a suitable error message if there's an INTO clause
   * there, implying the set-op tree is in a context that doesn't allow
   * INTO.  (transformSetOperationTree would throw error anyway, but it
   * seems worth the trouble to throw a different error for non-leftmost
   * INTO, so we produce that error in transformSetOperationTree.)
   */
  leftmostSelect = stmt->larg;
  while (leftmostSelect && leftmostSelect->op != SETOP_NONE)
    leftmostSelect = leftmostSelect->larg;
  Assert(leftmostSelect && IsA(leftmostSelect, SelectStmt) &&
       leftmostSelect->larg == NULL);
  if (leftmostSelect->intoClause)
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg("SELECT ... INTO is not allowed here"),
         parser_errposition(pstate,
                  exprLocation((Node *) leftmostSelect->intoClause))));

  /*
   * We need to extract ORDER BY and other top-level clauses here and not
   * let transformSetOperationTree() see them --- else it'll just recurse
   * right back here!
   */
  sortClause = stmt->sortClause;
  limitOffset = stmt->limitOffset;
  limitCount = stmt->limitCount;
  lockingClause = stmt->lockingClause;
  withClause = stmt->withClause;

  stmt->sortClause = NIL;
  stmt->limitOffset = NULL;
  stmt->limitCount = NULL;
  stmt->lockingClause = NIL;
  stmt->withClause = NULL;

  /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
  if (lockingClause)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
            LCS_asString(((LockingClause *)
                    linitial(lockingClause))->strength))));

  /* Process the WITH clause independently of all else */
  if (withClause)
  {
    qry->hasRecursive = withClause->recursive;
    qry->cteList = transformWithClause(pstate, withClause);
    qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
  }

  /*
   * Recursively transform the components of the tree.
   */
  sostmt = castNode(SetOperationStmt,
            transformSetOperationTree(pstate, stmt, true, NULL));
  Assert(sostmt);
  qry->setOperations = (Node *) sostmt;

  /*
   * Re-find leftmost SELECT (now it's a sub-query in rangetable)
   */
  node = sostmt->larg;
  while (node && IsA(node, SetOperationStmt))
    node = ((SetOperationStmt *) node)->larg;
  Assert(node && IsA(node, RangeTblRef));
  leftmostRTI = ((RangeTblRef *) node)->rtindex;
  leftmostQuery = rt_fetch(leftmostRTI, pstate->p_rtable)->subquery;
  Assert(leftmostQuery != NULL);

  /*
   * Generate dummy targetlist for outer query using column names of
   * leftmost select and common datatypes/collations of topmost set
   * operation.  Also make lists of the dummy vars and their names for use
   * in parsing ORDER BY.
   *
   * Note: we use leftmostRTI as the varno of the dummy variables. It
   * shouldn't matter too much which RT index they have, as long as they
   * have one that corresponds to a real RT entry; else funny things may
   * happen when the tree is mashed by rule rewriting.
   */
  qry->targetList = NIL;
  targetvars = NIL;
  targetnames = NIL;
  sortnscolumns = (ParseNamespaceColumn *)
    palloc0(list_length(sostmt->colTypes) * sizeof(ParseNamespaceColumn));
  sortcolindex = 0;

  forfour(lct, sostmt->colTypes,
      lcm, sostmt->colTypmods,
      lcc, sostmt->colCollations,
      left_tlist, leftmostQuery->targetList)
  {
    Oid     colType = lfirst_oid(lct);
    int32   colTypmod = lfirst_int(lcm);
    Oid     colCollation = lfirst_oid(lcc);
    TargetEntry *lefttle = (TargetEntry *) lfirst(left_tlist);
    char     *colName;
    TargetEntry *tle;
    Var      *var;

    Assert(!lefttle->resjunk);
    colName = pstrdup(lefttle->resname);
    var = makeVar(leftmostRTI,
            lefttle->resno,
            colType,
            colTypmod,
            colCollation,
            0);
    var->location = exprLocation((Node *) lefttle->expr);
    tle = makeTargetEntry((Expr *) var,
                (AttrNumber) pstate->p_next_resno++,
                colName,
                false);
    qry->targetList = lappend(qry->targetList, tle);
    targetvars = lappend(targetvars, var);
    targetnames = lappend(targetnames, makeString(colName));
    sortnscolumns[sortcolindex].p_varno = leftmostRTI;
    sortnscolumns[sortcolindex].p_varattno = lefttle->resno;
    sortnscolumns[sortcolindex].p_vartype = colType;
    sortnscolumns[sortcolindex].p_vartypmod = colTypmod;
    sortnscolumns[sortcolindex].p_varcollid = colCollation;
    sortnscolumns[sortcolindex].p_varnosyn = leftmostRTI;
    sortnscolumns[sortcolindex].p_varattnosyn = lefttle->resno;
    sortcolindex++;
  }

  /*
   * As a first step towards supporting sort clauses that are expressions
   * using the output columns, generate a namespace entry that makes the
   * output columns visible.  A Join RTE node is handy for this, since we
   * can easily control the Vars generated upon matches.
   *
   * Note: we don't yet do anything useful with such cases, but at least
   * "ORDER BY upper(foo)" will draw the right error message rather than
   * "foo not found".
   */
  sv_rtable_length = list_length(pstate->p_rtable);

  jnsitem = addRangeTableEntryForJoin(pstate,
                    targetnames,
                    sortnscolumns,
                    JOIN_INNER,
                    0,
                    targetvars,
                    NIL,
                    NIL,
                    NULL,
                    NULL,
                    false);

  sv_namespace = pstate->p_namespace;
  pstate->p_namespace = NIL;

  /* add jnsitem to column namespace only */
  addNSItemToQuery(pstate, jnsitem, false, false, true);

  /*
   * For now, we don't support resjunk sort clauses on the output of a
   * setOperation tree --- you can only use the SQL92-spec options of
   * selecting an output column by name or number.  Enforce by checking that
   * transformSortClause doesn't add any items to tlist.  Note, if changing
   * this, add_setop_child_rel_equivalences() will need to be updated.
   */
  tllen = list_length(qry->targetList);

  qry->sortClause = transformSortClause(pstate,
                      sortClause,
                      &qry->targetList,
                      EXPR_KIND_ORDER_BY,
                      false /* allow SQL92 rules */ );

  /* restore namespace, remove join RTE from rtable */
  pstate->p_namespace = sv_namespace;
  pstate->p_rtable = list_truncate(pstate->p_rtable, sv_rtable_length);

  if (tllen != list_length(qry->targetList))
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         errmsg("invalid UNION/INTERSECT/EXCEPT ORDER BY clause"),
         errdetail("Only result column names can be used, not expressions or functions."),
         errhint("Add the expression/function to every SELECT, or move the UNION into a FROM clause."),
         parser_errposition(pstate,
                  exprLocation(list_nth(qry->targetList, tllen)))));

  qry->limitOffset = transformLimitClause(pstate, limitOffset,
                      EXPR_KIND_OFFSET, "OFFSET",
                      stmt->limitOption);
  qry->limitCount = transformLimitClause(pstate, limitCount,
                       EXPR_KIND_LIMIT, "LIMIT",
                       stmt->limitOption);
  qry->limitOption = stmt->limitOption;

  qry->rtable = pstate->p_rtable;
  qry->rteperminfos = pstate->p_rteperminfos;
  qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);

  qry->hasSubLinks = pstate->p_hasSubLinks;
  qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
  qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
  qry->hasAggs = pstate->p_hasAggs;

  foreach(l, lockingClause)
  {
    transformLockingClause(pstate, qry,
                 (LockingClause *) lfirst(l), false);
  }

  assign_query_collations(pstate, qry);

  /* this must be done after collations, for reliable comparison of exprs */
  if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual)
    parseCheckAggregates(pstate, qry);

  return qry;
}

/*
 * Make a SortGroupClause node for a SetOperationStmt's groupClauses
 *
 * If require_hash is true, the caller is indicating that they need hash
 * support or they will fail.  So look extra hard for hash support.
 */
SortGroupClause *
makeSortGroupClauseForSetOp(Oid rescoltype, bool require_hash)
{
  SortGroupClause *grpcl = makeNode(SortGroupClause);
  Oid     sortop;
  Oid     eqop;
  bool    hashable;

  /* determine the eqop and optional sortop */
  get_sort_group_operators(rescoltype,
               false, true, false,
               &sortop, &eqop, NULL,
               &hashable);

  /*
   * The type cache doesn't believe that record is hashable (see
   * cache_record_field_properties()), but if the caller really needs hash
   * support, we can assume it does.  Worst case, if any components of the
   * record don't support hashing, we will fail at execution.
   */
  if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
    hashable = true;

  /* we don't have a tlist yet, so can't assign sortgrouprefs */
  grpcl->tleSortGroupRef = 0;
  grpcl->eqop = eqop;
  grpcl->sortop = sortop;
  grpcl->reverse_sort = false;  /* Sort-op is "less than", or InvalidOid */
  grpcl->nulls_first = false; /* OK with or without sortop */
  grpcl->hashable = hashable;

  return grpcl;
}

/*
 * transformSetOperationTree
 *    Recursively transform leaves and internal nodes of a set-op tree
 *
 * In addition to returning the transformed node, if targetlist isn't NULL
 * then we return a list of its non-resjunk TargetEntry nodes.  For a leaf
 * set-op node these are the actual targetlist entries; otherwise they are
 * dummy entries created to carry the type, typmod, collation, and location
 * (for error messages) of each output column of the set-op node.  This info
 * is needed only during the internal recursion of this function, so outside
 * callers pass NULL for targetlist.  Note: the reason for passing the
 * actual targetlist entries of a leaf node is so that upper levels can
 * replace UNKNOWN Consts with properly-coerced constants.
 */
static Node *
transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
              bool isTopLevel, List **targetlist)
{
  bool    isLeaf;

  Assert(stmt && IsA(stmt, SelectStmt));

  /* Guard against stack overflow due to overly complex set-expressions */
  check_stack_depth();

  /*
   * Validity-check both leaf and internal SELECTs for disallowed ops.
   */
  if (stmt->intoClause)
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg("INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT"),
         parser_errposition(pstate,
                  exprLocation((Node *) stmt->intoClause))));

  /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
  if (stmt->lockingClause)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
            LCS_asString(((LockingClause *)
                    linitial(stmt->lockingClause))->strength))));

  /*
   * If an internal node of a set-op tree has ORDER BY, LIMIT, FOR UPDATE,
   * or WITH clauses attached, we need to treat it like a leaf node to
   * generate an independent sub-Query tree.  Otherwise, it can be
   * represented by a SetOperationStmt node underneath the parent Query.
   */
  if (stmt->op == SETOP_NONE)
  {
    Assert(stmt->larg == NULL && stmt->rarg == NULL);
    isLeaf = true;
  }
  else
  {
    Assert(stmt->larg != NULL && stmt->rarg != NULL);
    if (stmt->sortClause || stmt->limitOffset || stmt->limitCount ||
      stmt->lockingClause || stmt->withClause)
      isLeaf = true;
    else
      isLeaf = false;
  }

  if (isLeaf)
  {
    /* Process leaf SELECT */
    Query    *selectQuery;
    ParseNamespaceItem *nsitem;
    RangeTblRef *rtr;

    /*
     * Transform SelectStmt into a Query.
     *
     * This works the same as SELECT transformation normally would, except
     * that we prevent resolving unknown-type outputs as TEXT.  This does
     * not change the subquery's semantics since if the column type
     * matters semantically, it would have been resolved to something else
     * anyway.  Doing this lets us resolve such outputs using
     * select_common_type(), below.
     *
     * Note: previously transformed sub-queries don't affect the parsing
     * of this sub-query, because they are not in the toplevel pstate's
     * namespace list.
     */
    selectQuery = parse_sub_analyze((Node *) stmt, pstate,
                    NULL, false, false);

    /*
     * Check for bogus references to Vars on the current query level (but
     * upper-level references are okay). Normally this can't happen
     * because the namespace will be empty, but it could happen if we are
     * inside a rule.
     */
    if (pstate->p_namespace)
    {
      if (contain_vars_of_level((Node *) selectQuery, 1))
        ereport(ERROR,
            (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
             errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
             parser_errposition(pstate,
                      locate_var_of_level((Node *) selectQuery, 1))));
    }

    /*
     * Extract a list of the non-junk TLEs for upper-level processing.
     */
    if (targetlist)
    {
      ListCell   *tl;

      *targetlist = NIL;
      foreach(tl, selectQuery->targetList)
      {
        TargetEntry *tle = (TargetEntry *) lfirst(tl);

        if (!tle->resjunk)
          *targetlist = lappend(*targetlist, tle);
      }
    }

    /*
     * Make the leaf query be a subquery in the top-level rangetable.
     */
    nsitem = addRangeTableEntryForSubquery(pstate,
                         selectQuery,
                         NULL,
                         false,
                         false);

    /*
     * Return a RangeTblRef to replace the SelectStmt in the set-op tree.
     */
    rtr = makeNode(RangeTblRef);
    rtr->rtindex = nsitem->p_rtindex;
    return (Node *) rtr;
  }
  else
  {
    /* Process an internal node (set operation node) */
    SetOperationStmt *op = makeNode(SetOperationStmt);
    List     *ltargetlist;
    List     *rtargetlist;
    const char *context;
    bool    recursive = (pstate->p_parent_cte &&
                 pstate->p_parent_cte->cterecursive);

    context = (stmt->op == SETOP_UNION ? "UNION" :
           (stmt->op == SETOP_INTERSECT ? "INTERSECT" :
          "EXCEPT"));

    op->op = stmt->op;
    op->all = stmt->all;

    /*
     * Recursively transform the left child node.
     */
    op->larg = transformSetOperationTree(pstate, stmt->larg,
                       false,
                       &ltargetlist);

    /*
     * If we are processing a recursive union query, now is the time to
     * examine the non-recursive term's output columns and mark the
     * containing CTE as having those result columns.  We should do this
     * only at the topmost setop of the CTE, of course.
     */
    if (isTopLevel && recursive)
      determineRecursiveColTypes(pstate, op->larg, ltargetlist);

    /*
     * Recursively transform the right child node.
     */
    op->rarg = transformSetOperationTree(pstate, stmt->rarg,
                       false,
                       &rtargetlist);

    constructSetOpTargetlist(pstate, op, ltargetlist, rtargetlist, targetlist,
                 context, recursive);

    return (Node *) op;
  }
}

/*
 * constructSetOpTargetlist
 *    Compute the types, typmods and collations of the columns in the target
 *    list of the given set operation.
 *
 * For every pair of columns in the targetlists of the children, compute the
 * common type, typmod, and collation representing the output (UNION) column.
 * If targetlist is not NULL, also build the dummy output targetlist
 * containing non-resjunk output columns.  The values are stored into the
 * given SetOperationStmt node.  context is a string for error messages
 * ("UNION" etc.).  recursive is true if it is a recursive union.
 */
void
constructSetOpTargetlist(ParseState *pstate, SetOperationStmt *op,
             const List *ltargetlist, const List *rtargetlist,
             List **targetlist, const char *context, bool recursive)
{
  ListCell   *ltl;
  ListCell   *rtl;

  /*
   * Verify that the two children have the same number of non-junk columns,
   * and determine the types of the merged output columns.
   */
  if (list_length(ltargetlist) != list_length(rtargetlist))
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg("each %s query must have the same number of columns",
            context),
         parser_errposition(pstate,
                  exprLocation((const Node *) rtargetlist))));

  if (targetlist)
    *targetlist = NIL;
  op->colTypes = NIL;
  op->colTypmods = NIL;
  op->colCollations = NIL;
  op->groupClauses = NIL;

  forboth(ltl, ltargetlist, rtl, rtargetlist)
  {
    TargetEntry *ltle = (TargetEntry *) lfirst(ltl);
    TargetEntry *rtle = (TargetEntry *) lfirst(rtl);
    Node     *lcolnode = (Node *) ltle->expr;
    Node     *rcolnode = (Node *) rtle->expr;
    Oid     lcoltype = exprType(lcolnode);
    Oid     rcoltype = exprType(rcolnode);
    Node     *bestexpr;
    int     bestlocation;
    Oid     rescoltype;
    int32   rescoltypmod;
    Oid     rescolcoll;

    /* select common type, same as CASE et al */
    rescoltype = select_common_type(pstate,
                    list_make2(lcolnode, rcolnode),
                    context,
                    &bestexpr);
    bestlocation = exprLocation(bestexpr);

    /*
     * Verify the coercions are actually possible.  If not, we'd fail
     * later anyway, but we want to fail now while we have sufficient
     * context to produce an error cursor position.
     *
     * For all non-UNKNOWN-type cases, we verify coercibility but we don't
     * modify the child's expression, for fear of changing the child
     * query's semantics.
     *
     * If a child expression is an UNKNOWN-type Const or Param, we want to
     * replace it with the coerced expression.  This can only happen when
     * the child is a leaf set-op node.  It's safe to replace the
     * expression because if the child query's semantics depended on the
     * type of this output column, it'd have already coerced the UNKNOWN
     * to something else.  We want to do this because (a) we want to
     * verify that a Const is valid for the target type, or resolve the
     * actual type of an UNKNOWN Param, and (b) we want to avoid
     * unnecessary discrepancies between the output type of the child
     * query and the resolved target type. Such a discrepancy would
     * disable optimization in the planner.
     *
     * If it's some other UNKNOWN-type node, eg a Var, we do nothing
     * (knowing that coerce_to_common_type would fail).  The planner is
     * sometimes able to fold an UNKNOWN Var to a constant before it has
     * to coerce the type, so failing now would just break cases that
     * might work.
     */
    if (lcoltype != UNKNOWNOID)
      lcolnode = coerce_to_common_type(pstate, lcolnode,
                       rescoltype, context);
    else if (IsA(lcolnode, Const) ||
         IsA(lcolnode, Param))
    {
      lcolnode = coerce_to_common_type(pstate, lcolnode,
                       rescoltype, context);
      ltle->expr = (Expr *) lcolnode;
    }

    if (rcoltype != UNKNOWNOID)
      rcolnode = coerce_to_common_type(pstate, rcolnode,
                       rescoltype, context);
    else if (IsA(rcolnode, Const) ||
         IsA(rcolnode, Param))
    {
      rcolnode = coerce_to_common_type(pstate, rcolnode,
                       rescoltype, context);
      rtle->expr = (Expr *) rcolnode;
    }

    rescoltypmod = select_common_typmod(pstate,
                      list_make2(lcolnode, rcolnode),
                      rescoltype);

    /*
     * Select common collation.  A common collation is required for all
     * set operators except UNION ALL; see SQL:2008 7.13 <query
     * expression> Syntax Rule 15c.  (If we fail to identify a common
     * collation for a UNION ALL column, the colCollations element will be
     * set to InvalidOid, which may result in a runtime error if something
     * at a higher query level wants to use the column's collation.)
     */
    rescolcoll = select_common_collation(pstate,
                       list_make2(lcolnode, rcolnode),
                       (op->op == SETOP_UNION && op->all));

    /* emit results */
    op->colTypes = lappend_oid(op->colTypes, rescoltype);
    op->colTypmods = lappend_int(op->colTypmods, rescoltypmod);
    op->colCollations = lappend_oid(op->colCollations, rescolcoll);

    /*
     * For all cases except UNION ALL, identify the grouping operators
     * (and, if available, sorting operators) that will be used to
     * eliminate duplicates.
     */
    if (op->op != SETOP_UNION || !op->all)
    {
      ParseCallbackState pcbstate;

      setup_parser_errposition_callback(&pcbstate, pstate,
                        bestlocation);

      /* If it's a recursive union, we need to require hashing support. */
      op->groupClauses = lappend(op->groupClauses,
                     makeSortGroupClauseForSetOp(rescoltype, recursive));

      cancel_parser_errposition_callback(&pcbstate);
    }

    /*
     * Construct a dummy tlist entry to return.  We use a SetToDefault
     * node for the expression, since it carries exactly the fields
     * needed, but any other expression node type would do as well.
     */
    if (targetlist)
    {
      SetToDefault *rescolnode = makeNode(SetToDefault);
      TargetEntry *restle;

      rescolnode->typeId = rescoltype;
      rescolnode->typeMod = rescoltypmod;
      rescolnode->collation = rescolcoll;
      rescolnode->location = bestlocation;
      restle = makeTargetEntry((Expr *) rescolnode,
                   0, /* no need to set resno */
                   NULL,
                   false);
      *targetlist = lappend(*targetlist, restle);
    }
  }
}

/*
 * Process the outputs of the non-recursive term of a recursive union
 * to set up the parent CTE's columns
 */
static void
determineRecursiveColTypes(ParseState *pstate, Node *larg, List *nrtargetlist)
{
  Node     *node;
  int     leftmostRTI;
  Query    *leftmostQuery;
  List     *targetList;
  ListCell   *left_tlist;
  ListCell   *nrtl;
  int     next_resno;

  /*
   * Find leftmost leaf SELECT
   */
  node = larg;
  while (node && IsA(node, SetOperationStmt))
    node = ((SetOperationStmt *) node)->larg;
  Assert(node && IsA(node, RangeTblRef));
  leftmostRTI = ((RangeTblRef *) node)->rtindex;
  leftmostQuery = rt_fetch(leftmostRTI, pstate->p_rtable)->subquery;
  Assert(leftmostQuery != NULL);

  /*
   * Generate dummy targetlist using column names of leftmost select and
   * dummy result expressions of the non-recursive term.
   */
  targetList = NIL;
  next_resno = 1;

  forboth(nrtl, nrtargetlist, left_tlist, leftmostQuery->targetList)
  {
    TargetEntry *nrtle = (TargetEntry *) lfirst(nrtl);
    TargetEntry *lefttle = (TargetEntry *) lfirst(left_tlist);
    char     *colName;
    TargetEntry *tle;

    Assert(!lefttle->resjunk);
    colName = pstrdup(lefttle->resname);
    tle = makeTargetEntry(nrtle->expr,
                next_resno++,
                colName,
                false);
    targetList = lappend(targetList, tle);
  }

  /* Now build CTE's output column info using dummy targetlist */
  analyzeCTETargetList(pstate, pstate->p_parent_cte, targetList);
}


/*
 * transformReturnStmt -
 *    transforms a return statement
 */
static Query *
transformReturnStmt(ParseState *pstate, ReturnStmt *stmt)
{
  Query    *qry = makeNode(Query);

  qry->commandType = CMD_SELECT;
  qry->isReturn = true;

  qry->targetList = list_make1(makeTargetEntry((Expr *) transformExpr(pstate, stmt->returnval, EXPR_KIND_SELECT_TARGET),
                         1, NULL, false));

  if (pstate->p_resolve_unknowns)
    resolveTargetListUnknowns(pstate, qry->targetList);
  qry->rtable = pstate->p_rtable;
  qry->rteperminfos = pstate->p_rteperminfos;
  qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
  qry->hasSubLinks = pstate->p_hasSubLinks;
  qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
  qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
  qry->hasAggs = pstate->p_hasAggs;

  assign_query_collations(pstate, qry);

  return qry;
}


/*
 * transformUpdateStmt -
 *    transforms an update statement
 */
static Query *
transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt)
{
  Query    *qry = makeNode(Query);
  ParseNamespaceItem *nsitem;
  Node     *qual;

  qry->commandType = CMD_UPDATE;

  /* process the WITH clause independently of all else */
  if (stmt->withClause)
  {
    qry->hasRecursive = stmt->withClause->recursive;
    qry->cteList = transformWithClause(pstate, stmt->withClause);
    qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
  }

  qry->resultRelation = setTargetTable(pstate, stmt->relation,
                     stmt->relation->inh,
                     true,
                     ACL_UPDATE);

  /* disallow UPDATE ... WHERE CURRENT OF on a view */
  if (stmt->whereClause &&
    IsA(stmt->whereClause, CurrentOfExpr) &&
    pstate->p_target_relation->rd_rel->relkind == RELKIND_VIEW)
    ereport(ERROR,
        errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        errmsg("WHERE CURRENT OF on a view is not implemented"));

  if (stmt->forPortionOf)
    qry->forPortionOf = transformForPortionOfClause(pstate,
                            qry->resultRelation,
                            stmt->forPortionOf,
                            stmt->whereClause,
                            true);

  nsitem = pstate->p_target_nsitem;

  /* subqueries in FROM cannot access the result relation */
  nsitem->p_lateral_only = true;
  nsitem->p_lateral_ok = false;

  /*
   * the FROM clause is non-standard SQL syntax. We used to be able to do
   * this with REPLACE in POSTQUEL so we keep the feature.
   */
  transformFromClause(pstate, stmt->fromClause);

  /* remaining clauses can reference the result relation normally */
  nsitem->p_lateral_only = false;
  nsitem->p_lateral_ok = true;

  qual = transformWhereClause(pstate, stmt->whereClause,
                EXPR_KIND_WHERE, "WHERE");

  transformReturningClause(pstate, qry, stmt->returningClause,
               EXPR_KIND_RETURNING);

  /*
   * Now we are done with SELECT-like processing, and can get on with
   * transforming the target list to match the UPDATE target columns.
   */
  qry->targetList = transformUpdateTargetList(pstate, stmt->targetList,
                        qry->forPortionOf);

  qry->rtable = pstate->p_rtable;
  qry->rteperminfos = pstate->p_rteperminfos;
  qry->jointree = makeFromExpr(pstate->p_joinlist, qual);

  qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
  qry->hasSubLinks = pstate->p_hasSubLinks;

  assign_query_collations(pstate, qry);

  return qry;
}

/*
 * transformUpdateTargetList -
 *  handle SET clause in UPDATE/MERGE/INSERT ... ON CONFLICT UPDATE
 */
List *
transformUpdateTargetList(ParseState *pstate, List *origTlist, ForPortionOfExpr *forPortionOf)
{
  List     *tlist = NIL;
  RTEPermissionInfo *target_perminfo;
  ListCell   *orig_tl;
  ListCell   *tl;

  tlist = transformTargetList(pstate, origTlist,
                EXPR_KIND_UPDATE_SOURCE);

  /* Prepare to assign non-conflicting resnos to resjunk attributes */
  if (pstate->p_next_resno <= RelationGetNumberOfAttributes(pstate->p_target_relation))
    pstate->p_next_resno = RelationGetNumberOfAttributes(pstate->p_target_relation) + 1;

  /* Prepare non-junk columns for assignment to target table */
  target_perminfo = pstate->p_target_nsitem->p_perminfo;
  orig_tl = list_head(origTlist);

  foreach(tl, tlist)
  {
    TargetEntry *tle = (TargetEntry *) lfirst(tl);
    ResTarget  *origTarget;
    int     attrno;

    if (tle->resjunk)
    {
      /*
       * Resjunk nodes need no additional processing, but be sure they
       * have resnos that do not match any target columns; else rewriter
       * or planner might get confused.  They don't need a resname
       * either.
       */
      tle->resno = (AttrNumber) pstate->p_next_resno++;
      tle->resname = NULL;
      continue;
    }
    if (orig_tl == NULL)
      elog(ERROR, "UPDATE target count mismatch --- internal error");
    origTarget = lfirst_node(ResTarget, orig_tl);

    attrno = attnameAttNum(pstate->p_target_relation,
                 origTarget->name, true);
    if (attrno == InvalidAttrNumber)
      ereport(ERROR,
          (errcode(ERRCODE_UNDEFINED_COLUMN),
           errmsg("column \"%s\" of relation \"%s\" does not exist",
              origTarget->name,
              RelationGetRelationName(pstate->p_target_relation)),
           (origTarget->indirection != NIL &&
            strcmp(origTarget->name, pstate->p_target_nsitem->p_names->aliasname) == 0) ?
           errhint("SET target columns cannot be qualified with the relation name.") : 0,
           parser_errposition(pstate, origTarget->location)));

    /*
     * If this is a FOR PORTION OF update, forbid directly setting the
     * range column, since that would conflict with the implicit updates.
     */
    if (forPortionOf != NULL)
    {
      if (attrno == forPortionOf->rangeVar->varattno)
        ereport(ERROR,
            (errcode(ERRCODE_SYNTAX_ERROR),
             errmsg("cannot update column \"%s\" because it is used in FOR PORTION OF",
                origTarget->name),
             parser_errposition(pstate, origTarget->location)));
    }

    updateTargetListEntry(pstate, tle, origTarget->name,
                attrno,
                origTarget->indirection,
                origTarget->location);

    /* Mark the target column as requiring update permissions */
    target_perminfo->updatedCols = bms_add_member(target_perminfo->updatedCols,
                            attrno - FirstLowInvalidHeapAttributeNumber);

    orig_tl = lnext(origTlist, orig_tl);
  }
  if (orig_tl != NULL)
    elog(ERROR, "UPDATE target count mismatch --- internal error");

  return tlist;
}

/*
 * addNSItemForReturning -
 *  add a ParseNamespaceItem for the OLD or NEW alias in RETURNING.
 */
static void
addNSItemForReturning(ParseState *pstate, const char *aliasname,
            VarReturningType returning_type)
{
  List     *colnames;
  int     numattrs;
  ParseNamespaceColumn *nscolumns;
  ParseNamespaceItem *nsitem;

  /* copy per-column data from the target relation */
  colnames = pstate->p_target_nsitem->p_rte->eref->colnames;
  numattrs = list_length(colnames);

  nscolumns = palloc_array(ParseNamespaceColumn, numattrs);

  memcpy(nscolumns, pstate->p_target_nsitem->p_nscolumns,
       numattrs * sizeof(ParseNamespaceColumn));

  /* mark all columns as returning OLD/NEW */
  for (int i = 0; i < numattrs; i++)
    nscolumns[i].p_varreturningtype = returning_type;

  /* build the nsitem, copying most fields from the target relation */
  nsitem = palloc_object(ParseNamespaceItem);
  nsitem->p_names = makeAlias(aliasname, colnames);
  nsitem->p_rte = pstate->p_target_nsitem->p_rte;
  nsitem->p_rtindex = pstate->p_target_nsitem->p_rtindex;
  nsitem->p_perminfo = pstate->p_target_nsitem->p_perminfo;
  nsitem->p_nscolumns = nscolumns;
  nsitem->p_returning_type = returning_type;

  /* add it to the query namespace as a table-only item */
  addNSItemToQuery(pstate, nsitem, false, true, false);
}

/*
 * transformReturningClause -
 *  handle a RETURNING clause in INSERT/UPDATE/DELETE/MERGE
 */
void
transformReturningClause(ParseState *pstate, Query *qry,
             ReturningClause *returningClause,
             ParseExprKind exprKind)
{
  int     save_nslen = list_length(pstate->p_namespace);
  int     save_next_resno;

  if (returningClause == NULL)
    return;         /* nothing to do */

  /*
   * Scan RETURNING WITH(...) options for OLD/NEW alias names.  Complain if
   * there is any conflict with existing relations.
   */
  foreach_node(ReturningOption, option, returningClause->options)
  {
    switch (option->option)
    {
      case RETURNING_OPTION_OLD:
        if (qry->returningOldAlias != NULL)
          ereport(ERROR,
              errcode(ERRCODE_SYNTAX_ERROR),
          /* translator: %s is OLD or NEW */
              errmsg("%s cannot be specified multiple times", "OLD"),
              parser_errposition(pstate, option->location));
        qry->returningOldAlias = option->value;
        break;

      case RETURNING_OPTION_NEW:
        if (qry->returningNewAlias != NULL)
          ereport(ERROR,
              errcode(ERRCODE_SYNTAX_ERROR),
          /* translator: %s is OLD or NEW */
              errmsg("%s cannot be specified multiple times", "NEW"),
              parser_errposition(pstate, option->location));
        qry->returningNewAlias = option->value;
        break;

      default:
        elog(ERROR, "unrecognized returning option: %d", option->option);
    }

    if (refnameNamespaceItem(pstate, NULL, option->value, -1, NULL) != NULL)
      ereport(ERROR,
          errcode(ERRCODE_DUPLICATE_ALIAS),
          errmsg("table name \"%s\" specified more than once",
               option->value),
          parser_errposition(pstate, option->location));

    addNSItemForReturning(pstate, option->value,
                option->option == RETURNING_OPTION_OLD ?
                VAR_RETURNING_OLD : VAR_RETURNING_NEW);
  }

  /*
   * If OLD/NEW alias names weren't explicitly specified, use "old"/"new"
   * unless masked by existing relations.
   */
  if (qry->returningOldAlias == NULL &&
    refnameNamespaceItem(pstate, NULL, "old", -1, NULL) == NULL)
  {
    qry->returningOldAlias = "old";
    addNSItemForReturning(pstate, "old", VAR_RETURNING_OLD);
  }
  if (qry->returningNewAlias == NULL &&
    refnameNamespaceItem(pstate, NULL, "new", -1, NULL) == NULL)
  {
    qry->returningNewAlias = "new";
    addNSItemForReturning(pstate, "new", VAR_RETURNING_NEW);
  }

  /*
   * We need to assign resnos starting at one in the RETURNING list. Save
   * and restore the main tlist's value of p_next_resno, just in case
   * someone looks at it later (probably won't happen).
   */
  save_next_resno = pstate->p_next_resno;
  pstate->p_next_resno = 1;

  /* transform RETURNING expressions identically to a SELECT targetlist */
  qry->returningList = transformTargetList(pstate,
                       returningClause->exprs,
                       exprKind);

  /*
   * Complain if the nonempty tlist expanded to nothing (which is possible
   * if it contains only a star-expansion of a zero-column table).  If we
   * allow this, the parsed Query will look like it didn't have RETURNING,
   * with results that would probably surprise the user.
   */
  if (qry->returningList == NIL)
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg("RETURNING must have at least one column"),
         parser_errposition(pstate,
                  exprLocation(linitial(returningClause->exprs)))));

  /* mark column origins */
  markTargetListOrigins(pstate, qry->returningList);

  /* resolve any still-unresolved output columns as being type text */
  if (pstate->p_resolve_unknowns)
    resolveTargetListUnknowns(pstate, qry->returningList);

  /* restore state */
  pstate->p_namespace = list_truncate(pstate->p_namespace, save_nslen);
  pstate->p_next_resno = save_next_resno;
}


/*
 * transformPLAssignStmt -
 *    transform a PL/pgSQL assignment statement
 *
 * If there is no opt_indirection, the transformed statement looks like
 * "SELECT a_expr ...", except the expression has been cast to the type of
 * the target.  With indirection, it's still a SELECT, but the expression will
 * incorporate FieldStore and/or assignment SubscriptingRef nodes to compute a
 * new value for a container-type variable represented by the target.  The
 * expression references the target as the container source.
 */
static Query *
transformPLAssignStmt(ParseState *pstate, PLAssignStmt *stmt)
{
  Query    *qry;
  ColumnRef  *cref = makeNode(ColumnRef);
  List     *indirection = stmt->indirection;
  int     nnames = stmt->nnames;
  Node     *target;
  SelectStmtPassthrough passthru;
  bool    save_resolve_unknowns;

  /*
   * First, construct a ColumnRef for the target variable.  If the target
   * has more than one dotted name, we have to pull the extra names out of
   * the indirection list.
   */
  cref->fields = list_make1(makeString(stmt->name));
  cref->location = stmt->location;
  if (nnames > 1)
  {
    /* avoid munging the raw parsetree */
    indirection = list_copy(indirection);
    while (--nnames > 0 && indirection != NIL)
    {
      Node     *ind = (Node *) linitial(indirection);

      if (!IsA(ind, String))
        elog(ERROR, "invalid name count in PLAssignStmt");
      cref->fields = lappend(cref->fields, ind);
      indirection = list_delete_first(indirection);
    }
  }

  /*
   * Transform the target reference.  Typically we will get back a Param
   * node, but there's no reason to be too picky about its type.  (Note that
   * we must do this before calling transformSelectStmt.  It's tempting to
   * do it inside transformPLAssignStmtTarget, but we need to do it before
   * adding any FROM tables to the pstate's namespace, else we might wrongly
   * resolve the target as a table column.)
   */
  target = transformExpr(pstate, (Node *) cref,
               EXPR_KIND_UPDATE_TARGET);

  /* Set up passthrough data for transformPLAssignStmtTarget */
  passthru.stmt = stmt;
  passthru.target = target;
  passthru.indirection = indirection;

  /*
   * To avoid duplicating a lot of code, we use transformSelectStmt to do
   * almost all of the work.  However, we need to do additional processing
   * on the SELECT's targetlist after it's been transformed, but before
   * possible addition of targetlist items for ORDER BY or GROUP BY.
   * transformSelectStmt knows it should call transformPLAssignStmtTarget if
   * it's passed a passthru argument.
   *
   * Also, disable resolution of unknown-type tlist items; PL/pgSQL wants to
   * deal with that itself.
   */
  save_resolve_unknowns = pstate->p_resolve_unknowns;
  pstate->p_resolve_unknowns = false;
  qry = transformSelectStmt(pstate, stmt->val, &passthru);
  pstate->p_resolve_unknowns = save_resolve_unknowns;

  return qry;
}

/*
 * Callback function to adjust a SELECT's tlist to make the output suitable
 * for assignment to a PLAssignStmt's target variable.
 *
 * Note: we actually modify the tle->expr in-place, but the function's API
 * is set up to not presume that.
 */
static List *
transformPLAssignStmtTarget(ParseState *pstate, List *tlist,
              SelectStmtPassthrough *passthru)
{
  PLAssignStmt *stmt = passthru->stmt;
  Node     *target = passthru->target;
  List     *indirection = passthru->indirection;
  Oid     targettype;
  int32   targettypmod;
  Oid     targetcollation;
  TargetEntry *tle;
  Oid     type_id;

  targettype = exprType(target);
  targettypmod = exprTypmod(target);
  targetcollation = exprCollation(target);

  /* we should have exactly one targetlist item */
  if (list_length(tlist) != 1)
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg_plural("assignment source returned %d column",
                 "assignment source returned %d columns",
                 list_length(tlist),
                 list_length(tlist))));

  tle = linitial_node(TargetEntry, tlist);

  /*
   * This next bit is similar to transformAssignedExpr; the key difference
   * is we use COERCION_PLPGSQL not COERCION_ASSIGNMENT.
   */
  type_id = exprType((Node *) tle->expr);

  pstate->p_expr_kind = EXPR_KIND_UPDATE_TARGET;

  if (indirection)
  {
    tle->expr = (Expr *)
      transformAssignmentIndirection(pstate,
                       target,
                       stmt->name,
                       false,
                       targettype,
                       targettypmod,
                       targetcollation,
                       indirection,
                       list_head(indirection),
                       (Node *) tle->expr,
                       COERCION_PLPGSQL,
                       exprLocation(target));
  }
  else if (targettype != type_id &&
       (targettype == RECORDOID || ISCOMPLEX(targettype)) &&
       (type_id == RECORDOID || ISCOMPLEX(type_id)))
  {
    /*
     * Hack: do not let coerce_to_target_type() deal with inconsistent
     * composite types.  Just pass the expression result through as-is,
     * and let the PL/pgSQL executor do the conversion its way.  This is
     * rather bogus, but it's needed for backwards compatibility.
     */
  }
  else
  {
    /*
     * For normal non-qualified target column, do type checking and
     * coercion.
     */
    Node     *orig_expr = (Node *) tle->expr;

    tle->expr = (Expr *)
      coerce_to_target_type(pstate,
                  orig_expr, type_id,
                  targettype, targettypmod,
                  COERCION_PLPGSQL,
                  COERCE_IMPLICIT_CAST,
                  -1);
    /* With COERCION_PLPGSQL, this error is probably unreachable */
    if (tle->expr == NULL)
      ereport(ERROR,
          (errcode(ERRCODE_DATATYPE_MISMATCH),
           errmsg("variable \"%s\" is of type %s"
              " but expression is of type %s",
              stmt->name,
              format_type_be(targettype),
              format_type_be(type_id)),
           errhint("You will need to rewrite or cast the expression."),
           parser_errposition(pstate, exprLocation(orig_expr))));
  }

  pstate->p_expr_kind = EXPR_KIND_NONE;

  return list_make1(tle);
}


/*
 * transformDeclareCursorStmt -
 *  transform a DECLARE CURSOR Statement
 *
 * DECLARE CURSOR is like other utility statements in that we emit it as a
 * CMD_UTILITY Query node; however, we must first transform the contained
 * query.  We used to postpone that until execution, but it's really necessary
 * to do it during the normal parse analysis phase to ensure that side effects
 * of parser hooks happen at the expected time.
 */
static Query *
transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
{
  Query    *result;
  Query    *query;

  if ((stmt->options & CURSOR_OPT_SCROLL) &&
    (stmt->options & CURSOR_OPT_NO_SCROLL))
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
    /* translator: %s is a SQL keyword */
         errmsg("cannot specify both %s and %s",
            "SCROLL", "NO SCROLL")));

  if ((stmt->options & CURSOR_OPT_ASENSITIVE) &&
    (stmt->options & CURSOR_OPT_INSENSITIVE))
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
    /* translator: %s is a SQL keyword */
         errmsg("cannot specify both %s and %s",
            "ASENSITIVE", "INSENSITIVE")));

  /* Transform contained query, not allowing SELECT INTO */
  query = transformStmt(pstate, stmt->query);
  stmt->query = (Node *) query;

  /* Grammar should not have allowed anything but SELECT */
  if (!IsA(query, Query) ||
    query->commandType != CMD_SELECT)
    elog(ERROR, "unexpected non-SELECT command in DECLARE CURSOR");

  /*
   * We also disallow data-modifying WITH in a cursor.  (This could be
   * allowed, but the semantics of when the updates occur might be
   * surprising.)
   */
  if (query->hasModifyingCTE)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
         errmsg("DECLARE CURSOR must not contain data-modifying statements in WITH")));

  /* FOR UPDATE and WITH HOLD are not compatible */
  if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_HOLD))
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("DECLARE CURSOR WITH HOLD ... %s is not supported",
            LCS_asString(((RowMarkClause *)
                    linitial(query->rowMarks))->strength)),
         errdetail("Holdable cursors must be READ ONLY.")));

  /* FOR UPDATE and SCROLL are not compatible */
  if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_SCROLL))
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("DECLARE SCROLL CURSOR ... %s is not supported",
            LCS_asString(((RowMarkClause *)
                    linitial(query->rowMarks))->strength)),
         errdetail("Scrollable cursors must be READ ONLY.")));

  /* FOR UPDATE and INSENSITIVE are not compatible */
  if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_INSENSITIVE))
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("DECLARE INSENSITIVE CURSOR ... %s is not valid",
            LCS_asString(((RowMarkClause *)
                    linitial(query->rowMarks))->strength)),
         errdetail("Insensitive cursors must be READ ONLY.")));

  /* represent the command as a utility Query */
  result = makeNode(Query);
  result->commandType = CMD_UTILITY;
  result->utilityStmt = (Node *) stmt;

  return result;
}


/*
 * transformExplainStmt -
 *  transform an EXPLAIN Statement
 *
 * EXPLAIN is like other utility statements in that we emit it as a
 * CMD_UTILITY Query node; however, we must first transform the contained
 * query.  We used to postpone that until execution, but it's really necessary
 * to do it during the normal parse analysis phase to ensure that side effects
 * of parser hooks happen at the expected time.
 */
static Query *
transformExplainStmt(ParseState *pstate, ExplainStmt *stmt)
{
  Query    *result;
  bool    generic_plan = false;
  Oid      *paramTypes = NULL;
  int     numParams = 0;

  /*
   * If we have no external source of parameter definitions, and the
   * GENERIC_PLAN option is specified, then accept variable parameter
   * definitions (similarly to PREPARE, for example).
   */
  if (pstate->p_paramref_hook == NULL)
  {
    ListCell   *lc;

    foreach(lc, stmt->options)
    {
      DefElem    *opt = (DefElem *) lfirst(lc);

      if (strcmp(opt->defname, "generic_plan") == 0)
        generic_plan = defGetBoolean(opt);
      /* don't "break", as we want the last value */
    }
    if (generic_plan)
      setup_parse_variable_parameters(pstate, &paramTypes, &numParams);
  }

  /* transform contained query, allowing SELECT INTO */
  stmt->query = (Node *) transformOptionalSelectInto(pstate, stmt->query);

  /* make sure all is well with parameter types */
  if (generic_plan)
    check_variable_parameters(pstate, (Query *) stmt->query);

  /* represent the command as a utility Query */
  result = makeNode(Query);
  result->commandType = CMD_UTILITY;
  result->utilityStmt = (Node *) stmt;

  return result;
}


/*
 * transformCreateTableAsStmt -
 *  transform a CREATE TABLE AS, SELECT ... INTO, or CREATE MATERIALIZED VIEW
 *  Statement
 *
 * As with DECLARE CURSOR and EXPLAIN, transform the contained statement now.
 */
static Query *
transformCreateTableAsStmt(ParseState *pstate, CreateTableAsStmt *stmt)
{
  Query    *result;
  Query    *query;

  /* transform contained query, not allowing SELECT INTO */
  query = transformStmt(pstate, stmt->query);
  stmt->query = (Node *) query;

  /* additional work needed for CREATE MATERIALIZED VIEW */
  if (stmt->objtype == OBJECT_MATVIEW)
  {
    ObjectAddress temp_object;

    /*
     * Prohibit a data-modifying CTE in the query used to create a
     * materialized view. It's not sufficiently clear what the user would
     * want to happen if the MV is refreshed or incrementally maintained.
     */
    if (query->hasModifyingCTE)
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("materialized views must not use data-modifying statements in WITH")));

    /*
     * Check whether any temporary database objects are used in the
     * creation query. It would be hard to refresh data or incrementally
     * maintain it if a source disappeared.
     */
    if (query_uses_temp_object(query, &temp_object))
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("materialized views must not use temporary objects"),
           errdetail("This view depends on temporary %s.",
                 getObjectDescription(&temp_object, false))));

    /*
     * A materialized view would either need to save parameters for use in
     * maintaining/loading the data or prohibit them entirely.  The latter
     * seems safer and more sane.
     */
    if (query_contains_extern_params(query))
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("materialized views may not be defined using bound parameters")));

    /*
     * For now, we disallow unlogged materialized views, because it seems
     * like a bad idea for them to just go to empty after a crash. (If we
     * could mark them as unpopulated, that would be better, but that
     * requires catalog changes which crash recovery can't presently
     * handle.)
     */
    if (stmt->into->rel->relpersistence == RELPERSISTENCE_UNLOGGED)
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("materialized views cannot be unlogged")));

    /*
     * At runtime, we'll need a copy of the parsed-but-not-rewritten Query
     * for purposes of creating the view's ON SELECT rule.  We stash that
     * in the IntoClause because that's where intorel_startup() can
     * conveniently get it from.
     */
    stmt->into->viewQuery = copyObject(query);
  }

  /* represent the command as a utility Query */
  result = makeNode(Query);
  result->commandType = CMD_UTILITY;
  result->utilityStmt = (Node *) stmt;

  return result;
}

/*
 * transform a CallStmt
 */
static Query *
transformCallStmt(ParseState *pstate, CallStmt *stmt)
{
  List     *targs;
  ListCell   *lc;
  Node     *node;
  FuncExpr   *fexpr;
  HeapTuple proctup;
  Datum   proargmodes;
  bool    isNull;
  List     *outargs = NIL;
  Query    *result;

  /*
   * First, do standard parse analysis on the procedure call and its
   * arguments, allowing us to identify the called procedure.
   */
  targs = NIL;
  foreach(lc, stmt->funccall->args)
  {
    targs = lappend(targs, transformExpr(pstate,
                       (Node *) lfirst(lc),
                       EXPR_KIND_CALL_ARGUMENT));
  }

  node = ParseFuncOrColumn(pstate,
               stmt->funccall->funcname,
               targs,
               pstate->p_last_srf,
               stmt->funccall,
               true,
               stmt->funccall->location);

  assign_expr_collations(pstate, node);

  fexpr = castNode(FuncExpr, node);

  proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid));
  if (!HeapTupleIsValid(proctup))
    elog(ERROR, "cache lookup failed for function %u", fexpr->funcid);

  /*
   * Expand the argument list to deal with named-argument notation and
   * default arguments.  For ordinary FuncExprs this'd be done during
   * planning, but a CallStmt doesn't go through planning, and there seems
   * no good reason not to do it here.
   */
  fexpr->args = expand_function_arguments(fexpr->args,
                      true,
                      fexpr->funcresulttype,
                      proctup);

  /* Fetch proargmodes; if it's null, there are no output args */
  proargmodes = SysCacheGetAttr(PROCOID, proctup,
                  Anum_pg_proc_proargmodes,
                  &isNull);
  if (!isNull)
  {
    /*
     * Split the list into input arguments in fexpr->args and output
     * arguments in stmt->outargs.  INOUT arguments appear in both lists.
     */
    ArrayType  *arr;
    int     numargs;
    char     *argmodes;
    List     *inargs;
    int     i;

    arr = DatumGetArrayTypeP(proargmodes);  /* ensure not toasted */
    numargs = list_length(fexpr->args);
    if (ARR_NDIM(arr) != 1 ||
      ARR_DIMS(arr)[0] != numargs ||
      ARR_HASNULL(arr) ||
      ARR_ELEMTYPE(arr) != CHAROID)
      elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls",
         numargs);
    argmodes = (char *) ARR_DATA_PTR(arr);

    inargs = NIL;
    i = 0;
    foreach(lc, fexpr->args)
    {
      Node     *n = lfirst(lc);

      switch (argmodes[i])
      {
        case PROARGMODE_IN:
        case PROARGMODE_VARIADIC:
          inargs = lappend(inargs, n);
          break;
        case PROARGMODE_OUT:
          outargs = lappend(outargs, n);
          break;
        case PROARGMODE_INOUT:
          inargs = lappend(inargs, n);
          outargs = lappend(outargs, copyObject(n));
          break;
        default:
          /* note we don't support PROARGMODE_TABLE */
          elog(ERROR, "invalid argmode %c for procedure",
             argmodes[i]);
          break;
      }
      i++;
    }
    fexpr->args = inargs;
  }

  stmt->funcexpr = fexpr;
  stmt->outargs = outargs;

  ReleaseSysCache(proctup);

  /* represent the command as a utility Query */
  result = makeNode(Query);
  result->commandType = CMD_UTILITY;
  result->utilityStmt = (Node *) stmt;

  return result;
}

/*
 * Produce a string representation of a LockClauseStrength value.
 * This should only be applied to valid values (not LCS_NONE).
 */
const char *
LCS_asString(LockClauseStrength strength)
{
  switch (strength)
  {
    case LCS_NONE:
      Assert(false);
      break;
    case LCS_FORKEYSHARE:
      return "FOR KEY SHARE";
    case LCS_FORSHARE:
      return "FOR SHARE";
    case LCS_FORNOKEYUPDATE:
      return "FOR NO KEY UPDATE";
    case LCS_FORUPDATE:
      return "FOR UPDATE";
  }
  return "FOR some";     /* shouldn't happen */
}

/*
 * Check for features that are not supported with FOR [KEY] UPDATE/SHARE.
 *
 * exported so planner can check again after rewriting, query pullup, etc
 */
void
CheckSelectLocking(Query *qry, LockClauseStrength strength)
{
  Assert(strength != LCS_NONE); /* else caller error */

  if (qry->setOperations)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
            LCS_asString(strength))));
  if (qry->distinctClause != NIL)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with DISTINCT clause",
            LCS_asString(strength))));
  if (qry->groupClause != NIL || qry->groupingSets != NIL)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with GROUP BY clause",
            LCS_asString(strength))));
  if (qry->havingQual != NULL)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with HAVING clause",
            LCS_asString(strength))));
  if (qry->hasAggs)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with aggregate functions",
            LCS_asString(strength))));
  if (qry->hasWindowFuncs)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with window functions",
            LCS_asString(strength))));
  if (qry->hasTargetSRFs)
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("%s is not allowed with set-returning functions in the target list",
            LCS_asString(strength))));
}

/*
 * Transform a FOR [KEY] UPDATE/SHARE clause
 *
 * This basically involves replacing names by integer relids.
 *
 * NB: if you need to change this, see also markQueryForLocking()
 * in rewriteHandler.c, and isLockedRefname() in parse_relation.c.
 */
static void
transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc,
             bool pushedDown)
{
  List     *lockedRels = lc->lockedRels;
  ListCell   *l;
  ListCell   *rt;
  Index   i;
  LockingClause *allrels;

  CheckSelectLocking(qry, lc->strength);

  /* make a clause we can pass down to subqueries to select all rels */
  allrels = makeNode(LockingClause);
  allrels->lockedRels = NIL; /* indicates all rels */
  allrels->strength = lc->strength;
  allrels->waitPolicy = lc->waitPolicy;

  if (lockedRels == NIL)
  {
    /*
     * Lock all regular tables used in query and its subqueries.  We
     * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD
     * in rules.  This is a bit of an abuse of a mostly-obsolete flag, but
     * it's convenient.  We can't rely on the namespace mechanism that has
     * largely replaced inFromCl, since for example we need to lock
     * base-relation RTEs even if they are masked by upper joins.
     */
    i = 0;
    foreach(rt, qry->rtable)
    {
      RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);

      ++i;
      if (!rte->inFromCl)
        continue;
      switch (rte->rtekind)
      {
        case RTE_RELATION:
          {
            RTEPermissionInfo *perminfo;

            applyLockingClause(qry, i,
                       lc->strength,
                       lc->waitPolicy,
                       pushedDown);
            perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
            perminfo->requiredPerms |= ACL_SELECT_FOR_UPDATE;
          }
          break;
        case RTE_SUBQUERY:
          applyLockingClause(qry, i, lc->strength, lc->waitPolicy,
                     pushedDown);

          /*
           * FOR UPDATE/SHARE of subquery is propagated to all of
           * subquery's rels, too.  We could do this later (based on
           * the marking of the subquery RTE) but it is convenient
           * to have local knowledge in each query level about which
           * rels need to be opened with RowShareLock.
           */
          transformLockingClause(pstate, rte->subquery,
                       allrels, true);
          break;
        default:
          /* ignore all other RTE kinds */
          break;
      }
    }
  }
  else
  {
    /*
     * Lock just the named tables.  As above, we allow locking any base
     * relation regardless of alias-visibility rules, so we need to
     * examine inFromCl to exclude OLD/NEW.
     */
    foreach(l, lockedRels)
    {
      RangeVar   *thisrel = (RangeVar *) lfirst(l);

      /* For simplicity we insist on unqualified alias names here */
      if (thisrel->catalogname || thisrel->schemaname)
        ereport(ERROR,
            (errcode(ERRCODE_SYNTAX_ERROR),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
             errmsg("%s must specify unqualified relation names",
                LCS_asString(lc->strength)),
             parser_errposition(pstate, thisrel->location)));

      i = 0;
      foreach(rt, qry->rtable)
      {
        RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
        char     *rtename = rte->eref->aliasname;

        ++i;
        if (!rte->inFromCl)
          continue;

        /*
         * A join RTE without an alias is not visible as a relation
         * name and needs to be skipped (otherwise it might hide a
         * base relation with the same name), except if it has a USING
         * alias, which *is* visible.
         *
         * Subquery and values RTEs without aliases are never visible
         * as relation names and must always be skipped.
         */
        if (rte->alias == NULL)
        {
          if (rte->rtekind == RTE_JOIN)
          {
            if (rte->join_using_alias == NULL)
              continue;
            rtename = rte->join_using_alias->aliasname;
          }
          else if (rte->rtekind == RTE_SUBQUERY ||
               rte->rtekind == RTE_VALUES)
            continue;
        }

        if (strcmp(rtename, thisrel->relname) == 0)
        {
          switch (rte->rtekind)
          {
            case RTE_RELATION:
              {
                RTEPermissionInfo *perminfo;

                applyLockingClause(qry, i,
                           lc->strength,
                           lc->waitPolicy,
                           pushedDown);
                perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
                perminfo->requiredPerms |= ACL_SELECT_FOR_UPDATE;
              }
              break;
            case RTE_SUBQUERY:
              applyLockingClause(qry, i, lc->strength,
                         lc->waitPolicy, pushedDown);
              /* see comment above */
              transformLockingClause(pstate, rte->subquery,
                           allrels, true);
              break;
            case RTE_JOIN:
              ereport(ERROR,
                  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
              /*------
                translator: %s is a SQL row locking clause such as FOR UPDATE */
                   errmsg("%s cannot be applied to a join",
                      LCS_asString(lc->strength)),
                   parser_errposition(pstate, thisrel->location)));
              break;
            case RTE_FUNCTION:
              ereport(ERROR,
                  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
              /*------
                translator: %s is a SQL row locking clause such as FOR UPDATE */
                   errmsg("%s cannot be applied to a function",
                      LCS_asString(lc->strength)),
                   parser_errposition(pstate, thisrel->location)));
              break;
            case RTE_TABLEFUNC:
              ereport(ERROR,
                  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
              /*------
                translator: %s is a SQL row locking clause such as FOR UPDATE */
                   errmsg("%s cannot be applied to a table function",
                      LCS_asString(lc->strength)),
                   parser_errposition(pstate, thisrel->location)));
              break;
            case RTE_VALUES:
              ereport(ERROR,
                  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
              /*------
                translator: %s is a SQL row locking clause such as FOR UPDATE */
                   errmsg("%s cannot be applied to VALUES",
                      LCS_asString(lc->strength)),
                   parser_errposition(pstate, thisrel->location)));
              break;
            case RTE_CTE:
              ereport(ERROR,
                  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
              /*------
                translator: %s is a SQL row locking clause such as FOR UPDATE */
                   errmsg("%s cannot be applied to a WITH query",
                      LCS_asString(lc->strength)),
                   parser_errposition(pstate, thisrel->location)));
              break;
            case RTE_NAMEDTUPLESTORE:
              ereport(ERROR,
                  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
              /*------
                translator: %s is a SQL row locking clause such as FOR UPDATE */
                   errmsg("%s cannot be applied to a named tuplestore",
                      LCS_asString(lc->strength)),
                   parser_errposition(pstate, thisrel->location)));
              break;
            case RTE_GRAPH_TABLE:
              ereport(ERROR,
                  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
              /*------
                translator: %s is a SQL row locking clause such as FOR UPDATE */
                   errmsg("%s cannot be applied to GRAPH_TABLE",
                      LCS_asString(lc->strength)),
                   parser_errposition(pstate, thisrel->location)));
              break;

              /* Shouldn't be possible to see RTE_RESULT here */

            default:
              elog(ERROR, "unrecognized RTE type: %d",
                 (int) rte->rtekind);
              break;
          }
          break;   /* out of foreach loop */
        }
      }
      if (rt == NULL)
        ereport(ERROR,
            (errcode(ERRCODE_UNDEFINED_TABLE),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
             errmsg("relation \"%s\" in %s clause not found in FROM clause",
                thisrel->relname,
                LCS_asString(lc->strength)),
             parser_errposition(pstate, thisrel->location)));
    }
  }
}

/*
 * Record locking info for a single rangetable item
 */
void
applyLockingClause(Query *qry, Index rtindex,
           LockClauseStrength strength, LockWaitPolicy waitPolicy,
           bool pushedDown)
{
  RowMarkClause *rc;

  Assert(strength != LCS_NONE); /* else caller error */

  /* If it's an explicit clause, make sure hasForUpdate gets set */
  if (!pushedDown)
    qry->hasForUpdate = true;

  /* Check for pre-existing entry for same rtindex */
  if ((rc = get_parse_rowmark(qry, rtindex)) != NULL)
  {
    /*
     * If the same RTE is specified with more than one locking strength,
     * use the strongest.  (Reasonable, since you can't take both a shared
     * and exclusive lock at the same time; it'll end up being exclusive
     * anyway.)
     *
     * Similarly, if the same RTE is specified with more than one lock
     * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
     * turn wins over waiting for the lock (the default).  This is a bit
     * more debatable but raising an error doesn't seem helpful. (Consider
     * for instance SELECT FOR UPDATE NOWAIT from a view that internally
     * contains a plain FOR UPDATE spec.)  Having NOWAIT win over SKIP
     * LOCKED is reasonable since the former throws an error in case of
     * coming across a locked tuple, which may be undesirable in some
     * cases but it seems better than silently returning inconsistent
     * results.
     *
     * And of course pushedDown becomes false if any clause is explicit.
     */
    rc->strength = Max(rc->strength, strength);
    rc->waitPolicy = Max(rc->waitPolicy, waitPolicy);
    rc->pushedDown &= pushedDown;
    return;
  }

  /* Make a new RowMarkClause */
  rc = makeNode(RowMarkClause);
  rc->rti = rtindex;
  rc->strength = strength;
  rc->waitPolicy = waitPolicy;
  rc->pushedDown = pushedDown;
  qry->rowMarks = lappend(qry->rowMarks, rc);
}

#ifdef DEBUG_NODE_TESTS_ENABLED
/*
 * Coverage testing for raw_expression_tree_walker().
 *
 * When enabled, we run raw_expression_tree_walker() over every DML statement
 * submitted to parse analysis.  Without this provision, that function is only
 * applied in limited cases involving CTEs, and we don't really want to have
 * to test everything inside as well as outside a CTE.
 */
static bool
test_raw_expression_coverage(Node *node, void *context)
{
  if (node == NULL)
    return false;
  return raw_expression_tree_walker(node,
                    test_raw_expression_coverage,
                    context);
}
#endif              /* DEBUG_NODE_TESTS_ENABLED */

Coverage Report

Created: 2026-08-14 06:37