preptlist.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * preptlist.c
 *    Routines to preprocess the parse tree target list
 *
 * For an INSERT, the targetlist must contain an entry for each attribute of
 * the target relation in the correct order.
 *
 * For an UPDATE, the targetlist just contains the expressions for the new
 * column values.
 *
 * For UPDATE and DELETE queries, the targetlist must also contain "junk"
 * tlist entries needed to allow the executor to identify the rows to be
 * updated or deleted; for example, the ctid of a heap row.  (The planner
 * adds these; they're not in what we receive from the parser/rewriter.)
 *
 * For all query types, there can be additional junk tlist entries, such as
 * sort keys, Vars needed for a RETURNING list, and row ID information needed
 * for SELECT FOR UPDATE locking and/or EvalPlanQual checking.
 *
 * The query rewrite phase also does preprocessing of the targetlist (see
 * rewriteTargetListIU).  The division of labor between here and there is
 * partially historical, but it's not entirely arbitrary.  The stuff done
 * here is closely connected to physical access to tables, whereas the
 * rewriter's work is more concerned with SQL semantics.
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *    src/backend/optimizer/prep/preptlist.c
 *
 *-------------------------------------------------------------------------
 */
 
#include "postgres.h"
 
#include "access/table.h"
#include "nodes/makefuncs.h"
#include "optimizer/appendinfo.h"
#include "optimizer/optimizer.h"
#include "optimizer/prep.h"
#include "optimizer/tlist.h"
#include "parser/parse_coerce.h"
#include "parser/parsetree.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
 
static List *expand_insert_targetlist(PlannerInfo *root, List *tlist,
                                      Relation rel);
 
 
/*
 * preprocess_targetlist
 *    Driver for preprocessing the parse tree targetlist.
 *
 * The preprocessed targetlist is returned in root->processed_tlist.
 * Also, if this is an UPDATE, we return a list of target column numbers
 * in root->update_colnos.  (Resnos in processed_tlist will be consecutive,
 * so do not look at that to find out which columns are targets!)
 */
void
preprocess_targetlist(PlannerInfo *root)
{
    Query      *parse = root->parse;
    int         result_relation = parse->resultRelation;
    List       *range_table = parse->rtable;
    CmdType     command_type = parse->commandType;
    RangeTblEntry *target_rte = NULL;
    Relation    target_relation = NULL;
    List       *tlist;
    ListCell   *lc;
 
    /*
     * If there is a result relation, open it so we can look for missing
     * columns and so on.  We assume that previous code already acquired at
     * least AccessShareLock on the relation, so we need no lock here.
     */
    if (result_relation)
    {
        target_rte = rt_fetch(result_relation, range_table);
 
        /*
         * Sanity check: it'd better be a real relation not, say, a subquery.
         * Else parser or rewriter messed up.
         */
        if (target_rte->rtekind != RTE_RELATION)
            elog(ERROR, "result relation must be a regular relation");
 
        target_relation = table_open(target_rte->relid, NoLock);
    }
    else
        Assert(command_type == CMD_SELECT);
 
    /*
     * In an INSERT, the executor expects the targetlist to match the exact
     * order of the target table's attributes, including entries for
     * attributes not mentioned in the source query.
     *
     * In an UPDATE, we don't rearrange the tlist order, but we need to make a
     * separate list of the target attribute numbers, in tlist order, and then
     * renumber the processed_tlist entries to be consecutive.
     */
    tlist = parse->targetList;
    if (command_type == CMD_INSERT)
        tlist = expand_insert_targetlist(root, tlist, target_relation);
    else if (command_type == CMD_UPDATE)
        root->update_colnos = extract_update_targetlist_colnos(tlist);
 
    /*
     * For non-inherited UPDATE/DELETE/MERGE, register any junk column(s)
     * needed to allow the executor to identify the rows to be updated or
     * deleted.  In the inheritance case, we do nothing now, leaving this to
     * be dealt with when expand_inherited_rtentry() makes the leaf target
     * relations.  (But there might not be any leaf target relations, in which
     * case we must do this in distribute_row_identity_vars().)
     */
    if ((command_type == CMD_UPDATE || command_type == CMD_DELETE ||
         command_type == CMD_MERGE) &&
        !target_rte->inh)
    {
        /* row-identity logic expects to add stuff to processed_tlist */
        root->processed_tlist = tlist;
        add_row_identity_columns(root, result_relation,
                                 target_rte, target_relation);
        tlist = root->processed_tlist;
    }
 
    /*
     * For MERGE we also need to handle the target list for each INSERT and
     * UPDATE action separately.  In addition, we examine the qual of each
     * action and add any Vars there (other than those of the target rel) to
     * the subplan targetlist.
     */
    if (command_type == CMD_MERGE)
    {
        ListCell   *l;
        List       *vars;
 
        /*
         * For MERGE, handle targetlist of each MergeAction separately. Give
         * the same treatment to MergeAction->targetList as we would have
         * given to a regular INSERT.  For UPDATE, collect the column numbers
         * being modified.
         */
        foreach(l, parse->mergeActionList)
        {
            MergeAction *action = (MergeAction *) lfirst(l);
            ListCell   *l2;
 
            if (action->commandType == CMD_INSERT)
                action->targetList = expand_insert_targetlist(root,
                                                              action->targetList,
                                                              target_relation);
            else if (action->commandType == CMD_UPDATE)
                action->updateColnos =
                    extract_update_targetlist_colnos(action->targetList);
 
            /*
             * Add resjunk entries for any Vars and PlaceHolderVars used in
             * each action's targetlist and WHEN condition that belong to
             * relations other than the target.  We don't expect to see any
             * aggregates or window functions here.
             */
            vars = pull_var_clause((Node *)
                                   list_concat_copy((List *) action->qual,
                                                    action->targetList),
                                   PVC_INCLUDE_PLACEHOLDERS);
            foreach(l2, vars)
            {
                Var        *var = (Var *) lfirst(l2);
                TargetEntry *tle;
 
                if (IsA(var, Var) && var->varno == result_relation)
                    continue;   /* don't need it */
 
                if (tlist_member((Expr *) var, tlist))
                    continue;   /* already got it */
 
                tle = makeTargetEntry((Expr *) var,
                                      list_length(tlist) + 1,
                                      NULL, true);
                tlist = lappend(tlist, tle);
            }
            list_free(vars);
        }
 
        /*
         * Add resjunk entries for any Vars and PlaceHolderVars used in the
         * join condition that belong to relations other than the target.  We
         * don't expect to see any aggregates or window functions here.
         */
        vars = pull_var_clause(parse->mergeJoinCondition,
                               PVC_INCLUDE_PLACEHOLDERS);
        foreach(l, vars)
        {
            Var        *var = (Var *) lfirst(l);
            TargetEntry *tle;
 
            if (IsA(var, Var) && var->varno == result_relation)
                continue;       /* don't need it */
 
            if (tlist_member((Expr *) var, tlist))
                continue;       /* already got it */
 
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  NULL, true);
            tlist = lappend(tlist, tle);
        }
    }
 
    /*
     * Add necessary junk columns for rowmarked rels.  These values are needed
     * for locking of rels selected FOR UPDATE/SHARE, and to do EvalPlanQual
     * rechecking.  See comments for PlanRowMark in plannodes.h.  If you
     * change this stanza, see also expand_inherited_rtentry(), which has to
     * be able to add on junk columns equivalent to these.
     *
     * (Someday it might be useful to fold these resjunk columns into the
     * row-identity-column management used for UPDATE/DELETE.  Today is not
     * that day, however.  One notable issue is that it seems important that
     * the whole-row Vars made here use the real table rowtype, not RECORD, so
     * that conversion to/from child relations' rowtypes will happen.  Also,
     * since these entries don't potentially bloat with more and more child
     * relations, there's not really much need for column sharing.)
     */
    foreach(lc, root->rowMarks)
    {
        PlanRowMark *rc = (PlanRowMark *) lfirst(lc);
        Var        *var;
        char        resname[32];
        TargetEntry *tle;
 
        /* child rels use the same junk attrs as their parents */
        if (rc->rti != rc->prti)
            continue;
 
        if (rc->allMarkTypes & ~(1 << ROW_MARK_COPY))
        {
            /* Need to fetch TID */
            var = makeVar(rc->rti,
                          SelfItemPointerAttributeNumber,
                          TIDOID,
                          -1,
                          InvalidOid,
                          0);
            snprintf(resname, sizeof(resname), "ctid%u", rc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  pstrdup(resname),
                                  true);
            tlist = lappend(tlist, tle);
        }
        if (rc->allMarkTypes & (1 << ROW_MARK_COPY))
        {
            /* Need the whole row as a junk var */
            var = makeWholeRowVar(rt_fetch(rc->rti, range_table),
                                  rc->rti,
                                  0,
                                  false);
            snprintf(resname, sizeof(resname), "wholerow%u", rc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  pstrdup(resname),
                                  true);
            tlist = lappend(tlist, tle);
        }
 
        /* If parent of inheritance tree, always fetch the tableoid too. */
        if (rc->isParent)
        {
            var = makeVar(rc->rti,
                          TableOidAttributeNumber,
                          OIDOID,
                          -1,
                          InvalidOid,
                          0);
            snprintf(resname, sizeof(resname), "tableoid%u", rc->rowmarkId);
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  pstrdup(resname),
                                  true);
            tlist = lappend(tlist, tle);
        }
    }
 
    /*
     * If the query has a RETURNING list, add resjunk entries for any Vars
     * used in RETURNING that belong to other relations.  We need to do this
     * to make these Vars available for the RETURNING calculation.  Vars that
     * belong to the result rel don't need to be added, because they will be
     * made to refer to the actual heap tuple.
     */
    if (parse->returningList && list_length(parse->rtable) > 1)
    {
        List       *vars;
        ListCell   *l;
 
        vars = pull_var_clause((Node *) parse->returningList,
                               PVC_RECURSE_AGGREGATES |
                               PVC_RECURSE_WINDOWFUNCS |
                               PVC_INCLUDE_PLACEHOLDERS);
        foreach(l, vars)
        {
            Var        *var = (Var *) lfirst(l);
            TargetEntry *tle;
 
            if (IsA(var, Var) &&
                var->varno == result_relation)
                continue;       /* don't need it */
 
            if (tlist_member((Expr *) var, tlist))
                continue;       /* already got it */
 
            tle = makeTargetEntry((Expr *) var,
                                  list_length(tlist) + 1,
                                  NULL,
                                  true);
 
            tlist = lappend(tlist, tle);
        }
        list_free(vars);
    }
 
    root->processed_tlist = tlist;
 
    if (target_relation)
        table_close(target_relation, NoLock);
}
 
/*
 * extract_update_targetlist_colnos
 *      Extract a list of the target-table column numbers that
 *      an UPDATE's targetlist wants to assign to, then renumber.
 *
 * The convention in the parser and rewriter is that the resnos in an
 * UPDATE's non-resjunk TLE entries are the target column numbers
 * to assign to.  Here, we extract that info into a separate list, and
 * then convert the tlist to the sequential-numbering convention that's
 * used by all other query types.
 *
 * This is also applied to the tlist associated with INSERT ... ON CONFLICT
 * ... UPDATE, although not till much later in planning.
 */
List *
extract_update_targetlist_colnos(List *tlist)
{
    List       *update_colnos = NIL;
    AttrNumber  nextresno = 1;
    ListCell   *lc;
 
    foreach(lc, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(lc);
 
        if (!tle->resjunk)
            update_colnos = lappend_int(update_colnos, tle->resno);
        tle->resno = nextresno++;
    }
    return update_colnos;
}
 
 
/*****************************************************************************
 *
 *      TARGETLIST EXPANSION
 *
 *****************************************************************************/
 
/*
 * expand_insert_targetlist
 *    Given a target list as generated by the parser and a result relation,
 *    add targetlist entries for any missing attributes, and ensure the
 *    non-junk attributes appear in proper field order.
 *
 * Once upon a time we also did more or less this with UPDATE targetlists,
 * but now this code is only applied to INSERT targetlists.
 */
static List *
expand_insert_targetlist(PlannerInfo *root, List *tlist, Relation rel)
{
    List       *new_tlist = NIL;
    ListCell   *tlist_item;
    int         attrno,
                numattrs;
 
    tlist_item = list_head(tlist);
 
    /*
     * The rewriter should have already ensured that the TLEs are in correct
     * order; but we have to insert TLEs for any missing attributes.
     *
     * Scan the tuple description in the relation's relcache entry to make
     * sure we have all the user attributes in the right order.
     */
    numattrs = RelationGetNumberOfAttributes(rel);
 
    for (attrno = 1; attrno <= numattrs; attrno++)
    {
        Form_pg_attribute att_tup = TupleDescAttr(rel->rd_att, attrno - 1);
        TargetEntry *new_tle = NULL;
 
        if (tlist_item != NULL)
        {
            TargetEntry *old_tle = (TargetEntry *) lfirst(tlist_item);
 
            if (!old_tle->resjunk && old_tle->resno == attrno)
            {
                new_tle = old_tle;
                tlist_item = lnext(tlist, tlist_item);
            }
        }
 
        if (new_tle == NULL)
        {
            /*
             * Didn't find a matching tlist entry, so make one.
             *
             * INSERTs should insert NULL in this case.  (We assume the
             * rewriter would have inserted any available non-NULL default
             * value.)  Also, normally we must apply any domain constraints
             * that might exist --- this is to catch domain NOT NULL.
             *
             * When generating a NULL constant for a dropped column, we label
             * it INT4 (any other guaranteed-to-exist datatype would do as
             * well). We can't label it with the dropped column's datatype
             * since that might not exist anymore.  It does not really matter
             * what we claim the type is, since NULL is NULL --- its
             * representation is datatype-independent.  This could perhaps
             * confuse code comparing the finished plan to the target
             * relation, however.
             *
             * Another exception is that if the column is generated, the value
             * we produce here will be ignored, and we don't want to risk
             * throwing an error.  So in that case we *don't* want to apply
             * domain constraints, so we must produce a NULL of the base type.
             * Again, code comparing the finished plan to the target relation
             * must account for this.
             */
            Node       *new_expr;
 
            if (att_tup->attisdropped)
            {
                /* Insert NULL for dropped column */
                new_expr = (Node *) makeConst(INT4OID,
                                              -1,
                                              InvalidOid,
                                              sizeof(int32),
                                              (Datum) 0,
                                              true, /* isnull */
                                              true /* byval */ );
            }
            else if (att_tup->attgenerated)
            {
                /* Generated column, insert a NULL of the base type */
                Oid         baseTypeId = att_tup->atttypid;
                int32       baseTypeMod = att_tup->atttypmod;
 
                baseTypeId = getBaseTypeAndTypmod(baseTypeId, &baseTypeMod);
                new_expr = (Node *) makeConst(baseTypeId,
                                              baseTypeMod,
                                              att_tup->attcollation,
                                              att_tup->attlen,
                                              (Datum) 0,
                                              true, /* isnull */
                                              att_tup->attbyval);
            }
            else
            {
                /* Normal column, insert a NULL of the column datatype */
                new_expr = coerce_null_to_domain(att_tup->atttypid,
                                                 att_tup->atttypmod,
                                                 att_tup->attcollation,
                                                 att_tup->attlen,
                                                 att_tup->attbyval);
                /* Must run expression preprocessing on any non-const nodes */
                if (!IsA(new_expr, Const))
                    new_expr = eval_const_expressions(root, new_expr);
            }
 
            new_tle = makeTargetEntry((Expr *) new_expr,
                                      attrno,
                                      pstrdup(NameStr(att_tup->attname)),
                                      false);
        }
 
        new_tlist = lappend(new_tlist, new_tle);
    }
 
    /*
     * The remaining tlist entries should be resjunk; append them all to the
     * end of the new tlist, making sure they have resnos higher than the last
     * real attribute.  (Note: although the rewriter already did such
     * renumbering, we have to do it again here in case we added NULL entries
     * above.)
     */
    while (tlist_item)
    {
        TargetEntry *old_tle = (TargetEntry *) lfirst(tlist_item);
 
        if (!old_tle->resjunk)
            elog(ERROR, "targetlist is not sorted correctly");
        /* Get the resno right, but don't copy unnecessarily */
        if (old_tle->resno != attrno)
        {
            old_tle = flatCopyTargetEntry(old_tle);
            old_tle->resno = attrno;
        }
        new_tlist = lappend(new_tlist, old_tle);
        attrno++;
        tlist_item = lnext(tlist, tlist_item);
    }
 
    return new_tlist;
}
 
 
/*
 * Locate PlanRowMark for given RT index, or return NULL if none
 *
 * This probably ought to be elsewhere, but there's no very good place
 */
PlanRowMark *
get_plan_rowmark(List *rowmarks, Index rtindex)
{
    ListCell   *l;
 
    foreach(l, rowmarks)
    {
        PlanRowMark *rc = (PlanRowMark *) lfirst(l);
 
        if (rc->rti == rtindex)
            return rc;
    }
    return NULL;
}