Logo Search packages:      
Sourcecode: postgresql-8.4 version File versions

preptlist.c

/*-------------------------------------------------------------------------
 *
 * preptlist.c
 *      Routines to preprocess the parse tree target list
 *
 * This module takes care of altering the query targetlist as needed for
 * INSERT, UPDATE, and DELETE queries.    For INSERT and UPDATE queries,
 * the targetlist must contain an entry for each attribute of the target
 * relation in the correct order.  For both UPDATE and DELETE queries,
 * we need a junk targetlist entry holding the CTID attribute --- the
 * executor relies on this to find the tuple to be replaced/deleted.
 * We may also need junk tlist entries for Vars used in the RETURNING list.
 *
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *      $PostgreSQL$
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "access/heapam.h"
#include "access/sysattr.h"
#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
#include "optimizer/prep.h"
#include "optimizer/subselect.h"
#include "optimizer/tlist.h"
#include "optimizer/var.h"
#include "parser/analyze.h"
#include "parser/parsetree.h"
#include "parser/parse_coerce.h"
#include "utils/rel.h"


static List *expand_targetlist(List *tlist, int command_type,
                          Index result_relation, List *range_table);


/*
 * preprocess_targetlist
 *      Driver for preprocessing the parse tree targetlist.
 *
 *      Returns the new targetlist.
 */
List *
preprocess_targetlist(PlannerInfo *root, List *tlist)
{
      Query    *parse = root->parse;
      int               result_relation = parse->resultRelation;
      List     *range_table = parse->rtable;
      CmdType           command_type = parse->commandType;

      /*
       * Sanity check: if there is a result relation, it'd better be a real
       * relation not a subquery.  Else parser or rewriter messed up.
       */
      if (result_relation)
      {
            RangeTblEntry *rte = rt_fetch(result_relation, range_table);

            if (rte->subquery != NULL || rte->relid == InvalidOid)
                  elog(ERROR, "subquery cannot be result relation");
      }

      /*
       * for heap_form_tuple to work, the targetlist must match the exact order
       * of the attributes. We also need to fill in any missing attributes. -ay
       * 10/94
       */
      if (command_type == CMD_INSERT || command_type == CMD_UPDATE)
            tlist = expand_targetlist(tlist, command_type,
                                                  result_relation, range_table);

      /*
       * for "update" and "delete" queries, add ctid of the result relation into
       * the target list so that the ctid will propagate through execution and
       * ExecutePlan() will be able to identify the right tuple to replace or
       * delete.  This extra field is marked "junk" so that it is not stored
       * back into the tuple.
       */
      if (command_type == CMD_UPDATE || command_type == CMD_DELETE)
      {
            TargetEntry *tle;
            Var            *var;

            var = makeVar(result_relation, SelfItemPointerAttributeNumber,
                                TIDOID, -1, 0);

            tle = makeTargetEntry((Expr *) var,
                                            list_length(tlist) + 1,
                                            pstrdup("ctid"),
                                            true);

            /*
             * For an UPDATE, expand_targetlist already created a fresh tlist. For
             * DELETE, better do a listCopy so that we don't destructively modify
             * the original tlist (is this really necessary?).
             */
            if (command_type == CMD_DELETE)
                  tlist = list_copy(tlist);

            tlist = lappend(tlist, tle);
      }

      /*
       * Add TID targets for rels selected FOR UPDATE/SHARE.      The executor uses
       * the TID to know which rows to lock, much as for UPDATE or DELETE.
       */
      if (parse->rowMarks)
      {
            ListCell   *l;

            /*
             * We've got trouble if the FOR UPDATE/SHARE appears inside grouping,
             * since grouping renders a reference to individual tuple CTIDs
             * invalid.  This is also checked at parse time, but that's
             * insufficient because of rule substitution, query pullup, etc.
             */
            CheckSelectLocking(parse);

            /*
             * Currently the executor only supports FOR UPDATE/SHARE at top level
             */
            if (root->query_level > 1)
                  ereport(ERROR,
                              (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("SELECT FOR UPDATE/SHARE is not allowed in subqueries")));

            foreach(l, parse->rowMarks)
            {
                  RowMarkClause *rc = (RowMarkClause *) lfirst(l);
                  Var            *var;
                  char     *resname;
                  TargetEntry *tle;

                  /* ignore child rels */
                  if (rc->rti != rc->prti)
                        continue;

                  /* always need the ctid */
                  var = makeVar(rc->rti,
                                      SelfItemPointerAttributeNumber,
                                      TIDOID,
                                      -1,
                                      0);

                  resname = (char *) palloc(32);
                  snprintf(resname, 32, "ctid%u", rc->rti);

                  tle = makeTargetEntry((Expr *) var,
                                                  list_length(tlist) + 1,
                                                  resname,
                                                  true);

                  tlist = lappend(tlist, tle);

                  /* if parent of inheritance tree, need the tableoid too */
                  if (rc->isParent)
                  {
                        var = makeVar(rc->rti,
                                            TableOidAttributeNumber,
                                            OIDOID,
                                            -1,
                                            0);

                        resname = (char *) palloc(32);
                        snprintf(resname, 32, "tableoid%u", rc->rti);

                        tle = makeTargetEntry((Expr *) var,
                                                        list_length(tlist) + 1,
                                                        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, true);
            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((Node *) var, tlist))
                        continue;         /* already got it */

                  tle = makeTargetEntry((Expr *) var,
                                                  list_length(tlist) + 1,
                                                  NULL,
                                                  true);

                  tlist = lappend(tlist, tle);
            }
            list_free(vars);
      }

      return tlist;
}

/*****************************************************************************
 *
 *          TARGETLIST EXPANSION
 *
 *****************************************************************************/

/*
 * expand_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.
 *
 * NOTE: if you are tempted to put more processing here, consider whether
 * it shouldn't go in the rewriter's rewriteTargetList() instead.
 */
static List *
expand_targetlist(List *tlist, int command_type,
                          Index result_relation, List *range_table)
{
      List     *new_tlist = NIL;
      ListCell   *tlist_item;
      Relation    rel;
      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.  We assume
       * that the rewriter already acquired at least AccessShareLock on the
       * relation, so we need no lock here.
       */
      rel = heap_open(getrelid(result_relation, range_table), NoLock);

      numattrs = RelationGetNumberOfAttributes(rel);

      for (attrno = 1; attrno <= numattrs; attrno++)
      {
            Form_pg_attribute att_tup = rel->rd_att->attrs[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_item);
                  }
            }

            if (new_tle == NULL)
            {
                  /*
                   * Didn't find a matching tlist entry, so make one.
                   *
                   * For INSERT, generate a NULL constant.  (We assume the rewriter
                   * would have inserted any available default value.) Also, if the
                   * column isn't dropped, apply any domain constraints that might
                   * exist --- this is to catch domain NOT NULL.
                   *
                   * For UPDATE, generate a Var reference to the existing value of
                   * the attribute, so that it gets copied to the new tuple. But
                   * generate a NULL for dropped columns (we want to drop any old
                   * values).
                   *
                   * 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.
                   */
                  Oid               atttype = att_tup->atttypid;
                  int32       atttypmod = att_tup->atttypmod;
                  Node     *new_expr;

                  switch (command_type)
                  {
                        case CMD_INSERT:
                              if (!att_tup->attisdropped)
                              {
                                    new_expr = (Node *) makeConst(atttype,
                                                                                -1,
                                                                                att_tup->attlen,
                                                                                (Datum) 0,
                                                                                true,           /* isnull */
                                                                                att_tup->attbyval);
                                    new_expr = coerce_to_domain(new_expr,
                                                                              InvalidOid, -1,
                                                                              atttype,
                                                                              COERCE_IMPLICIT_CAST,
                                                                              -1,
                                                                              false,
                                                                              false);
                              }
                              else
                              {
                                    /* Insert NULL for dropped column */
                                    new_expr = (Node *) makeConst(INT4OID,
                                                                                -1,
                                                                                sizeof(int32),
                                                                                (Datum) 0,
                                                                                true,           /* isnull */
                                                                                true /* byval */ );
                              }
                              break;
                        case CMD_UPDATE:
                              if (!att_tup->attisdropped)
                              {
                                    new_expr = (Node *) makeVar(result_relation,
                                                                              attrno,
                                                                              atttype,
                                                                              atttypmod,
                                                                              0);
                              }
                              else
                              {
                                    /* Insert NULL for dropped column */
                                    new_expr = (Node *) makeConst(INT4OID,
                                                                                -1,
                                                                                sizeof(int32),
                                                                                (Datum) 0,
                                                                                true,           /* isnull */
                                                                                true /* byval */ );
                              }
                              break;
                        default:
                              elog(ERROR, "unrecognized command_type: %d",
                                     (int) command_type);
                              new_expr = NULL;  /* keep compiler quiet */
                              break;
                  }

                  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 are doing an UPDATE
       * in a table with dropped columns, or an inheritance child table with
       * extra columns.)
       */
      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_item);
      }

      heap_close(rel, NoLock);

      return new_tlist;
}

Generated by  Doxygen 1.6.0   Back to index