/Users/deen/code/yugabyte-db/src/postgres/src/backend/parser/analyze.c

Source (jump to first uncovered line)
/*-------------------------------------------------------------------------
 *
 * 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-2018, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *  src/backend/parser/analyze.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "access/sysattr.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/pg_type.h"
#include "commands/dbcommands.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/var.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_oper.h"
#include "parser/parse_param.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
#include "parser/parsetree.h"
#include "rewrite/rewriteManip.h"
#include "utils/rel.h"

#include "pg_yb_utils.h"

/* 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 List *transformInsertRow(ParseState *pstate, List *exprlist,
           List *stmtcols, List *icolumns, List *attrnos,
           bool strip_indirection);
static OnConflictExpr *transformOnConflictClause(ParseState *pstate,
              OnConflictClause *onConflictClause);
static int  count_rowexpr_columns(ParseState *pstate, Node *expr);
static Query *transformSelectStmt(ParseState *pstate, SelectStmt *stmt);
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 *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
static List *transformReturningList(ParseState *pstate, List *returningList);
static List *transformUpdateTargetList(ParseState *pstate,
              List *targetList);
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 RAW_EXPRESSION_COVERAGE_TEST
static bool test_raw_expression_coverage(Node *node, void *context);
#endif


/*
 * parse_analyze
 *    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(RawStmt *parseTree, const char *sourceText,
        Oid *paramTypes, int numParams,
        QueryEnvironment *queryEnv)
{
  ParseState *pstate = make_parsestate(NULL);
  Query    *query;

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

  pstate->p_sourcetext = sourceText;

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

  pstate->p_queryEnv = queryEnv;

  query = transformTopLevelStmt(pstate, parseTree);

  if (pstate->p_target_relation &&
    pstate->p_target_relation->rd_rel->relpersistence == 52.9kRELPERSISTENCE_TEMP52.9k
    && IsYugaByteEnabled()326)
  {
    SetTxnWithPGRel();
  }

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

  free_parsestate(pstate);

  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)
{
  ParseState *pstate = make_parsestate(NULL);
  Query    *query;

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

  pstate->p_sourcetext = sourceText;

  parse_variable_parameters(pstate, paramTypes, numParams);

  query = transformTopLevelStmt(pstate, parseTree);

  if (pstate->p_target_relation &&
    pstate->p_target_relation->rd_rel->relpersistence == 245kRELPERSISTENCE_TEMP245k
    && IsYugaByteEnabled()66)
  {
    SetTxnWithPGRel();
  }

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

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

  free_parsestate(pstate);

  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 (stmt126k && 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->relkind = 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;

  /*
   * We apply 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.
   */
#ifdef RAW_EXPRESSION_COVERAGE_TEST
  switch (nodeTag(parseTree))
  {
    case T_SelectStmt:
    case T_InsertStmt:
    case T_UpdateStmt:
    case T_DeleteStmt:
      (void) test_raw_expression_coverage(parseTree, NULL);
      break;
    default:
      break;
  }
#endif              /* RAW_EXPRESSION_COVERAGE_TEST */

  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_SelectStmt:
      {
        SelectStmt *n = (SelectStmt *) parseTree;

        if (n->valuesLists)
          result = transformValuesClause(pstate, n);
        else if (n->op == SETOP_NONE)
          result = transformSelectStmt(pstate, n);
        else
          result = transformSetOperationStmt(pstate, n);
      }
      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 = (Node *) parseTree;
      break;
  }

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

  return result;
}

/*
 * analyze_requires_snapshot
 *    Returns true if a snapshot must be set before doing parse analysis
 *    on the given raw parse tree.
 *
 * Classification here should match transformStmt().
 */
bool
analyze_requires_snapshot(RawStmt *parseTree)
{
  bool    result;

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

      /*
       * Special cases
       */
    case T_DeclareCursorStmt:
    case T_ExplainStmt:
    case T_CreateTableAsStmt:
      /* yes, because we must analyze the contained statement */
      result = true;
      break;

    case T_BackfillIndexStmt:
      result = false;
      break;

    default:
      /* other utility statements don't have any real parse analysis */
      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);

  /* grab the namespace item made by setTargetTable */
  nsitem = (ParseNamespaceItem *) llast(pstate->p_namespace);

  /* 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;

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

  qry->returningList = transformReturningList(pstate, stmt->returningList);

  /* done building the range table and jointree */
  qry->rtable = pstate->p_rtable;
  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_namespace;
  List     *icolumns;
  List     *attrnos;
  RangeTblEntry *rte;
  RangeTblRef *rtr;
  ListCell   *icols;
  ListCell   *attnos;
  ListCell   *lc;
  bool    isOnConflictUpdate;
  AclMode   targetPerms;

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

  qry->commandType = CMD_INSERT;
  pstate->p_is_insert = true;

  /* 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;

  isOnConflictUpdate = (stmt->onConflictClause &&
              stmt->onConflictClause->action == ONCONFLICT_UPDATE7.62k);

  /*
   * 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 && (271kselectStmt->valuesLists == 271kNIL271k ||
                    selectStmt->sortClause != 269kNIL269k ||
                    selectStmt->limitOffset != NULL269k ||
                    selectStmt->limitCount != NULL269k ||
                    selectStmt->lockingClause != 269kNIL269k ||
                    selectStmt->withClause != NULL269k));

  /*
   * If a non-nil rangetable/namespace was passed in, and we are doing
   * INSERT/SELECT, arrange to pass the rangetable/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_namespace = pstate->p_namespace;
    pstate->p_namespace = NIL;
  }
  else
  {
    sub_rtable = NIL;   /* not used, but keep compiler quiet */
    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 (isOnConflictUpdate)
    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_joinexprs = NIL; /* sub_rtable has no joins */
    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.
     */
    rte = addRangeTableEntryForSubquery(pstate,
                      selectQuery,
                      makeAlias("*SELECT*", NIL),
                      false,
                      false);
    rtr = makeNode(RangeTblRef);
    /* assume new rte is at end */
    rtr->rtindex = list_length(pstate->p_rtable);
    Assert(rte == rt_fetch(rtr->rtindex, pstate->p_rtable));
    pstate->p_joinlist = lappend(pstate->p_joinlist, rtr);

    /*----------
     * 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) ||IsA1.25k(tle->expr, Param)) &&
        exprType((Node *) tle->expr) == 1.85kUNKNOWNOID1.85k)
        expr = tle->expr;
      else
      {
        Var      *var = makeVarFromTargetEntry(rtr->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)1)
      lateral = true;

    /*
     * Generate the VALUES RTE
     */
    rte = addRangeTableEntryForValues(pstate, exprsLists,
                      coltypes, coltypmods, colcollations,
                      NULL, lateral, true);
    rtr = makeNode(RangeTblRef);
    /* assume new rte is at end */
    rtr->rtindex = list_length(pstate->p_rtable);
    Assert(rte == rt_fetch(rtr->rtindex, pstate->p_rtable));
    pstate->p_joinlist = lappend(pstate->p_joinlist, rtr);

    /*
     * Generate list of Vars referencing the RTE
     */
    expandRTE(rte, rtr->rtindex, 0, -1, false, NULL, &exprList);

    /*
     * 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.
   */
  rte = pstate->p_target_rangetblentry;
  qry->targetList = NIL;
  icols = list_head(icolumns);
  attnos = list_head(attrnos);
  foreach(lc, exprList)
  {
    Expr     *expr = (Expr *) lfirst(lc);
    ResTarget  *col;
    AttrNumber  attr_num;
    TargetEntry *tle;

    col = lfirst_node(ResTarget, icols);
    attr_num = (AttrNumber) lfirst_int(attnos);

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

    rte->insertedCols = bms_add_member(rte->insertedCols,
                       attr_num - YBGetFirstLowInvalidAttributeNumber(pstate->p_target_relation));

    icols = lnext(icols);
    attnos = lnext(attnos);
  }

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

  /*
   * If we have a RETURNING clause, we need to add the target relation to
   * the query namespace before processing it, so that Var references in
   * RETURNING will work.  Also, remove any namespace entries added in a
   * sub-SELECT or VALUES list.
   */
  if (stmt->returningList)
  {
    pstate->p_namespace = NIL;
    addRTEtoQuery(pstate, pstate->p_target_rangetblentry,
            false, true, true);
    qry->returningList = transformReturningList(pstate,
                          stmt->returningList);
  }

  /* done building the range table and jointree */
  qry->rtable = pstate->p_rtable;
  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
 */
static 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)196k)
  {
    /*
     * 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;
  icols = list_head(icolumns);
  attnos = list_head(attrnos);
  foreach(lc, exprlist)
  {
    Expr     *expr = (Expr *) lfirst(lc);
    ResTarget  *col;

    col = lfirst_node(ResTarget, icols);

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

    if (strip_indirection)
    {
      while (expr)
      {
        if (IsA(expr, FieldStore))
        {
          FieldStore *fstore = (FieldStore *) expr;

          expr = (Expr *) linitial(fstore->newvals);
        }
        else if (IsA(expr, ArrayRef))
        {
          ArrayRef   *aref = (ArrayRef *) expr;

          if (aref->refassgnexpr == NULL)
            break;
          expr = aref->refassgnexpr;
        }
        else
          break;
      }
    }

    result = lappend(result, expr);

    icols = lnext(icols);
    attnos = lnext(attnos);
  }

  return result;
}

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

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

  /* Process DO UPDATE */
  if (onConflictClause->action == ONCONFLICT_UPDATE)
  {
    Relation  targetrel = pstate->p_target_relation;

    /*
     * All INSERT expressions have been parsed, get ready for potentially
     * existing SET statements that need to be processed like an UPDATE.
     */
    pstate->p_is_insert = false;

    /*
     * Add range table entry for the EXCLUDED pseudo relation.  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 = addRangeTableEntryForRelation(pstate,
                        targetrel,
                        makeAlias("excluded", NIL),
                        false, false);
    exclRte->relkind = RELKIND_COMPOSITE_TYPE;
    exclRte->requiredPerms = 0;
    /* other permissions fields in exclRte are already empty */

    exclRelIndex = list_length(pstate->p_rtable);

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

    /*
     * Add EXCLUDED and the target RTE to the namespace, so that they can
     * be used in the UPDATE subexpressions.
     */
    addRTEtoQuery(pstate, exclRte, false, true, true);
    addRTEtoQuery(pstate, pstate->p_target_rangetblentry,
            false, true, true);

    /*
     * Now transform the UPDATE subexpressions.
     */
    onConflictSet =
      transformUpdateTargetList(pstate, onConflictClause->targetList);

    onConflictWhere = transformWhereClause(pstate,
                         onConflictClause->whereClause,
                         EXPR_KIND_WHERE, "WHERE");
  }

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

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

  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++14.8k)
  {
    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 = "";
    }
    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
 *
 * 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)
{
  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);

  /* mark column origins */
  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 */ );

  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");
  qry->limitCount = transformLimitClause(pstate, stmt->limitCount,
                       EXPR_KIND_LIMIT, "LIMIT");

  /* 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->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->groupClause133k || qry->groupingSets133k || qry->havingQual133k)
    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;
  List     *coltypes = NIL;
  List     *coltypmods = NIL;
  List     *colcollations = NIL;
  List    **colexprs = NULL;
  int     sublist_length = -1;
  bool    lateral = false;
  RangeTblEntry *rte;
  int     rtindex;
  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);
  }

  /*
   * 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; 1.23ki < sublist_length; i++1.43k)
  {
    Oid     coltype;
    int32   coltypmod = -1;
    Oid     colcoll;
    bool    first = true;

    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) = (void *) col;
      if (first)
      {
        coltypmod = exprTypmod(col);
        first = false;
      }
      else
      {
        /* As soon as we see a non-matching typmod, fall back to -1 */
        if (coltypmod >= 0 && coltypmod != exprTypmod(col)0)
          coltypmod = -1;
      }
    }

    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.
   */
  exprsLists = NIL;
  foreach(lc, colexprs[0])
  {
    Node     *col = (Node *) lfirst(lc);
    List     *sublist;

    sublist = list_make1(col);
    exprsLists = lappend(exprsLists, sublist);
  }
  list_free(colexprs[0]);
  for (i = 1; i < sublist_length; i++192)
  {
    forboth(lc, colexprs[i], lc2, exprsLists)
    {
      Node     *col = (Node *) lfirst(lc);
      List     *sublist = lfirst(lc2);

      /* sublist pointer in exprsLists won't need adjustment */
      (void) lappend(sublist, col);
    }
    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)0)
    lateral = true;

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

  /* assume new rte is at end */
  rtindex = list_length(pstate->p_rtable);
  Assert(rte == rt_fetch(rtindex, pstate->p_rtable));

  /*
   * Generate a targetlist as though expanding "*"
   */
  Assert(pstate->p_next_resno == 1);
  qry->targetList = expandRelAttrs(pstate, rte, rtindex, 0, -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");
  qry->limitCount = transformLimitClause(pstate, stmt->limitCount,
                       EXPR_KIND_LIMIT, "LIMIT");

  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->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;
  RangeTblEntry *jrte;
  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 && IsA2.08k(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;
  left_tlist = list_head(leftmostQuery->targetList);

  forthree(lct, sostmt->colTypes,
       lcm, sostmt->colTypmods,
       lcc, sostmt->colCollations)
  {
    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));
    left_tlist = lnext(left_tlist);
  }

  /*
   * 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);

  jrte = addRangeTableEntryForJoin(pstate,
                   targetnames,
                   JOIN_INNER,
                   targetvars,
                   NULL,
                   false);

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

  /* add jrte to column namespace only */
  addRTEtoQuery(pstate, jrte, 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.
   */
  tllen = list_length(qry->targetList);

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

  /* restore namespace, remove jrte 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");
  qry->limitCount = transformLimitClause(pstate, limitCount,
                       EXPR_KIND_LIMIT, "LIMIT");

  qry->rtable = pstate->p_rtable;
  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->groupClause459 || qry->groupingSets459 || qry->havingQual459)
    parseCheckAggregates(pstate, qry);

  return qry;
}

/*
 * 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;
    char    selectName[32];
    RangeTblEntry *rte PG_USED_FOR_ASSERTS_ONLY;
    RangeTblRef *rtr;
    ListCell   *tl;

    /*
     * 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)
    {
      *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.
     */
    snprintf(selectName, sizeof(selectName), "*SELECT* %d",
         list_length(pstate->p_rtable) + 1);
    rte = addRangeTableEntryForSubquery(pstate,
                      selectQuery,
                      makeAlias(selectName, NIL),
                      false,
                      false);

    /*
     * Return a RangeTblRef to replace the SelectStmt in the set-op tree.
     */
    rtr = makeNode(RangeTblRef);
    /* assume new rte is at end */
    rtr->rtindex = list_length(pstate->p_rtable);
    Assert(rte == rt_fetch(rtr->rtindex, pstate->p_rtable));
    return (Node *) rtr;
  }
  else
  {
    /* Process an internal node (set operation node) */
    SetOperationStmt *op = makeNode(SetOperationStmt);
    List     *ltargetlist;
    List     *rtargetlist;
    ListCell   *ltl;
    ListCell   *rtl;
    const char *context;

    context = (stmt->op == SETOP_UNION ? "UNION"2.07k :
           (25stmt->op == SETOP_INTERSECT25 ? "INTERSECT"7 :
          "EXCEPT"18));

    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 &&
      pstate->p_parent_cte469 &&
      pstate->p_parent_cte->cterecursive60)
      determineRecursiveColTypes(pstate, op->larg, ltargetlist);

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

    /*
     * 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((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);
      int32   lcoltypmod = exprTypmod(lcolnode);
      int32   rcoltypmod = exprTypmod(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);
      /* if same type and same typmod, use typmod; else default */
      if (lcoltype == rcoltype && lcoltypmod == rcoltypmod4.35k)
        rescoltypmod = lcoltypmod;
      else
        rescoltypmod = -1;

      /*
       * 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) ||
           IsA0(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) ||
           IsA0(rcolnode, Param))
      {
        rcolnode = coerce_to_common_type(pstate, rcolnode,
                         rescoltype, context);
        rtle->expr = (Expr *) rcolnode;
      }

      /*
       * 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 curCollations 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->all4.37k));

      /* 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->all4.37k)
      {
        SortGroupClause *grpcl = makeNode(SortGroupClause);
        Oid     sortop;
        Oid     eqop;
        bool    hashable;
        ParseCallbackState pcbstate;

        setup_parser_errposition_callback(&pcbstate, pstate,
                          bestlocation);

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

        cancel_parser_errposition_callback(&pcbstate);

        /* we don't have a tlist yet, so can't assign sortgrouprefs */
        grpcl->tleSortGroupRef = 0;
        grpcl->eqop = eqop;
        grpcl->sortop = sortop;
        grpcl->nulls_first = false; /* OK with or without sortop */
        grpcl->hashable = hashable;

        op->groupClauses = lappend(op->groupClauses, grpcl);
      }

      /*
       * 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);
      }
    }

    return (Node *) op;
  }
}

/*
 * 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;
  left_tlist = list_head(leftmostQuery->targetList);
  next_resno = 1;

  foreach(nrtl, nrtargetlist)
  {
    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);
    left_tlist = lnext(left_tlist);
  }

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


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

  qry->commandType = CMD_UPDATE;
  pstate->p_is_insert = false;

  /* 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);

  /* grab the namespace item made by setTargetTable */
  nsitem = (ParseNamespaceItem *) llast(pstate->p_namespace);

  /* 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");

  qry->returningList = transformReturningList(pstate, stmt->returningList);

  /*
   * 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->rtable = pstate->p_rtable;
  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/INSERT ... ON CONFLICT UPDATE
 */
static List *
transformUpdateTargetList(ParseState *pstate, List *origTlist)
{
  List     *tlist = NIL;
  RangeTblEntry *target_rte;
  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_rte = pstate->p_target_rangetblentry;
  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)),
           parser_errposition(pstate, origTarget->location)));

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

    /* Mark the target column as requiring update permissions */
    target_rte->updatedCols = bms_add_member(target_rte->updatedCols,
                         attrno - YBGetFirstLowInvalidAttributeNumber(pstate->p_target_relation));

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

  return tlist;
}

/*
 * transformReturningList -
 *  handle a RETURNING clause in INSERT/UPDATE/DELETE
 */
static List *
transformReturningList(ParseState *pstate, List *returningList)
{
  List     *rlist;
  int     save_next_resno;

  if (returningList == NIL)
    return NIL;        /* nothing to do */

  /*
   * 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 identically to a SELECT targetlist */
  rlist = transformTargetList(pstate, returningList, EXPR_KIND_RETURNING);

  /*
   * 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 (rlist == NIL)
    ereport(ERROR,
        (errcode(ERRCODE_SYNTAX_ERROR),
         errmsg("RETURNING must have at least one column"),
         parser_errposition(pstate,
                  exprLocation(linitial(returningList)))));

  /* mark column origins */
  markTargetListOrigins(pstate, rlist);

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

  /* restore state */
  pstate->p_next_resno = save_next_resno;

  return rlist;
}


/*
 * 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;

  /*
   * Don't allow both SCROLL and NO SCROLL to be specified
   */
  if ((stmt->options & CURSOR_OPT_SCROLL) &&
    (stmt->options & 31CURSOR_OPT_NO_SCROLL31))
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
         errmsg("cannot specify both SCROLL and NO SCROLL")));

  /* 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_SELECT1.54k)
    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 & 9CURSOR_OPT_HOLD9))
    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 & 9CURSOR_OPT_SCROLL9))
    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 & 9CURSOR_OPT_INSENSITIVE9))
    ereport(ERROR,
        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    /*------
      translator: %s is a SQL row locking clause such as FOR UPDATE */
         errmsg("DECLARE INSENSITIVE CURSOR ... %s is not supported",
            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;

  /* transform contained query, allowing SELECT INTO */
  stmt->query = (Node *) transformOptionalSelectInto(pstate, 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->relkind == OBJECT_MATVIEW)
  {
    /*
     * 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 (isQueryUsingTempRelation(query))
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("materialized views must not use temporary tables or views")));

    /*
     * 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 = (Node *) 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
 *
 * We need to do parse analysis on the procedure call and its arguments.
 */
static Query *
transformCallStmt(ParseState *pstate, CallStmt *stmt)
{
  List     *targs;
  ListCell   *lc;
  Node     *node;
  Query    *result;

  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);

  stmt->funcexpr = castNode(FuncExpr, node);

  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:
          applyLockingClause(qry, i, lc->strength, lc->waitPolicy,
                     pushedDown);
          rte->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 JOIN, SPECIAL, FUNCTION, VALUES, CTE RTEs */
          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);

        ++i;
        if (!rte->inFromCl)
          continue;
        if (strcmp(rte->eref->aliasname, thisrel->relname) == 0)
        {
          switch (rte->rtekind)
          {
            case RTE_RELATION:
              applyLockingClause(qry, i, lc->strength,
                         lc->waitPolicy, pushedDown);
              rte->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;
            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);
}

/*
 * 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.
 */
#ifdef RAW_EXPRESSION_COVERAGE_TEST

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              /* RAW_EXPRESSION_COVERAGE_TEST */

YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

Coverage Report

Created: 2022-03-22 16:43