granicus.if.org Git - postgresql/blob - src/backend/rewrite/rewriteHandler.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * rewriteHandler.c
   4  *              Primary module of query rewriter.
   5  *
   6  * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  * IDENTIFICATION
  10  *        $PostgreSQL: pgsql/src/backend/rewrite/rewriteHandler.c,v 1.171 2007/03/01 18:50:28 tgl Exp $
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #include "postgres.h"
  15
  16 #include "access/heapam.h"
  17 #include "catalog/pg_type.h"
  18 #include "nodes/makefuncs.h"
  19 #include "optimizer/clauses.h"
  20 #include "parser/analyze.h"
  21 #include "parser/parse_coerce.h"
  22 #include "parser/parse_expr.h"
  23 #include "parser/parsetree.h"
  24 #include "rewrite/rewriteHandler.h"
  25 #include "rewrite/rewriteManip.h"
  26 #include "utils/builtins.h"
  27 #include "utils/lsyscache.h"
  28
  29
  30 /* We use a list of these to detect recursion in RewriteQuery */
  31 typedef struct rewrite_event
  32 {
  33         Oid                     relation;               /* OID of relation having rules */
  34         CmdType         event;                  /* type of rule being fired */
  35 } rewrite_event;
  36
  37 static bool acquireLocksOnSubLinks(Node *node, void *context);
  38 static Query *rewriteRuleAction(Query *parsetree,
  39                                   Query *rule_action,
  40                                   Node *rule_qual,
  41                                   int rt_index,
  42                                   CmdType event,
  43                                   bool *returning_flag);
  44 static List *adjustJoinTreeList(Query *parsetree, bool removert, int rt_index);
  45 static void rewriteTargetList(Query *parsetree, Relation target_relation,
  46                                   List **attrno_list);
  47 static TargetEntry *process_matched_tle(TargetEntry *src_tle,
  48                                         TargetEntry *prior_tle,
  49                                         const char *attrName);
  50 static Node *get_assignment_input(Node *node);
  51 static void rewriteValuesRTE(RangeTblEntry *rte, Relation target_relation,
  52                                  List *attrnos);
  53 static void markQueryForLocking(Query *qry, Node *jtnode,
  54                                                                 bool forUpdate, bool noWait);
  55 static List *matchLocks(CmdType event, RuleLock *rulelocks,
  56                    int varno, Query *parsetree);
  57 static Query *fireRIRrules(Query *parsetree, List *activeRIRs);
  58
  59
  60 /*
  61  * AcquireRewriteLocks -
  62  *        Acquire suitable locks on all the relations mentioned in the Query.
  63  *        These locks will ensure that the relation schemas don't change under us
  64  *        while we are rewriting and planning the query.
  65  *
  66  * A secondary purpose of this routine is to fix up JOIN RTE references to
  67  * dropped columns (see details below).  Because the RTEs are modified in
  68  * place, it is generally appropriate for the caller of this routine to have
  69  * first done a copyObject() to make a writable copy of the querytree in the
  70  * current memory context.
  71  *
  72  * This processing can, and for efficiency's sake should, be skipped when the
  73  * querytree has just been built by the parser: parse analysis already got
  74  * all the same locks we'd get here, and the parser will have omitted dropped
  75  * columns from JOINs to begin with.  But we must do this whenever we are
  76  * dealing with a querytree produced earlier than the current command.
  77  *
  78  * About JOINs and dropped columns: although the parser never includes an
  79  * already-dropped column in a JOIN RTE's alias var list, it is possible for
  80  * such a list in a stored rule to include references to dropped columns.
  81  * (If the column is not explicitly referenced anywhere else in the query,
  82  * the dependency mechanism won't consider it used by the rule and so won't
  83  * prevent the column drop.)  To support get_rte_attribute_is_dropped(),
  84  * we replace join alias vars that reference dropped columns with NULL Const
  85  * nodes.
  86  *
  87  * (In PostgreSQL 8.0, we did not do this processing but instead had
  88  * get_rte_attribute_is_dropped() recurse to detect dropped columns in joins.
  89  * That approach had horrible performance unfortunately; in particular
  90  * construction of a nested join was O(N^2) in the nesting depth.)
  91  */
  92 void
  93 AcquireRewriteLocks(Query *parsetree)
  94 {
  95         ListCell   *l;
  96         int                     rt_index;
  97
  98         /*
  99          * First, process RTEs of the current query level.
 100          */
 101         rt_index = 0;
 102         foreach(l, parsetree->rtable)
 103         {
 104                 RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
 105                 Relation        rel;
 106                 LOCKMODE        lockmode;
 107                 List       *newaliasvars;
 108                 Index           curinputvarno;
 109                 RangeTblEntry *curinputrte;
 110                 ListCell   *ll;
 111
 112                 ++rt_index;
 113                 switch (rte->rtekind)
 114                 {
 115                         case RTE_RELATION:
 116
 117                                 /*
 118                                  * Grab the appropriate lock type for the relation, and do not
 119                                  * release it until end of transaction. This protects the
 120                                  * rewriter and planner against schema changes mid-query.
 121                                  *
 122                                  * If the relation is the query's result relation, then we
 123                                  * need RowExclusiveLock.  Otherwise, check to see if the
 124                                  * relation is accessed FOR UPDATE/SHARE or not.  We can't
 125                                  * just grab AccessShareLock because then the executor would
 126                                  * be trying to upgrade the lock, leading to possible
 127                                  * deadlocks.
 128                                  */
 129                                 if (rt_index == parsetree->resultRelation)
 130                                         lockmode = RowExclusiveLock;
 131                                 else if (get_rowmark(parsetree, rt_index))
 132                                         lockmode = RowShareLock;
 133                                 else
 134                                         lockmode = AccessShareLock;
 135
 136                                 rel = heap_open(rte->relid, lockmode);
 137                                 heap_close(rel, NoLock);
 138                                 break;
 139
 140                         case RTE_JOIN:
 141
 142                                 /*
 143                                  * Scan the join's alias var list to see if any columns have
 144                                  * been dropped, and if so replace those Vars with NULL
 145                                  * Consts.
 146                                  *
 147                                  * Since a join has only two inputs, we can expect to see
 148                                  * multiple references to the same input RTE; optimize away
 149                                  * multiple fetches.
 150                                  */
 151                                 newaliasvars = NIL;
 152                                 curinputvarno = 0;
 153                                 curinputrte = NULL;
 154                                 foreach(ll, rte->joinaliasvars)
 155                                 {
 156                                         Var                *aliasvar = (Var *) lfirst(ll);
 157
 158                                         /*
 159                                          * If the list item isn't a simple Var, then it must
 160                                          * represent a merged column, ie a USING column, and so it
 161                                          * couldn't possibly be dropped, since it's referenced in
 162                                          * the join clause.  (Conceivably it could also be a NULL
 163                                          * constant already?  But that's OK too.)
 164                                          */
 165                                         if (IsA(aliasvar, Var))
 166                                         {
 167                                                 /*
 168                                                  * The elements of an alias list have to refer to
 169                                                  * earlier RTEs of the same rtable, because that's the
 170                                                  * order the planner builds things in.  So we already
 171                                                  * processed the referenced RTE, and so it's safe to
 172                                                  * use get_rte_attribute_is_dropped on it. (This might
 173                                                  * not hold after rewriting or planning, but it's OK
 174                                                  * to assume here.)
 175                                                  */
 176                                                 Assert(aliasvar->varlevelsup == 0);
 177                                                 if (aliasvar->varno != curinputvarno)
 178                                                 {
 179                                                         curinputvarno = aliasvar->varno;
 180                                                         if (curinputvarno >= rt_index)
 181                                                                 elog(ERROR, "unexpected varno %d in JOIN RTE %d",
 182                                                                          curinputvarno, rt_index);
 183                                                         curinputrte = rt_fetch(curinputvarno,
 184                                                                                                    parsetree->rtable);
 185                                                 }
 186                                                 if (get_rte_attribute_is_dropped(curinputrte,
 187                                                                                                                  aliasvar->varattno))
 188                                                 {
 189                                                         /*
 190                                                          * can't use vartype here, since that might be a
 191                                                          * now-dropped type OID, but it doesn't really
 192                                                          * matter what type the Const claims to be.
 193                                                          */
 194                                                         aliasvar = (Var *) makeNullConst(INT4OID);
 195                                                 }
 196                                         }
 197                                         newaliasvars = lappend(newaliasvars, aliasvar);
 198                                 }
 199                                 rte->joinaliasvars = newaliasvars;
 200                                 break;
 201
 202                         case RTE_SUBQUERY:
 203
 204                                 /*
 205                                  * The subquery RTE itself is all right, but we have to
 206                                  * recurse to process the represented subquery.
 207                                  */
 208                                 AcquireRewriteLocks(rte->subquery);
 209                                 break;
 210
 211                         default:
 212                                 /* ignore other types of RTEs */
 213                                 break;
 214                 }
 215         }
 216
 217         /*
 218          * Recurse into sublink subqueries, too.  But we already did the ones in
 219          * the rtable.
 220          */
 221         if (parsetree->hasSubLinks)
 222                 query_tree_walker(parsetree, acquireLocksOnSubLinks, NULL,
 223                                                   QTW_IGNORE_RT_SUBQUERIES);
 224 }
 225
 226 /*
 227  * Walker to find sublink subqueries for AcquireRewriteLocks
 228  */
 229 static bool
 230 acquireLocksOnSubLinks(Node *node, void *context)
 231 {
 232         if (node == NULL)
 233                 return false;
 234         if (IsA(node, SubLink))
 235         {
 236                 SubLink    *sub = (SubLink *) node;
 237
 238                 /* Do what we came for */
 239                 AcquireRewriteLocks((Query *) sub->subselect);
 240                 /* Fall through to process lefthand args of SubLink */
 241         }
 242
 243         /*
 244          * Do NOT recurse into Query nodes, because AcquireRewriteLocks already
 245          * processed subselects of subselects for us.
 246          */
 247         return expression_tree_walker(node, acquireLocksOnSubLinks, context);
 248 }
 249
 250
 251 /*
 252  * rewriteRuleAction -
 253  *        Rewrite the rule action with appropriate qualifiers (taken from
 254  *        the triggering query).
 255  *
 256  * Input arguments:
 257  *      parsetree - original query
 258  *      rule_action - one action (query) of a rule
 259  *      rule_qual - WHERE condition of rule, or NULL if unconditional
 260  *      rt_index - RT index of result relation in original query
 261  *      event - type of rule event
 262  * Output arguments:
 263  *      *returning_flag - set TRUE if we rewrite RETURNING clause in rule_action
 264  *                                      (must be initialized to FALSE)
 265  * Return value:
 266  *      rewritten form of rule_action
 267  */
 268 static Query *
 269 rewriteRuleAction(Query *parsetree,
 270                                   Query *rule_action,
 271                                   Node *rule_qual,
 272                                   int rt_index,
 273                                   CmdType event,
 274                                   bool *returning_flag)
 275 {
 276         int                     current_varno,
 277                                 new_varno;
 278         int                     rt_length;
 279         Query      *sub_action;
 280         Query     **sub_action_ptr;
 281
 282         /*
 283          * Make modifiable copies of rule action and qual (what we're passed are
 284          * the stored versions in the relcache; don't touch 'em!).
 285          */
 286         rule_action = (Query *) copyObject(rule_action);
 287         rule_qual = (Node *) copyObject(rule_qual);
 288
 289         /*
 290          * Acquire necessary locks and fix any deleted JOIN RTE entries.
 291          */
 292         AcquireRewriteLocks(rule_action);
 293         (void) acquireLocksOnSubLinks(rule_qual, NULL);
 294
 295         current_varno = rt_index;
 296         rt_length = list_length(parsetree->rtable);
 297         new_varno = PRS2_NEW_VARNO + rt_length;
 298
 299         /*
 300          * Adjust rule action and qual to offset its varnos, so that we can merge
 301          * its rtable with the main parsetree's rtable.
 302          *
 303          * If the rule action is an INSERT...SELECT, the OLD/NEW rtable entries
 304          * will be in the SELECT part, and we have to modify that rather than the
 305          * top-level INSERT (kluge!).
 306          */
 307         sub_action = getInsertSelectQuery(rule_action, &sub_action_ptr);
 308
 309         OffsetVarNodes((Node *) sub_action, rt_length, 0);
 310         OffsetVarNodes(rule_qual, rt_length, 0);
 311         /* but references to *OLD* should point at original rt_index */
 312         ChangeVarNodes((Node *) sub_action,
 313                                    PRS2_OLD_VARNO + rt_length, rt_index, 0);
 314         ChangeVarNodes(rule_qual,
 315                                    PRS2_OLD_VARNO + rt_length, rt_index, 0);
 316
 317         /*
 318          * Generate expanded rtable consisting of main parsetree's rtable plus
 319          * rule action's rtable; this becomes the complete rtable for the rule
 320          * action.      Some of the entries may be unused after we finish rewriting,
 321          * but we leave them all in place for two reasons:
 322          *
 323          * We'd have a much harder job to adjust the query's varnos if we
 324          * selectively removed RT entries.
 325          *
 326          * If the rule is INSTEAD, then the original query won't be executed at
 327          * all, and so its rtable must be preserved so that the executor will do
 328          * the correct permissions checks on it.
 329          *
 330          * RT entries that are not referenced in the completed jointree will be
 331          * ignored by the planner, so they do not affect query semantics.  But any
 332          * permissions checks specified in them will be applied during executor
 333          * startup (see ExecCheckRTEPerms()).  This allows us to check that the
 334          * caller has, say, insert-permission on a view, when the view is not
 335          * semantically referenced at all in the resulting query.
 336          *
 337          * When a rule is not INSTEAD, the permissions checks done on its copied
 338          * RT entries will be redundant with those done during execution of the
 339          * original query, but we don't bother to treat that case differently.
 340          *
 341          * NOTE: because planner will destructively alter rtable, we must ensure
 342          * that rule action's rtable is separate and shares no substructure with
 343          * the main rtable.  Hence do a deep copy here.
 344          */
 345         sub_action->rtable = list_concat((List *) copyObject(parsetree->rtable),
 346                                                                          sub_action->rtable);
 347
 348         /*
 349          * Each rule action's jointree should be the main parsetree's jointree
 350          * plus that rule's jointree, but usually *without* the original rtindex
 351          * that we're replacing (if present, which it won't be for INSERT). Note
 352          * that if the rule action refers to OLD, its jointree will add a
 353          * reference to rt_index.  If the rule action doesn't refer to OLD, but
 354          * either the rule_qual or the user query quals do, then we need to keep
 355          * the original rtindex in the jointree to provide data for the quals.  We
 356          * don't want the original rtindex to be joined twice, however, so avoid
 357          * keeping it if the rule action mentions it.
 358          *
 359          * As above, the action's jointree must not share substructure with the
 360          * main parsetree's.
 361          */
 362         if (sub_action->commandType != CMD_UTILITY)
 363         {
 364                 bool            keeporig;
 365                 List       *newjointree;
 366
 367                 Assert(sub_action->jointree != NULL);
 368                 keeporig = (!rangeTableEntry_used((Node *) sub_action->jointree,
 369                                                                                   rt_index, 0)) &&
 370                         (rangeTableEntry_used(rule_qual, rt_index, 0) ||
 371                          rangeTableEntry_used(parsetree->jointree->quals, rt_index, 0));
 372                 newjointree = adjustJoinTreeList(parsetree, !keeporig, rt_index);
 373                 if (newjointree != NIL)
 374                 {
 375                         /*
 376                          * If sub_action is a setop, manipulating its jointree will do no
 377                          * good at all, because the jointree is dummy.  (Perhaps someday
 378                          * we could push the joining and quals down to the member
 379                          * statements of the setop?)
 380                          */
 381                         if (sub_action->setOperations != NULL)
 382                                 ereport(ERROR,
 383                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 384                                                  errmsg("conditional UNION/INTERSECT/EXCEPT statements are not implemented")));
 385
 386                         sub_action->jointree->fromlist =
 387                                 list_concat(newjointree, sub_action->jointree->fromlist);
 388
 389                         /*
 390                          * There could have been some SubLinks in newjointree, in which
 391                          * case we'd better mark the sub_action correctly.
 392                          */
 393                         if (parsetree->hasSubLinks && !sub_action->hasSubLinks)
 394                                 sub_action->hasSubLinks =
 395                                         checkExprHasSubLink((Node *) newjointree);
 396                 }
 397         }
 398
 399         /*
 400          * Event Qualification forces copying of parsetree and splitting into two
 401          * queries one w/rule_qual, one w/NOT rule_qual. Also add user query qual
 402          * onto rule action
 403          */
 404         AddQual(sub_action, rule_qual);
 405
 406         AddQual(sub_action, parsetree->jointree->quals);
 407
 408         /*
 409          * Rewrite new.attribute w/ right hand side of target-list entry for
 410          * appropriate field name in insert/update.
 411          *
 412          * KLUGE ALERT: since ResolveNew returns a mutated copy, we can't just
 413          * apply it to sub_action; we have to remember to update the sublink
 414          * inside rule_action, too.
 415          */
 416         if ((event == CMD_INSERT || event == CMD_UPDATE) &&
 417                 sub_action->commandType != CMD_UTILITY)
 418         {
 419                 sub_action = (Query *) ResolveNew((Node *) sub_action,
 420                                                                                   new_varno,
 421                                                                                   0,
 422                                                                                   rt_fetch(new_varno,
 423                                                                                                    sub_action->rtable),
 424                                                                                   parsetree->targetList,
 425                                                                                   event,
 426                                                                                   current_varno);
 427                 if (sub_action_ptr)
 428                         *sub_action_ptr = sub_action;
 429                 else
 430                         rule_action = sub_action;
 431         }
 432
 433         /*
 434          * If rule_action has a RETURNING clause, then either throw it away if the
 435          * triggering query has no RETURNING clause, or rewrite it to emit what
 436          * the triggering query's RETURNING clause asks for.  Throw an error if
 437          * more than one rule has a RETURNING clause.
 438          */
 439         if (!parsetree->returningList)
 440                 rule_action->returningList = NIL;
 441         else if (rule_action->returningList)
 442         {
 443                 if (*returning_flag)
 444                         ereport(ERROR,
 445                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 446                                    errmsg("cannot have RETURNING lists in multiple rules")));
 447                 *returning_flag = true;
 448                 rule_action->returningList = (List *)
 449                         ResolveNew((Node *) parsetree->returningList,
 450                                            parsetree->resultRelation,
 451                                            0,
 452                                            rt_fetch(parsetree->resultRelation,
 453                                                                 parsetree->rtable),
 454                                            rule_action->returningList,
 455                                            CMD_SELECT,
 456                                            0);
 457         }
 458
 459         return rule_action;
 460 }
 461
 462 /*
 463  * Copy the query's jointree list, and optionally attempt to remove any
 464  * occurrence of the given rt_index as a top-level join item (we do not look
 465  * for it within join items; this is OK because we are only expecting to find
 466  * it as an UPDATE or DELETE target relation, which will be at the top level
 467  * of the join).  Returns modified jointree list --- this is a separate copy
 468  * sharing no nodes with the original.
 469  */
 470 static List *
 471 adjustJoinTreeList(Query *parsetree, bool removert, int rt_index)
 472 {
 473         List       *newjointree = copyObject(parsetree->jointree->fromlist);
 474         ListCell   *l;
 475
 476         if (removert)
 477         {
 478                 foreach(l, newjointree)
 479                 {
 480                         RangeTblRef *rtr = lfirst(l);
 481
 482                         if (IsA(rtr, RangeTblRef) &&
 483                                 rtr->rtindex == rt_index)
 484                         {
 485                                 newjointree = list_delete_ptr(newjointree, rtr);
 486
 487                                 /*
 488                                  * foreach is safe because we exit loop after list_delete...
 489                                  */
 490                                 break;
 491                         }
 492                 }
 493         }
 494         return newjointree;
 495 }
 496
 497
 498 /*
 499  * rewriteTargetList - rewrite INSERT/UPDATE targetlist into standard form
 500  *
 501  * This has the following responsibilities:
 502  *
 503  * 1. For an INSERT, add tlist entries to compute default values for any
 504  * attributes that have defaults and are not assigned to in the given tlist.
 505  * (We do not insert anything for default-less attributes, however.  The
 506  * planner will later insert NULLs for them, but there's no reason to slow
 507  * down rewriter processing with extra tlist nodes.)  Also, for both INSERT
 508  * and UPDATE, replace explicit DEFAULT specifications with column default
 509  * expressions.
 510  *
 511  * 2. Merge multiple entries for the same target attribute, or declare error
 512  * if we can't.  Multiple entries are only allowed for INSERT/UPDATE of
 513  * portions of an array or record field, for example
 514  *                      UPDATE table SET foo[2] = 42, foo[4] = 43;
 515  * We can merge such operations into a single assignment op.  Essentially,
 516  * the expression we want to produce in this case is like
 517  *              foo = array_set(array_set(foo, 2, 42), 4, 43)
 518  *
 519  * 3. Sort the tlist into standard order: non-junk fields in order by resno,
 520  * then junk fields (these in no particular order).
 521  *
 522  * We must do items 1 and 2 before firing rewrite rules, else rewritten
 523  * references to NEW.foo will produce wrong or incomplete results.      Item 3
 524  * is not needed for rewriting, but will be needed by the planner, and we
 525  * can do it essentially for free while handling items 1 and 2.
 526  *
 527  * If attrno_list isn't NULL, we return an additional output besides the
 528  * rewritten targetlist: an integer list of the assigned-to attnums, in
 529  * order of the original tlist's non-junk entries.  This is needed for
 530  * processing VALUES RTEs.
 531  */
 532 static void
 533 rewriteTargetList(Query *parsetree, Relation target_relation,
 534                                   List **attrno_list)
 535 {
 536         CmdType         commandType = parsetree->commandType;
 537         TargetEntry **new_tles;
 538         List       *new_tlist = NIL;
 539         List       *junk_tlist = NIL;
 540         Form_pg_attribute att_tup;
 541         int                     attrno,
 542                                 next_junk_attrno,
 543                                 numattrs;
 544         ListCell   *temp;
 545
 546         if (attrno_list)                        /* initialize optional result list */
 547                 *attrno_list = NIL;
 548
 549         /*
 550          * We process the normal (non-junk) attributes by scanning the input tlist
 551          * once and transferring TLEs into an array, then scanning the array to
 552          * build an output tlist.  This avoids O(N^2) behavior for large numbers
 553          * of attributes.
 554          *
 555          * Junk attributes are tossed into a separate list during the same tlist
 556          * scan, then appended to the reconstructed tlist.
 557          */
 558         numattrs = RelationGetNumberOfAttributes(target_relation);
 559         new_tles = (TargetEntry **) palloc0(numattrs * sizeof(TargetEntry *));
 560         next_junk_attrno = numattrs + 1;
 561
 562         foreach(temp, parsetree->targetList)
 563         {
 564                 TargetEntry *old_tle = (TargetEntry *) lfirst(temp);
 565
 566                 if (!old_tle->resjunk)
 567                 {
 568                         /* Normal attr: stash it into new_tles[] */
 569                         attrno = old_tle->resno;
 570                         if (attrno < 1 || attrno > numattrs)
 571                                 elog(ERROR, "bogus resno %d in targetlist", attrno);
 572                         att_tup = target_relation->rd_att->attrs[attrno - 1];
 573
 574                         /* put attrno into attrno_list even if it's dropped */
 575                         if (attrno_list)
 576                                 *attrno_list = lappend_int(*attrno_list, attrno);
 577
 578                         /* We can (and must) ignore deleted attributes */
 579                         if (att_tup->attisdropped)
 580                                 continue;
 581
 582                         /* Merge with any prior assignment to same attribute */
 583                         new_tles[attrno - 1] =
 584                                 process_matched_tle(old_tle,
 585                                                                         new_tles[attrno - 1],
 586                                                                         NameStr(att_tup->attname));
 587                 }
 588                 else
 589                 {
 590                         /*
 591                          * Copy all resjunk tlist entries to junk_tlist, and assign them
 592                          * resnos above the last real resno.
 593                          *
 594                          * Typical junk entries include ORDER BY or GROUP BY expressions
 595                          * (are these actually possible in an INSERT or UPDATE?), system
 596                          * attribute references, etc.
 597                          */
 598
 599                         /* Get the resno right, but don't copy unnecessarily */
 600                         if (old_tle->resno != next_junk_attrno)
 601                         {
 602                                 old_tle = flatCopyTargetEntry(old_tle);
 603                                 old_tle->resno = next_junk_attrno;
 604                         }
 605                         junk_tlist = lappend(junk_tlist, old_tle);
 606                         next_junk_attrno++;
 607                 }
 608         }
 609
 610         for (attrno = 1; attrno <= numattrs; attrno++)
 611         {
 612                 TargetEntry *new_tle = new_tles[attrno - 1];
 613
 614                 att_tup = target_relation->rd_att->attrs[attrno - 1];
 615
 616                 /* We can (and must) ignore deleted attributes */
 617                 if (att_tup->attisdropped)
 618                         continue;
 619
 620                 /*
 621                  * Handle the two cases where we need to insert a default expression:
 622                  * it's an INSERT and there's no tlist entry for the column, or the
 623                  * tlist entry is a DEFAULT placeholder node.
 624                  */
 625                 if ((new_tle == NULL && commandType == CMD_INSERT) ||
 626                         (new_tle && new_tle->expr && IsA(new_tle->expr, SetToDefault)))
 627                 {
 628                         Node       *new_expr;
 629
 630                         new_expr = build_column_default(target_relation, attrno);
 631
 632                         /*
 633                          * If there is no default (ie, default is effectively NULL), we
 634                          * can omit the tlist entry in the INSERT case, since the planner
 635                          * can insert a NULL for itself, and there's no point in spending
 636                          * any more rewriter cycles on the entry.  But in the UPDATE case
 637                          * we've got to explicitly set the column to NULL.
 638                          */
 639                         if (!new_expr)
 640                         {
 641                                 if (commandType == CMD_INSERT)
 642                                         new_tle = NULL;
 643                                 else
 644                                 {
 645                                         new_expr = (Node *) makeConst(att_tup->atttypid,
 646                                                                                                   att_tup->attlen,
 647                                                                                                   (Datum) 0,
 648                                                                                                   true, /* isnull */
 649                                                                                                   att_tup->attbyval);
 650                                         /* this is to catch a NOT NULL domain constraint */
 651                                         new_expr = coerce_to_domain(new_expr,
 652                                                                                                 InvalidOid, -1,
 653                                                                                                 att_tup->atttypid,
 654                                                                                                 COERCE_IMPLICIT_CAST,
 655                                                                                                 false,
 656                                                                                                 false);
 657                                 }
 658                         }
 659
 660                         if (new_expr)
 661                                 new_tle = makeTargetEntry((Expr *) new_expr,
 662                                                                                   attrno,
 663                                                                                   pstrdup(NameStr(att_tup->attname)),
 664                                                                                   false);
 665                 }
 666
 667                 if (new_tle)
 668                         new_tlist = lappend(new_tlist, new_tle);
 669         }
 670
 671         pfree(new_tles);
 672
 673         parsetree->targetList = list_concat(new_tlist, junk_tlist);
 674 }
 675
 676
 677 /*
 678  * Convert a matched TLE from the original tlist into a correct new TLE.
 679  *
 680  * This routine detects and handles multiple assignments to the same target
 681  * attribute.  (The attribute name is needed only for error messages.)
 682  */
 683 static TargetEntry *
 684 process_matched_tle(TargetEntry *src_tle,
 685                                         TargetEntry *prior_tle,
 686                                         const char *attrName)
 687 {
 688         TargetEntry *result;
 689         Node       *src_expr;
 690         Node       *prior_expr;
 691         Node       *src_input;
 692         Node       *prior_input;
 693         Node       *priorbottom;
 694         Node       *newexpr;
 695
 696         if (prior_tle == NULL)
 697         {
 698                 /*
 699                  * Normal case where this is the first assignment to the attribute.
 700                  */
 701                 return src_tle;
 702         }
 703
 704         /*----------
 705          * Multiple assignments to same attribute.      Allow only if all are
 706          * FieldStore or ArrayRef assignment operations.  This is a bit
 707          * tricky because what we may actually be looking at is a nest of
 708          * such nodes; consider
 709          *              UPDATE tab SET col.fld1.subfld1 = x, col.fld2.subfld2 = y
 710          * The two expressions produced by the parser will look like
 711          *              FieldStore(col, fld1, FieldStore(placeholder, subfld1, x))
 712          *              FieldStore(col, fld2, FieldStore(placeholder, subfld2, x))
 713          * However, we can ignore the substructure and just consider the top
 714          * FieldStore or ArrayRef from each assignment, because it works to
 715          * combine these as
 716          *              FieldStore(FieldStore(col, fld1,
 717          *                                                        FieldStore(placeholder, subfld1, x)),
 718          *                                 fld2, FieldStore(placeholder, subfld2, x))
 719          * Note the leftmost expression goes on the inside so that the
 720          * assignments appear to occur left-to-right.
 721          *
 722          * For FieldStore, instead of nesting we can generate a single
 723          * FieldStore with multiple target fields.      We must nest when
 724          * ArrayRefs are involved though.
 725          *----------
 726          */
 727         src_expr = (Node *) src_tle->expr;
 728         prior_expr = (Node *) prior_tle->expr;
 729         src_input = get_assignment_input(src_expr);
 730         prior_input = get_assignment_input(prior_expr);
 731         if (src_input == NULL ||
 732                 prior_input == NULL ||
 733                 exprType(src_expr) != exprType(prior_expr))
 734                 ereport(ERROR,
 735                                 (errcode(ERRCODE_SYNTAX_ERROR),
 736                                  errmsg("multiple assignments to same column \"%s\"",
 737                                                 attrName)));
 738
 739         /*
 740          * Prior TLE could be a nest of assignments if we do this more than once.
 741          */
 742         priorbottom = prior_input;
 743         for (;;)
 744         {
 745                 Node       *newbottom = get_assignment_input(priorbottom);
 746
 747                 if (newbottom == NULL)
 748                         break;                          /* found the original Var reference */
 749                 priorbottom = newbottom;
 750         }
 751         if (!equal(priorbottom, src_input))
 752                 ereport(ERROR,
 753                                 (errcode(ERRCODE_SYNTAX_ERROR),
 754                                  errmsg("multiple assignments to same column \"%s\"",
 755                                                 attrName)));
 756
 757         /*
 758          * Looks OK to nest 'em.
 759          */
 760         if (IsA(src_expr, FieldStore))
 761         {
 762                 FieldStore *fstore = makeNode(FieldStore);
 763
 764                 if (IsA(prior_expr, FieldStore))
 765                 {
 766                         /* combine the two */
 767                         memcpy(fstore, prior_expr, sizeof(FieldStore));
 768                         fstore->newvals =
 769                                 list_concat(list_copy(((FieldStore *) prior_expr)->newvals),
 770                                                         list_copy(((FieldStore *) src_expr)->newvals));
 771                         fstore->fieldnums =
 772                                 list_concat(list_copy(((FieldStore *) prior_expr)->fieldnums),
 773                                                         list_copy(((FieldStore *) src_expr)->fieldnums));
 774                 }
 775                 else
 776                 {
 777                         /* general case, just nest 'em */
 778                         memcpy(fstore, src_expr, sizeof(FieldStore));
 779                         fstore->arg = (Expr *) prior_expr;
 780                 }
 781                 newexpr = (Node *) fstore;
 782         }
 783         else if (IsA(src_expr, ArrayRef))
 784         {
 785                 ArrayRef   *aref = makeNode(ArrayRef);
 786
 787                 memcpy(aref, src_expr, sizeof(ArrayRef));
 788                 aref->refexpr = (Expr *) prior_expr;
 789                 newexpr = (Node *) aref;
 790         }
 791         else
 792         {
 793                 elog(ERROR, "cannot happen");
 794                 newexpr = NULL;
 795         }
 796
 797         result = flatCopyTargetEntry(src_tle);
 798         result->expr = (Expr *) newexpr;
 799         return result;
 800 }
 801
 802 /*
 803  * If node is an assignment node, return its input; else return NULL
 804  */
 805 static Node *
 806 get_assignment_input(Node *node)
 807 {
 808         if (node == NULL)
 809                 return NULL;
 810         if (IsA(node, FieldStore))
 811         {
 812                 FieldStore *fstore = (FieldStore *) node;
 813
 814                 return (Node *) fstore->arg;
 815         }
 816         else if (IsA(node, ArrayRef))
 817         {
 818                 ArrayRef   *aref = (ArrayRef *) node;
 819
 820                 if (aref->refassgnexpr == NULL)
 821                         return NULL;
 822                 return (Node *) aref->refexpr;
 823         }
 824         return NULL;
 825 }
 826
 827 /*
 828  * Make an expression tree for the default value for a column.
 829  *
 830  * If there is no default, return a NULL instead.
 831  */
 832 Node *
 833 build_column_default(Relation rel, int attrno)
 834 {
 835         TupleDesc       rd_att = rel->rd_att;
 836         Form_pg_attribute att_tup = rd_att->attrs[attrno - 1];
 837         Oid                     atttype = att_tup->atttypid;
 838         int32           atttypmod = att_tup->atttypmod;
 839         Node       *expr = NULL;
 840         Oid                     exprtype;
 841
 842         /*
 843          * Scan to see if relation has a default for this column.
 844          */
 845         if (rd_att->constr && rd_att->constr->num_defval > 0)
 846         {
 847                 AttrDefault *defval = rd_att->constr->defval;
 848                 int                     ndef = rd_att->constr->num_defval;
 849
 850                 while (--ndef >= 0)
 851                 {
 852                         if (attrno == defval[ndef].adnum)
 853                         {
 854                                 /*
 855                                  * Found it, convert string representation to node tree.
 856                                  */
 857                                 expr = stringToNode(defval[ndef].adbin);
 858                                 break;
 859                         }
 860                 }
 861         }
 862
 863         if (expr == NULL)
 864         {
 865                 /*
 866                  * No per-column default, so look for a default for the type itself.
 867                  */
 868                 expr = get_typdefault(atttype);
 869         }
 870
 871         if (expr == NULL)
 872                 return NULL;                    /* No default anywhere */
 873
 874         /*
 875          * Make sure the value is coerced to the target column type; this will
 876          * generally be true already, but there seem to be some corner cases
 877          * involving domain defaults where it might not be true. This should match
 878          * the parser's processing of non-defaulted expressions --- see
 879          * transformAssignedExpr().
 880          */
 881         exprtype = exprType(expr);
 882
 883         expr = coerce_to_target_type(NULL,      /* no UNKNOWN params here */
 884                                                                  expr, exprtype,
 885                                                                  atttype, atttypmod,
 886                                                                  COERCION_ASSIGNMENT,
 887                                                                  COERCE_IMPLICIT_CAST);
 888         if (expr == NULL)
 889                 ereport(ERROR,
 890                                 (errcode(ERRCODE_DATATYPE_MISMATCH),
 891                                  errmsg("column \"%s\" is of type %s"
 892                                                 " but default expression is of type %s",
 893                                                 NameStr(att_tup->attname),
 894                                                 format_type_be(atttype),
 895                                                 format_type_be(exprtype)),
 896                            errhint("You will need to rewrite or cast the expression.")));
 897
 898         return expr;
 899 }
 900
 901
 902 /* Does VALUES RTE contain any SetToDefault items? */
 903 static bool
 904 searchForDefault(RangeTblEntry *rte)
 905 {
 906         ListCell   *lc;
 907
 908         foreach(lc, rte->values_lists)
 909         {
 910                 List       *sublist = (List *) lfirst(lc);
 911                 ListCell   *lc2;
 912
 913                 foreach(lc2, sublist)
 914                 {
 915                         Node       *col = (Node *) lfirst(lc2);
 916
 917                         if (IsA(col, SetToDefault))
 918                                 return true;
 919                 }
 920         }
 921         return false;
 922 }
 923
 924 /*
 925  * When processing INSERT ... VALUES with a VALUES RTE (ie, multiple VALUES
 926  * lists), we have to replace any DEFAULT items in the VALUES lists with
 927  * the appropriate default expressions.  The other aspects of rewriteTargetList
 928  * need be applied only to the query's targetlist proper.
 929  *
 930  * Note that we currently can't support subscripted or field assignment
 931  * in the multi-VALUES case.  The targetlist will contain simple Vars
 932  * referencing the VALUES RTE, and therefore process_matched_tle() will
 933  * reject any such attempt with "multiple assignments to same column".
 934  */
 935 static void
 936 rewriteValuesRTE(RangeTblEntry *rte, Relation target_relation, List *attrnos)
 937 {
 938         List       *newValues;
 939         ListCell   *lc;
 940
 941         /*
 942          * Rebuilding all the lists is a pretty expensive proposition in a big
 943          * VALUES list, and it's a waste of time if there aren't any DEFAULT
 944          * placeholders.  So first scan to see if there are any.
 945          */
 946         if (!searchForDefault(rte))
 947                 return;                                 /* nothing to do */
 948
 949         /* Check list lengths (we can assume all the VALUES sublists are alike) */
 950         Assert(list_length(attrnos) == list_length(linitial(rte->values_lists)));
 951
 952         newValues = NIL;
 953         foreach(lc, rte->values_lists)
 954         {
 955                 List       *sublist = (List *) lfirst(lc);
 956                 List       *newList = NIL;
 957                 ListCell   *lc2;
 958                 ListCell   *lc3;
 959
 960                 forboth(lc2, sublist, lc3, attrnos)
 961                 {
 962                         Node       *col = (Node *) lfirst(lc2);
 963                         int                     attrno = lfirst_int(lc3);
 964
 965                         if (IsA(col, SetToDefault))
 966                         {
 967                                 Form_pg_attribute att_tup;
 968                                 Node       *new_expr;
 969
 970                                 att_tup = target_relation->rd_att->attrs[attrno - 1];
 971
 972                                 if (!att_tup->attisdropped)
 973                                         new_expr = build_column_default(target_relation, attrno);
 974                                 else
 975                                         new_expr = NULL;        /* force a NULL if dropped */
 976
 977                                 /*
 978                                  * If there is no default (ie, default is effectively NULL),
 979                                  * we've got to explicitly set the column to NULL.
 980                                  */
 981                                 if (!new_expr)
 982                                 {
 983                                         new_expr = (Node *) makeConst(att_tup->atttypid,
 984                                                                                                   att_tup->attlen,
 985                                                                                                   (Datum) 0,
 986                                                                                                   true, /* isnull */
 987                                                                                                   att_tup->attbyval);
 988                                         /* this is to catch a NOT NULL domain constraint */
 989                                         new_expr = coerce_to_domain(new_expr,
 990                                                                                                 InvalidOid, -1,
 991                                                                                                 att_tup->atttypid,
 992                                                                                                 COERCE_IMPLICIT_CAST,
 993                                                                                                 false,
 994                                                                                                 false);
 995                                 }
 996                                 newList = lappend(newList, new_expr);
 997                         }
 998                         else
 999                                 newList = lappend(newList, col);
1000                 }
1001                 newValues = lappend(newValues, newList);
1002         }
1003         rte->values_lists = newValues;
1004 }
1005
1006
1007 /*
1008  * matchLocks -
1009  *        match the list of locks and returns the matching rules
1010  */
1011 static List *
1012 matchLocks(CmdType event,
1013                    RuleLock *rulelocks,
1014                    int varno,
1015                    Query *parsetree)
1016 {
1017         List       *matching_locks = NIL;
1018         int                     nlocks;
1019         int                     i;
1020
1021         if (rulelocks == NULL)
1022                 return NIL;
1023
1024         if (parsetree->commandType != CMD_SELECT)
1025         {
1026                 if (parsetree->resultRelation != varno)
1027                         return NIL;
1028         }
1029
1030         nlocks = rulelocks->numLocks;
1031
1032         for (i = 0; i < nlocks; i++)
1033         {
1034                 RewriteRule *oneLock = rulelocks->rules[i];
1035
1036                 if (oneLock->event == event)
1037                 {
1038                         if (parsetree->commandType != CMD_SELECT ||
1039                                 (oneLock->attrno == -1 ?
1040                                  rangeTableEntry_used((Node *) parsetree, varno, 0) :
1041                                  attribute_used((Node *) parsetree,
1042                                                                 varno, oneLock->attrno, 0)))
1043                                 matching_locks = lappend(matching_locks, oneLock);
1044                 }
1045         }
1046
1047         return matching_locks;
1048 }
1049
1050
1051 /*
1052  * ApplyRetrieveRule - expand an ON SELECT rule
1053  */
1054 static Query *
1055 ApplyRetrieveRule(Query *parsetree,
1056                                   RewriteRule *rule,
1057                                   int rt_index,
1058                                   bool relation_level,
1059                                   Relation relation,
1060                                   List *activeRIRs)
1061 {
1062         Query      *rule_action;
1063         RangeTblEntry *rte,
1064                            *subrte;
1065         RowMarkClause *rc;
1066
1067         if (list_length(rule->actions) != 1)
1068                 elog(ERROR, "expected just one rule action");
1069         if (rule->qual != NULL)
1070                 elog(ERROR, "cannot handle qualified ON SELECT rule");
1071         if (!relation_level)
1072                 elog(ERROR, "cannot handle per-attribute ON SELECT rule");
1073
1074         /*
1075          * Make a modifiable copy of the view query, and acquire needed locks on
1076          * the relations it mentions.
1077          */
1078         rule_action = copyObject(linitial(rule->actions));
1079
1080         AcquireRewriteLocks(rule_action);
1081
1082         /*
1083          * Recursively expand any view references inside the view.
1084          */
1085         rule_action = fireRIRrules(rule_action, activeRIRs);
1086
1087         /*
1088          * VIEWs are really easy --- just plug the view query in as a subselect,
1089          * replacing the relation's original RTE.
1090          */
1091         rte = rt_fetch(rt_index, parsetree->rtable);
1092
1093         rte->rtekind = RTE_SUBQUERY;
1094         rte->relid = InvalidOid;
1095         rte->subquery = rule_action;
1096         rte->inh = false;                       /* must not be set for a subquery */
1097
1098         /*
1099          * We move the view's permission check data down to its rangetable. The
1100          * checks will actually be done against the *OLD* entry therein.
1101          */
1102         subrte = rt_fetch(PRS2_OLD_VARNO, rule_action->rtable);
1103         Assert(subrte->relid == relation->rd_id);
1104         subrte->requiredPerms = rte->requiredPerms;
1105         subrte->checkAsUser = rte->checkAsUser;
1106
1107         rte->requiredPerms = 0;         /* no permission check on subquery itself */
1108         rte->checkAsUser = InvalidOid;
1109
1110         /*
1111          * FOR UPDATE/SHARE of view?
1112          */
1113         if ((rc = get_rowmark(parsetree, rt_index)) != NULL)
1114         {
1115                 /*
1116                  * Remove the view from the list of rels that will actually be marked
1117                  * FOR UPDATE/SHARE by the executor.  It will still be access-checked
1118                  * for write access, though.
1119                  */
1120                 parsetree->rowMarks = list_delete_ptr(parsetree->rowMarks, rc);
1121
1122                 /*
1123                  * Set up the view's referenced tables as if FOR UPDATE/SHARE.
1124                  */
1125                 markQueryForLocking(rule_action, (Node *) rule_action->jointree,
1126                                                         rc->forUpdate, rc->noWait);
1127         }
1128
1129         return parsetree;
1130 }
1131
1132 /*
1133  * Recursively mark all relations used by a view as FOR UPDATE/SHARE.
1134  *
1135  * This may generate an invalid query, eg if some sub-query uses an
1136  * aggregate.  We leave it to the planner to detect that.
1137  *
1138  * NB: this must agree with the parser's transformLockingClause() routine.
1139  * However, unlike the parser we have to be careful not to mark a view's
1140  * OLD and NEW rels for updating.  The best way to handle that seems to be
1141  * to scan the jointree to determine which rels are used.
1142  */
1143 static void
1144 markQueryForLocking(Query *qry, Node *jtnode, bool forUpdate, bool noWait)
1145 {
1146         if (jtnode == NULL)
1147                 return;
1148         if (IsA(jtnode, RangeTblRef))
1149         {
1150                 int                     rti = ((RangeTblRef *) jtnode)->rtindex;
1151                 RangeTblEntry *rte = rt_fetch(rti, qry->rtable);
1152
1153                 if (rte->rtekind == RTE_RELATION)
1154                 {
1155                         applyLockingClause(qry, rti, forUpdate, noWait);
1156                         rte->requiredPerms |= ACL_SELECT_FOR_UPDATE;
1157                 }
1158                 else if (rte->rtekind == RTE_SUBQUERY)
1159                 {
1160                         /* FOR UPDATE/SHARE of subquery is propagated to subquery's rels */
1161                         markQueryForLocking(rte->subquery, (Node *) rte->subquery->jointree,
1162                                                                 forUpdate, noWait);
1163                 }
1164         }
1165         else if (IsA(jtnode, FromExpr))
1166         {
1167                 FromExpr   *f = (FromExpr *) jtnode;
1168                 ListCell   *l;
1169
1170                 foreach(l, f->fromlist)
1171                         markQueryForLocking(qry, lfirst(l), forUpdate, noWait);
1172         }
1173         else if (IsA(jtnode, JoinExpr))
1174         {
1175                 JoinExpr   *j = (JoinExpr *) jtnode;
1176
1177                 markQueryForLocking(qry, j->larg, forUpdate, noWait);
1178                 markQueryForLocking(qry, j->rarg, forUpdate, noWait);
1179         }
1180         else
1181                 elog(ERROR, "unrecognized node type: %d",
1182                          (int) nodeTag(jtnode));
1183 }
1184
1185
1186 /*
1187  * fireRIRonSubLink -
1188  *      Apply fireRIRrules() to each SubLink (subselect in expression) found
1189  *      in the given tree.
1190  *
1191  * NOTE: although this has the form of a walker, we cheat and modify the
1192  * SubLink nodes in-place.      It is caller's responsibility to ensure that
1193  * no unwanted side-effects occur!
1194  *
1195  * This is unlike most of the other routines that recurse into subselects,
1196  * because we must take control at the SubLink node in order to replace
1197  * the SubLink's subselect link with the possibly-rewritten subquery.
1198  */
1199 static bool
1200 fireRIRonSubLink(Node *node, List *activeRIRs)
1201 {
1202         if (node == NULL)
1203                 return false;
1204         if (IsA(node, SubLink))
1205         {
1206                 SubLink    *sub = (SubLink *) node;
1207
1208                 /* Do what we came for */
1209                 sub->subselect = (Node *) fireRIRrules((Query *) sub->subselect,
1210                                                                                            activeRIRs);
1211                 /* Fall through to process lefthand args of SubLink */
1212         }
1213
1214         /*
1215          * Do NOT recurse into Query nodes, because fireRIRrules already processed
1216          * subselects of subselects for us.
1217          */
1218         return expression_tree_walker(node, fireRIRonSubLink,
1219                                                                   (void *) activeRIRs);
1220 }
1221
1222
1223 /*
1224  * fireRIRrules -
1225  *      Apply all RIR rules on each rangetable entry in a query
1226  */
1227 static Query *
1228 fireRIRrules(Query *parsetree, List *activeRIRs)
1229 {
1230         int                     rt_index;
1231
1232         /*
1233          * don't try to convert this into a foreach loop, because rtable list can
1234          * get changed each time through...
1235          */
1236         rt_index = 0;
1237         while (rt_index < list_length(parsetree->rtable))
1238         {
1239                 RangeTblEntry *rte;
1240                 Relation        rel;
1241                 List       *locks;
1242                 RuleLock   *rules;
1243                 RewriteRule *rule;
1244                 int                     i;
1245
1246                 ++rt_index;
1247
1248                 rte = rt_fetch(rt_index, parsetree->rtable);
1249
1250                 /*
1251                  * A subquery RTE can't have associated rules, so there's nothing to
1252                  * do to this level of the query, but we must recurse into the
1253                  * subquery to expand any rule references in it.
1254                  */
1255                 if (rte->rtekind == RTE_SUBQUERY)
1256                 {
1257                         rte->subquery = fireRIRrules(rte->subquery, activeRIRs);
1258                         continue;
1259                 }
1260
1261                 /*
1262                  * Joins and other non-relation RTEs can be ignored completely.
1263                  */
1264                 if (rte->rtekind != RTE_RELATION)
1265                         continue;
1266
1267                 /*
1268                  * If the table is not referenced in the query, then we ignore it.
1269                  * This prevents infinite expansion loop due to new rtable entries
1270                  * inserted by expansion of a rule. A table is referenced if it is
1271                  * part of the join set (a source table), or is referenced by any Var
1272                  * nodes, or is the result table.
1273                  */
1274                 if (rt_index != parsetree->resultRelation &&
1275                         !rangeTableEntry_used((Node *) parsetree, rt_index, 0))
1276                         continue;
1277
1278                 /*
1279                  * We can use NoLock here since either the parser or
1280                  * AcquireRewriteLocks should have locked the rel already.
1281                  */
1282                 rel = heap_open(rte->relid, NoLock);
1283
1284                 /*
1285                  * Collect the RIR rules that we must apply
1286                  */
1287                 rules = rel->rd_rules;
1288                 if (rules == NULL)
1289                 {
1290                         heap_close(rel, NoLock);
1291                         continue;
1292                 }
1293                 locks = NIL;
1294                 for (i = 0; i < rules->numLocks; i++)
1295                 {
1296                         rule = rules->rules[i];
1297                         if (rule->event != CMD_SELECT)
1298                                 continue;
1299
1300                         if (rule->attrno > 0)
1301                         {
1302                                 /* per-attr rule; do we need it? */
1303                                 if (!attribute_used((Node *) parsetree, rt_index,
1304                                                                         rule->attrno, 0))
1305                                         continue;
1306                         }
1307
1308                         locks = lappend(locks, rule);
1309                 }
1310
1311                 /*
1312                  * If we found any, apply them --- but first check for recursion!
1313                  */
1314                 if (locks != NIL)
1315                 {
1316                         ListCell   *l;
1317
1318                         if (list_member_oid(activeRIRs, RelationGetRelid(rel)))
1319                                 ereport(ERROR,
1320                                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1321                                                  errmsg("infinite recursion detected in rules for relation \"%s\"",
1322                                                                 RelationGetRelationName(rel))));
1323                         activeRIRs = lcons_oid(RelationGetRelid(rel), activeRIRs);
1324
1325                         foreach(l, locks)
1326                         {
1327                                 rule = lfirst(l);
1328
1329                                 parsetree = ApplyRetrieveRule(parsetree,
1330                                                                                           rule,
1331                                                                                           rt_index,
1332                                                                                           rule->attrno == -1,
1333                                                                                           rel,
1334                                                                                           activeRIRs);
1335                         }
1336
1337                         activeRIRs = list_delete_first(activeRIRs);
1338                 }
1339
1340                 heap_close(rel, NoLock);
1341         }
1342
1343         /*
1344          * Recurse into sublink subqueries, too.  But we already did the ones in
1345          * the rtable.
1346          */
1347         if (parsetree->hasSubLinks)
1348                 query_tree_walker(parsetree, fireRIRonSubLink, (void *) activeRIRs,
1349                                                   QTW_IGNORE_RT_SUBQUERIES);
1350
1351         return parsetree;
1352 }
1353
1354
1355 /*
1356  * Modify the given query by adding 'AND rule_qual IS NOT TRUE' to its
1357  * qualification.  This is used to generate suitable "else clauses" for
1358  * conditional INSTEAD rules.  (Unfortunately we must use "x IS NOT TRUE",
1359  * not just "NOT x" which the planner is much smarter about, else we will
1360  * do the wrong thing when the qual evaluates to NULL.)
1361  *
1362  * The rule_qual may contain references to OLD or NEW.  OLD references are
1363  * replaced by references to the specified rt_index (the relation that the
1364  * rule applies to).  NEW references are only possible for INSERT and UPDATE
1365  * queries on the relation itself, and so they should be replaced by copies
1366  * of the related entries in the query's own targetlist.
1367  */
1368 static Query *
1369 CopyAndAddInvertedQual(Query *parsetree,
1370                                            Node *rule_qual,
1371                                            int rt_index,
1372                                            CmdType event)
1373 {
1374         /* Don't scribble on the passed qual (it's in the relcache!) */
1375         Node       *new_qual = (Node *) copyObject(rule_qual);
1376
1377         /*
1378          * In case there are subqueries in the qual, acquire necessary locks and
1379          * fix any deleted JOIN RTE entries.  (This is somewhat redundant with
1380          * rewriteRuleAction, but not entirely ... consider restructuring so that
1381          * we only need to process the qual this way once.)
1382          */
1383         (void) acquireLocksOnSubLinks(new_qual, NULL);
1384
1385         /* Fix references to OLD */
1386         ChangeVarNodes(new_qual, PRS2_OLD_VARNO, rt_index, 0);
1387         /* Fix references to NEW */
1388         if (event == CMD_INSERT || event == CMD_UPDATE)
1389                 new_qual = ResolveNew(new_qual,
1390                                                           PRS2_NEW_VARNO,
1391                                                           0,
1392                                                           rt_fetch(rt_index, parsetree->rtable),
1393                                                           parsetree->targetList,
1394                                                           event,
1395                                                           rt_index);
1396         /* And attach the fixed qual */
1397         AddInvertedQual(parsetree, new_qual);
1398
1399         return parsetree;
1400 }
1401
1402
1403 /*
1404  *      fireRules -
1405  *         Iterate through rule locks applying rules.
1406  *
1407  * Input arguments:
1408  *      parsetree - original query
1409  *      rt_index - RT index of result relation in original query
1410  *      event - type of rule event
1411  *      locks - list of rules to fire
1412  * Output arguments:
1413  *      *instead_flag - set TRUE if any unqualified INSTEAD rule is found
1414  *                                      (must be initialized to FALSE)
1415  *      *returning_flag - set TRUE if we rewrite RETURNING clause in any rule
1416  *                                      (must be initialized to FALSE)
1417  *      *qual_product - filled with modified original query if any qualified
1418  *                                      INSTEAD rule is found (must be initialized to NULL)
1419  * Return value:
1420  *      list of rule actions adjusted for use with this query
1421  *
1422  * Qualified INSTEAD rules generate their action with the qualification
1423  * condition added.  They also generate a modified version of the original
1424  * query with the negated qualification added, so that it will run only for
1425  * rows that the qualified action doesn't act on.  (If there are multiple
1426  * qualified INSTEAD rules, we AND all the negated quals onto a single
1427  * modified original query.)  We won't execute the original, unmodified
1428  * query if we find either qualified or unqualified INSTEAD rules.      If
1429  * we find both, the modified original query is discarded too.
1430  */
1431 static List *
1432 fireRules(Query *parsetree,
1433                   int rt_index,
1434                   CmdType event,
1435                   List *locks,
1436                   bool *instead_flag,
1437                   bool *returning_flag,
1438                   Query **qual_product)
1439 {
1440         List       *results = NIL;
1441         ListCell   *l;
1442
1443         foreach(l, locks)
1444         {
1445                 RewriteRule *rule_lock = (RewriteRule *) lfirst(l);
1446                 Node       *event_qual = rule_lock->qual;
1447                 List       *actions = rule_lock->actions;
1448                 QuerySource qsrc;
1449                 ListCell   *r;
1450
1451                 /* Determine correct QuerySource value for actions */
1452                 if (rule_lock->isInstead)
1453                 {
1454                         if (event_qual != NULL)
1455                                 qsrc = QSRC_QUAL_INSTEAD_RULE;
1456                         else
1457                         {
1458                                 qsrc = QSRC_INSTEAD_RULE;
1459                                 *instead_flag = true;   /* report unqualified INSTEAD */
1460                         }
1461                 }
1462                 else
1463                         qsrc = QSRC_NON_INSTEAD_RULE;
1464
1465                 if (qsrc == QSRC_QUAL_INSTEAD_RULE)
1466                 {
1467                         /*
1468                          * If there are INSTEAD rules with qualifications, the original
1469                          * query is still performed. But all the negated rule
1470                          * qualifications of the INSTEAD rules are added so it does its
1471                          * actions only in cases where the rule quals of all INSTEAD rules
1472                          * are false. Think of it as the default action in a case. We save
1473                          * this in *qual_product so RewriteQuery() can add it to the query
1474                          * list after we mangled it up enough.
1475                          *
1476                          * If we have already found an unqualified INSTEAD rule, then
1477                          * *qual_product won't be used, so don't bother building it.
1478                          */
1479                         if (!*instead_flag)
1480                         {
1481                                 if (*qual_product == NULL)
1482                                         *qual_product = copyObject(parsetree);
1483                                 *qual_product = CopyAndAddInvertedQual(*qual_product,
1484                                                                                                            event_qual,
1485                                                                                                            rt_index,
1486                                                                                                            event);
1487                         }
1488                 }
1489
1490                 /* Now process the rule's actions and add them to the result list */
1491                 foreach(r, actions)
1492                 {
1493                         Query      *rule_action = lfirst(r);
1494
1495                         if (rule_action->commandType == CMD_NOTHING)
1496                                 continue;
1497
1498                         rule_action = rewriteRuleAction(parsetree, rule_action,
1499                                                                                         event_qual, rt_index, event,
1500                                                                                         returning_flag);
1501
1502                         rule_action->querySource = qsrc;
1503                         rule_action->canSetTag = false;         /* might change later */
1504
1505                         results = lappend(results, rule_action);
1506                 }
1507         }
1508
1509         return results;
1510 }
1511
1512
1513 /*
1514  * RewriteQuery -
1515  *        rewrites the query and apply the rules again on the queries rewritten
1516  *
1517  * rewrite_events is a list of open query-rewrite actions, so we can detect
1518  * infinite recursion.
1519  */
1520 static List *
1521 RewriteQuery(Query *parsetree, List *rewrite_events)
1522 {
1523         CmdType         event = parsetree->commandType;
1524         bool            instead = false;
1525         bool            returning = false;
1526         Query      *qual_product = NULL;
1527         List       *rewritten = NIL;
1528
1529         /*
1530          * If the statement is an update, insert or delete - fire rules on it.
1531          *
1532          * SELECT rules are handled later when we have all the queries that should
1533          * get executed.  Also, utilities aren't rewritten at all (do we still
1534          * need that check?)
1535          */
1536         if (event != CMD_SELECT && event != CMD_UTILITY)
1537         {
1538                 int                     result_relation;
1539                 RangeTblEntry *rt_entry;
1540                 Relation        rt_entry_relation;
1541                 List       *locks;
1542
1543                 result_relation = parsetree->resultRelation;
1544                 Assert(result_relation != 0);
1545                 rt_entry = rt_fetch(result_relation, parsetree->rtable);
1546                 Assert(rt_entry->rtekind == RTE_RELATION);
1547
1548                 /*
1549                  * We can use NoLock here since either the parser or
1550                  * AcquireRewriteLocks should have locked the rel already.
1551                  */
1552                 rt_entry_relation = heap_open(rt_entry->relid, NoLock);
1553
1554                 /*
1555                  * If it's an INSERT or UPDATE, rewrite the targetlist into standard
1556                  * form.  This will be needed by the planner anyway, and doing it now
1557                  * ensures that any references to NEW.field will behave sanely.
1558                  */
1559                 if (event == CMD_UPDATE)
1560                         rewriteTargetList(parsetree, rt_entry_relation, NULL);
1561                 else if (event == CMD_INSERT)
1562                 {
1563                         RangeTblEntry *values_rte = NULL;
1564
1565                         /*
1566                          * If it's an INSERT ... VALUES (...), (...), ... there will be a
1567                          * single RTE for the VALUES targetlists.
1568                          */
1569                         if (list_length(parsetree->jointree->fromlist) == 1)
1570                         {
1571                                 RangeTblRef *rtr = (RangeTblRef *) linitial(parsetree->jointree->fromlist);
1572
1573                                 if (IsA(rtr, RangeTblRef))
1574                                 {
1575                                         RangeTblEntry *rte = rt_fetch(rtr->rtindex,
1576                                                                                                   parsetree->rtable);
1577
1578                                         if (rte->rtekind == RTE_VALUES)
1579                                                 values_rte = rte;
1580                                 }
1581                         }
1582
1583                         if (values_rte)
1584                         {
1585                                 List       *attrnos;
1586
1587                                 /* Process the main targetlist ... */
1588                                 rewriteTargetList(parsetree, rt_entry_relation, &attrnos);
1589                                 /* ... and the VALUES expression lists */
1590                                 rewriteValuesRTE(values_rte, rt_entry_relation, attrnos);
1591                         }
1592                         else
1593                         {
1594                                 /* Process just the main targetlist */
1595                                 rewriteTargetList(parsetree, rt_entry_relation, NULL);
1596                         }
1597                 }
1598
1599                 /*
1600                  * Collect and apply the appropriate rules.
1601                  */
1602                 locks = matchLocks(event, rt_entry_relation->rd_rules,
1603                                                    result_relation, parsetree);
1604
1605                 if (locks != NIL)
1606                 {
1607                         List       *product_queries;
1608
1609                         product_queries = fireRules(parsetree,
1610                                                                                 result_relation,
1611                                                                                 event,
1612                                                                                 locks,
1613                                                                                 &instead,
1614                                                                                 &returning,
1615                                                                                 &qual_product);
1616
1617                         /*
1618                          * If we got any product queries, recursively rewrite them --- but
1619                          * first check for recursion!
1620                          */
1621                         if (product_queries != NIL)
1622                         {
1623                                 ListCell   *n;
1624                                 rewrite_event *rev;
1625
1626                                 foreach(n, rewrite_events)
1627                                 {
1628                                         rev = (rewrite_event *) lfirst(n);
1629                                         if (rev->relation == RelationGetRelid(rt_entry_relation) &&
1630                                                 rev->event == event)
1631                                                 ereport(ERROR,
1632                                                                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
1633                                                                  errmsg("infinite recursion detected in rules for relation \"%s\"",
1634                                                            RelationGetRelationName(rt_entry_relation))));
1635                                 }
1636
1637                                 rev = (rewrite_event *) palloc(sizeof(rewrite_event));
1638                                 rev->relation = RelationGetRelid(rt_entry_relation);
1639                                 rev->event = event;
1640                                 rewrite_events = lcons(rev, rewrite_events);
1641
1642                                 foreach(n, product_queries)
1643                                 {
1644                                         Query      *pt = (Query *) lfirst(n);
1645                                         List       *newstuff;
1646
1647                                         newstuff = RewriteQuery(pt, rewrite_events);
1648                                         rewritten = list_concat(rewritten, newstuff);
1649                                 }
1650
1651                                 rewrite_events = list_delete_first(rewrite_events);
1652                         }
1653                 }
1654
1655                 /*
1656                  * If there is an INSTEAD, and the original query has a RETURNING, we
1657                  * have to have found a RETURNING in the rule(s), else fail. (Because
1658                  * DefineQueryRewrite only allows RETURNING in unconditional INSTEAD
1659                  * rules, there's no need to worry whether the substituted RETURNING
1660                  * will actually be executed --- it must be.)
1661                  */
1662                 if ((instead || qual_product != NULL) &&
1663                         parsetree->returningList &&
1664                         !returning)
1665                 {
1666                         switch (event)
1667                         {
1668                                 case CMD_INSERT:
1669                                         ereport(ERROR,
1670                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1671                                                  errmsg("cannot perform INSERT RETURNING on relation \"%s\"",
1672                                                                 RelationGetRelationName(rt_entry_relation)),
1673                                                          errhint("You need an unconditional ON INSERT DO INSTEAD rule with a RETURNING clause.")));
1674                                         break;
1675                                 case CMD_UPDATE:
1676                                         ereport(ERROR,
1677                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1678                                                  errmsg("cannot perform UPDATE RETURNING on relation \"%s\"",
1679                                                                 RelationGetRelationName(rt_entry_relation)),
1680                                                          errhint("You need an unconditional ON UPDATE DO INSTEAD rule with a RETURNING clause.")));
1681                                         break;
1682                                 case CMD_DELETE:
1683                                         ereport(ERROR,
1684                                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1685                                                  errmsg("cannot perform DELETE RETURNING on relation \"%s\"",
1686                                                                 RelationGetRelationName(rt_entry_relation)),
1687                                                          errhint("You need an unconditional ON DELETE DO INSTEAD rule with a RETURNING clause.")));
1688                                         break;
1689                                 default:
1690                                         elog(ERROR, "unrecognized commandType: %d",
1691                                                  (int) event);
1692                                         break;
1693                         }
1694                 }
1695
1696                 heap_close(rt_entry_relation, NoLock);
1697         }
1698
1699         /*
1700          * For INSERTs, the original query is done first; for UPDATE/DELETE, it is
1701          * done last.  This is needed because update and delete rule actions might
1702          * not do anything if they are invoked after the update or delete is
1703          * performed. The command counter increment between the query executions
1704          * makes the deleted (and maybe the updated) tuples disappear so the scans
1705          * for them in the rule actions cannot find them.
1706          *
1707          * If we found any unqualified INSTEAD, the original query is not done at
1708          * all, in any form.  Otherwise, we add the modified form if qualified
1709          * INSTEADs were found, else the unmodified form.
1710          */
1711         if (!instead)
1712         {
1713                 if (parsetree->commandType == CMD_INSERT)
1714                 {
1715                         if (qual_product != NULL)
1716                                 rewritten = lcons(qual_product, rewritten);
1717                         else
1718                                 rewritten = lcons(parsetree, rewritten);
1719                 }
1720                 else
1721                 {
1722                         if (qual_product != NULL)
1723                                 rewritten = lappend(rewritten, qual_product);
1724                         else
1725                                 rewritten = lappend(rewritten, parsetree);
1726                 }
1727         }
1728
1729         return rewritten;
1730 }
1731
1732
1733 /*
1734  * QueryRewrite -
1735  *        Primary entry point to the query rewriter.
1736  *        Rewrite one query via query rewrite system, possibly returning 0
1737  *        or many queries.
1738  *
1739  * NOTE: the parsetree must either have come straight from the parser,
1740  * or have been scanned by AcquireRewriteLocks to acquire suitable locks.
1741  */
1742 List *
1743 QueryRewrite(Query *parsetree)
1744 {
1745         List       *querylist;
1746         List       *results = NIL;
1747         ListCell   *l;
1748         CmdType         origCmdType;
1749         bool            foundOriginalQuery;
1750         Query      *lastInstead;
1751
1752         /*
1753          * Step 1
1754          *
1755          * Apply all non-SELECT rules possibly getting 0 or many queries
1756          */
1757         querylist = RewriteQuery(parsetree, NIL);
1758
1759         /*
1760          * Step 2
1761          *
1762          * Apply all the RIR rules on each query
1763          */
1764         foreach(l, querylist)
1765         {
1766                 Query      *query = (Query *) lfirst(l);
1767
1768                 query = fireRIRrules(query, NIL);
1769
1770                 /*
1771                  * If the query target was rewritten as a view, complain.
1772                  */
1773                 if (query->resultRelation)
1774                 {
1775                         RangeTblEntry *rte = rt_fetch(query->resultRelation,
1776                                                                                   query->rtable);
1777
1778                         if (rte->rtekind == RTE_SUBQUERY)
1779                         {
1780                                 switch (query->commandType)
1781                                 {
1782                                         case CMD_INSERT:
1783                                                 ereport(ERROR,
1784                                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1785                                                                  errmsg("cannot insert into a view"),
1786                                                                  errhint("You need an unconditional ON INSERT DO INSTEAD rule.")));
1787                                                 break;
1788                                         case CMD_UPDATE:
1789                                                 ereport(ERROR,
1790                                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1791                                                                  errmsg("cannot update a view"),
1792                                                                  errhint("You need an unconditional ON UPDATE DO INSTEAD rule.")));
1793                                                 break;
1794                                         case CMD_DELETE:
1795                                                 ereport(ERROR,
1796                                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1797                                                                  errmsg("cannot delete from a view"),
1798                                                                  errhint("You need an unconditional ON DELETE DO INSTEAD rule.")));
1799                                                 break;
1800                                         default:
1801                                                 elog(ERROR, "unrecognized commandType: %d",
1802                                                          (int) query->commandType);
1803                                                 break;
1804                                 }
1805                         }
1806                 }
1807
1808                 results = lappend(results, query);
1809         }
1810
1811         /*
1812          * Step 3
1813          *
1814          * Determine which, if any, of the resulting queries is supposed to set
1815          * the command-result tag; and update the canSetTag fields accordingly.
1816          *
1817          * If the original query is still in the list, it sets the command tag.
1818          * Otherwise, the last INSTEAD query of the same kind as the original is
1819          * allowed to set the tag.      (Note these rules can leave us with no query
1820          * setting the tag.  The tcop code has to cope with this by setting up a
1821          * default tag based on the original un-rewritten query.)
1822          *
1823          * The Asserts verify that at most one query in the result list is marked
1824          * canSetTag.  If we aren't checking asserts, we can fall out of the loop
1825          * as soon as we find the original query.
1826          */
1827         origCmdType = parsetree->commandType;
1828         foundOriginalQuery = false;
1829         lastInstead = NULL;
1830
1831         foreach(l, results)
1832         {
1833                 Query      *query = (Query *) lfirst(l);
1834
1835                 if (query->querySource == QSRC_ORIGINAL)
1836                 {
1837                         Assert(query->canSetTag);
1838                         Assert(!foundOriginalQuery);
1839                         foundOriginalQuery = true;
1840 #ifndef USE_ASSERT_CHECKING
1841                         break;
1842 #endif
1843                 }
1844                 else
1845                 {
1846                         Assert(!query->canSetTag);
1847                         if (query->commandType == origCmdType &&
1848                                 (query->querySource == QSRC_INSTEAD_RULE ||
1849                                  query->querySource == QSRC_QUAL_INSTEAD_RULE))
1850                                 lastInstead = query;
1851                 }
1852         }
1853
1854         if (!foundOriginalQuery && lastInstead != NULL)
1855                 lastInstead->canSetTag = true;
1856
1857         return results;
1858 }