rewriteHandler.c 33.4 KB
Newer Older
1 2
/*-------------------------------------------------------------------------
 *
3
 * rewriteHandler.c
4
 *		Primary module of query rewriter.
5
 *
Bruce Momjian's avatar
Bruce Momjian committed
6
 * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
Bruce Momjian's avatar
Add:  
Bruce Momjian committed
7
 * Portions Copyright (c) 1994, Regents of the University of California
8 9
 *
 * IDENTIFICATION
10
 *	  $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.104 2002/07/18 04:43:50 momjian Exp $
11 12 13 14 15
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

Bruce Momjian's avatar
Bruce Momjian committed
16
#include "access/heapam.h"
17
#include "catalog/pg_operator.h"
18
#include "catalog/pg_type.h"
Bruce Momjian's avatar
Bruce Momjian committed
19
#include "miscadmin.h"
20
#include "nodes/makefuncs.h"
Bruce Momjian's avatar
Bruce Momjian committed
21 22
#include "optimizer/clauses.h"
#include "optimizer/prep.h"
23
#include "optimizer/var.h"
Bruce Momjian's avatar
Bruce Momjian committed
24
#include "parser/analyze.h"
25
#include "parser/parse_coerce.h"
26 27
#include "parser/parse_expr.h"
#include "parser/parse_oper.h"
Bruce Momjian's avatar
Bruce Momjian committed
28
#include "parser/parse_target.h"
Bruce Momjian's avatar
Bruce Momjian committed
29
#include "parser/parse_type.h"
30
#include "parser/parsetree.h"
31
#include "rewrite/rewriteHandler.h"
Bruce Momjian's avatar
Bruce Momjian committed
32
#include "rewrite/rewriteManip.h"
33
#include "utils/builtins.h"
Bruce Momjian's avatar
Bruce Momjian committed
34
#include "utils/lsyscache.h"
35 36


37
static Query *rewriteRuleAction(Query *parsetree,
38 39 40 41
				  Query *rule_action,
				  Node *rule_qual,
				  int rt_index,
				  CmdType event);
42
static List *adjustJoinTreeList(Query *parsetree, bool removert, int rt_index);
43 44 45
static void rewriteTargetList(Query *parsetree, Relation target_relation);
static TargetEntry *process_matched_tle(TargetEntry *src_tle,
										TargetEntry *prior_tle);
46
static void markQueryForUpdate(Query *qry, bool skipOldNew);
47
static List *matchLocks(CmdType event, RuleLock *rulelocks,
48
		   int varno, Query *parsetree);
49
static Query *fireRIRrules(Query *parsetree);
50

51 52

/*
53 54 55
 * rewriteRuleAction -
 *	  Rewrite the rule action with appropriate qualifiers (taken from
 *	  the triggering query).
56
 */
57 58
static Query *
rewriteRuleAction(Query *parsetree,
59 60
				  Query *rule_action,
				  Node *rule_qual,
61
				  int rt_index,
62
				  CmdType event)
63
{
64 65 66
	int			current_varno,
				new_varno;
	int			rt_length;
67 68
	Query	   *sub_action;
	Query	  **sub_action_ptr;
69

70 71 72 73 74 75 76 77
	/*
	 * Make modifiable copies of rule action and qual (what we're passed
	 * are the stored versions in the relcache; don't touch 'em!).
	 */
	rule_action = (Query *) copyObject(rule_action);
	rule_qual = (Node *) copyObject(rule_qual);

	current_varno = rt_index;
78
	rt_length = length(parsetree->rtable);
79
	new_varno = PRS2_NEW_VARNO + rt_length;
80

81 82
	/*
	 * Adjust rule action and qual to offset its varnos, so that we can
83
	 * merge its rtable with the main parsetree's rtable.
84
	 *
85 86 87
	 * If the rule action is an INSERT...SELECT, the OLD/NEW rtable entries
	 * will be in the SELECT part, and we have to modify that rather than
	 * the top-level INSERT (kluge!).
88
	 */
89
	sub_action = getInsertSelectQuery(rule_action, &sub_action_ptr);
90

91
	OffsetVarNodes((Node *) sub_action, rt_length, 0);
92
	OffsetVarNodes(rule_qual, rt_length, 0);
93 94 95
	/* but references to *OLD* should point at original rt_index */
	ChangeVarNodes((Node *) sub_action,
				   PRS2_OLD_VARNO + rt_length, rt_index, 0);
96
	ChangeVarNodes(rule_qual,
97 98 99
				   PRS2_OLD_VARNO + rt_length, rt_index, 0);

	/*
100 101 102 103 104 105
	 * Generate expanded rtable consisting of main parsetree's rtable plus
	 * rule action's rtable; this becomes the complete rtable for the rule
	 * action.	Some of the entries may be unused after we finish
	 * rewriting, but if we tried to clean those out we'd have a much
	 * harder job to adjust RT indexes in the query's Vars.  It's OK to
	 * have unused RT entries, since planner will ignore them.
106
	 *
107
	 * NOTE: because planner will destructively alter rtable, we must ensure
108 109
	 * that rule action's rtable is separate and shares no substructure
	 * with the main rtable.  Hence do a deep copy here.
110
	 */
111 112
	sub_action->rtable = nconc((List *) copyObject(parsetree->rtable),
							   sub_action->rtable);
113

114 115
	/*
	 * Each rule action's jointree should be the main parsetree's jointree
116 117 118 119 120 121 122 123 124
	 * plus that rule's jointree, but usually *without* the original
	 * rtindex that we're replacing (if present, which it won't be for
	 * INSERT). Note that if the rule action refers to OLD, its jointree
	 * will add a reference to rt_index.  If the rule action doesn't refer
	 * to OLD, but either the rule_qual or the user query quals do, then
	 * we need to keep the original rtindex in the jointree to provide
	 * data for the quals.	We don't want the original rtindex to be
	 * joined twice, however, so avoid keeping it if the rule action
	 * mentions it.
125
	 *
126 127
	 * As above, the action's jointree must not share substructure with the
	 * main parsetree's.
128
	 */
129
	if (sub_action->jointree != NULL)
130
	{
131 132
		bool		keeporig;
		List	   *newjointree;
133

134 135
		keeporig = (!rangeTableEntry_used((Node *) sub_action->jointree,
										  rt_index, 0)) &&
136
			(rangeTableEntry_used(rule_qual, rt_index, 0) ||
137
		  rangeTableEntry_used(parsetree->jointree->quals, rt_index, 0));
138
		newjointree = adjustJoinTreeList(parsetree, !keeporig, rt_index);
139 140 141 142 143 144 145 146
		sub_action->jointree->fromlist =
			nconc(newjointree, sub_action->jointree->fromlist);
	}

	/*
	 * We copy the qualifications of the parsetree to the action and vice
	 * versa. So force hasSubLinks if one of them has it. If this is not
	 * right, the flag will get cleared later, but we mustn't risk having
147 148
	 * it not set when it needs to be.	(XXX this should probably be
	 * handled by AddQual and friends, not here...)
149 150 151 152 153 154 155
	 */
	if (parsetree->hasSubLinks)
		sub_action->hasSubLinks = TRUE;
	else if (sub_action->hasSubLinks)
		parsetree->hasSubLinks = TRUE;

	/*
156 157 158
	 * Event Qualification forces copying of parsetree and splitting into
	 * two queries one w/rule_qual, one w/NOT rule_qual. Also add user
	 * query qual onto rule action
159
	 */
160
	AddQual(sub_action, rule_qual);
161 162 163 164

	AddQual(sub_action, parsetree->jointree->quals);

	/*
165 166
	 * Rewrite new.attribute w/ right hand side of target-list entry for
	 * appropriate field name in insert/update.
167 168 169
	 *
	 * KLUGE ALERT: since ResolveNew returns a mutated copy, we can't just
	 * apply it to sub_action; we have to remember to update the sublink
170
	 * inside rule_action, too.
171
	 */
172
	if (event == CMD_INSERT || event == CMD_UPDATE)
173 174
	{
		sub_action = (Query *) ResolveNew((Node *) sub_action,
175
										  new_varno,
176 177
										  0,
										  parsetree->targetList,
178 179
										  event,
										  current_varno);
180 181 182
		if (sub_action_ptr)
			*sub_action_ptr = sub_action;
		else
183
			rule_action = sub_action;
184
	}
185

186
	return rule_action;
187 188
}

189
/*
190 191 192 193
 * Copy the query's jointree list, and optionally attempt to remove any
 * occurrence of the given rt_index as a top-level join item (we do not look
 * for it within join items; this is OK because we are only expecting to find
 * it as an UPDATE or DELETE target relation, which will be at the top level
194 195
 * of the join).  Returns modified jointree list --- this is a separate copy
 * sharing no nodes with the original.
196
 */
197
static List *
198
adjustJoinTreeList(Query *parsetree, bool removert, int rt_index)
199
{
200
	List	   *newjointree = copyObject(parsetree->jointree->fromlist);
201
	List	   *jjt;
202

203
	if (removert)
Bruce Momjian's avatar
Bruce Momjian committed
204
	{
205
		foreach(jjt, newjointree)
206
		{
207 208
			RangeTblRef *rtr = lfirst(jjt);

209
			if (IsA(rtr, RangeTblRef) &&rtr->rtindex == rt_index)
210 211 212 213
			{
				newjointree = lremove(rtr, newjointree);
				break;
			}
214
		}
215
	}
216
	return newjointree;
217
}
218

219

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
/*
 * rewriteTargetList - rewrite INSERT/UPDATE targetlist into standard form
 *
 * This has the following responsibilities:
 *
 * 1. For an INSERT, add tlist entries to compute default values for any
 * attributes that have defaults and are not assigned to in the given tlist.
 * (We do not insert anything for default-less attributes, however.  The
 * planner will later insert NULLs for them, but there's no reason to slow
 * down rewriter processing with extra tlist nodes.)
 *
 * 2. Merge multiple entries for the same target attribute, or declare error
 * if we can't.  Presently, multiple entries are only allowed for UPDATE of
 * an array field, for example "UPDATE table SET foo[2] = 42, foo[4] = 43".
 * We can merge such operations into a single assignment op.  Essentially,
 * the expression we want to produce in this case is like
 *		foo = array_set(array_set(foo, 2, 42), 4, 43)
 *
 * 3. Sort the tlist into standard order: non-junk fields in order by resno,
 * then junk fields (these in no particular order).
 *
 * We must do items 1 and 2 before firing rewrite rules, else rewritten
 * references to NEW.foo will produce wrong or incomplete results.  Item 3
 * is not needed for rewriting, but will be needed by the planner, and we
 * can do it essentially for free while handling items 1 and 2.
 */
static void
rewriteTargetList(Query *parsetree, Relation target_relation)
{
	CmdType		commandType = parsetree->commandType;
	List	   *tlist = parsetree->targetList;
	List	   *new_tlist = NIL;
	int			attrno,
				numattrs;
	List	   *temp;

	/*
	 * Scan the tuple description in the relation's relcache entry to make
	 * sure we have all the user attributes in the right order.
	 */
	numattrs = RelationGetNumberOfAttributes(target_relation);

	for (attrno = 1; attrno <= numattrs; attrno++)
	{
		Form_pg_attribute att_tup = target_relation->rd_att->attrs[attrno-1];
		TargetEntry *new_tle = NULL;

		/*
		 * Look for targetlist entries matching this attr.  We match by
		 * resno, but the resname should match too.
		 *
		 * Junk attributes are not candidates to be matched.
		 */
		foreach(temp, tlist)
		{
			TargetEntry *old_tle = (TargetEntry *) lfirst(temp);
			Resdom	   *resdom = old_tle->resdom;

			if (!resdom->resjunk && resdom->resno == attrno)
			{
				Assert(strcmp(resdom->resname,
							  NameStr(att_tup->attname)) == 0);
				new_tle = process_matched_tle(old_tle, new_tle);
				/* keep scanning to detect multiple assignments to attr */
			}
		}

		if (new_tle == NULL && commandType == CMD_INSERT)
		{
			/*
			 * Didn't find a matching tlist entry; if it's an INSERT,
			 * look for a default value, and add a tlist entry computing
			 * the default if we find one.
			 */
			Node	   *new_expr;

			new_expr = build_column_default(target_relation, attrno);

			if (new_expr)
				new_tle = makeTargetEntry(makeResdom(attrno,
													 att_tup->atttypid,
													 att_tup->atttypmod,
													 pstrdup(NameStr(att_tup->attname)),
													 false),
										  new_expr);
		}

		if (new_tle)
			new_tlist = lappend(new_tlist, new_tle);
	}

	/*
	 * Copy all resjunk tlist entries to the end of the new tlist, and
	 * assign them resnos above the last real resno.
	 *
	 * Typical junk entries include ORDER BY or GROUP BY expressions (are
	 * these actually possible in an INSERT or UPDATE?), system attribute
	 * references, etc.
	 */
	foreach(temp, tlist)
	{
		TargetEntry *old_tle = (TargetEntry *) lfirst(temp);
		Resdom	   *resdom = old_tle->resdom;

		if (resdom->resjunk)
		{
			/* Get the resno right, but don't copy unnecessarily */
			if (resdom->resno != attrno)
			{
				resdom = (Resdom *) copyObject((Node *) resdom);
				resdom->resno = attrno;
				old_tle = makeTargetEntry(resdom, old_tle->expr);
			}
			new_tlist = lappend(new_tlist, old_tle);
			attrno++;
		}
		else
		{
			/* Let's just make sure we processed all the non-junk items */
			if (resdom->resno < 1 || resdom->resno > numattrs)
				elog(ERROR, "rewriteTargetList: bogus resno %d in targetlist",
					 resdom->resno);
		}
	}

	parsetree->targetList = new_tlist;
}


/*
 * Convert a matched TLE from the original tlist into a correct new TLE.
 *
 * This routine detects and handles multiple assignments to the same target
 * attribute.
 */
static TargetEntry *
process_matched_tle(TargetEntry *src_tle,
					TargetEntry *prior_tle)
{
	Resdom	   *resdom = src_tle->resdom;
	Node	   *priorbottom;
	ArrayRef   *newexpr;

	if (prior_tle == NULL)
	{
		/*
		 * Normal case where this is the first assignment to the
		 * attribute.
		 */
		return src_tle;
	}

	/*
	 * Multiple assignments to same attribute.	Allow only if all are
	 * array-assign operators with same bottom array object.
	 */
	if (src_tle->expr == NULL || !IsA(src_tle->expr, ArrayRef) ||
		((ArrayRef *) src_tle->expr)->refassgnexpr == NULL ||
		prior_tle->expr == NULL || !IsA(prior_tle->expr, ArrayRef) ||
		((ArrayRef *) prior_tle->expr)->refassgnexpr == NULL ||
		((ArrayRef *) src_tle->expr)->refelemtype !=
		((ArrayRef *) prior_tle->expr)->refelemtype)
		elog(ERROR, "Multiple assignments to same attribute \"%s\"",
			 resdom->resname);

	/*
	 * Prior TLE could be a nest of ArrayRefs if we do this more than
	 * once.
	 */
	priorbottom = ((ArrayRef *) prior_tle->expr)->refexpr;
	while (priorbottom != NULL && IsA(priorbottom, ArrayRef) &&
		   ((ArrayRef *) priorbottom)->refassgnexpr != NULL)
		priorbottom = ((ArrayRef *) priorbottom)->refexpr;
	if (!equal(priorbottom, ((ArrayRef *) src_tle->expr)->refexpr))
		elog(ERROR, "Multiple assignments to same attribute \"%s\"",
			 resdom->resname);

	/*
	 * Looks OK to nest 'em.
	 */
	newexpr = makeNode(ArrayRef);
	memcpy(newexpr, src_tle->expr, sizeof(ArrayRef));
	newexpr->refexpr = prior_tle->expr;

	return makeTargetEntry(resdom, (Node *) newexpr);
}


/*
 * Make an expression tree for the default value for a column.
 *
 * If there is no default, return a NULL instead.
 */
413
Node *
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
build_column_default(Relation rel, int attrno)
{
	TupleDesc	rd_att = rel->rd_att;
	Form_pg_attribute att_tup = rd_att->attrs[attrno - 1];
	Oid			atttype = att_tup->atttypid;
	int32		atttypmod = att_tup->atttypmod;
	Node	   *expr = NULL;
	Oid			exprtype;

	/*
	 * Scan to see if relation has a default for this column.
	 */
	if (rd_att->constr && rd_att->constr->num_defval > 0)
	{
		AttrDefault *defval = rd_att->constr->defval;
		int			ndef = rd_att->constr->num_defval;

		while (--ndef >= 0)
		{
			if (attrno == defval[ndef].adnum)
			{
				/*
				 * Found it, convert string representation to node tree.
				 */
				expr = stringToNode(defval[ndef].adbin);
				break;
			}
		}
	}

	if (expr == NULL)
	{
		/*
		 * No per-column default, so look for a default for the type itself.
		 */
		if (att_tup->attisset)
		{
			/*
			 * Set attributes are represented as OIDs no matter what the set
			 * element type is, and the element type's default is irrelevant
			 * too.
			 */
		}
		else
		{
			expr = get_typdefault(atttype);
		}
	}

	if (expr == NULL)
		return NULL;			/* No default anywhere */

	/*
	 * Make sure the value is coerced to the target column
	 * type (might not be right type yet if it's not a
	 * constant!)  This should match the parser's processing of
	 * non-defaulted expressions --- see
	 * updateTargetListEntry().
	 */
	exprtype = exprType(expr);

	if (exprtype != atttype)
	{
		expr = CoerceTargetExpr(NULL, expr, exprtype,
478
								atttype, atttypmod, false);
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502

		/*
		 * This really shouldn't fail; should have checked the
		 * default's type when it was created ...
		 */
		if (expr == NULL)
			elog(ERROR, "Column \"%s\" is of type %s"
				 " but default expression is of type %s"
				 "\n\tYou will need to rewrite or cast the expression",
				 NameStr(att_tup->attname),
				 format_type_be(atttype),
				 format_type_be(exprtype));
	}

	/*
	 * If the column is a fixed-length type, it may need a
	 * length coercion as well as a type coercion.
	 */
	expr = coerce_type_typmod(NULL, expr, atttype, atttypmod);

	return expr;
}


503
/*
504 505
 * matchLocks -
 *	  match the list of locks and returns the matching rules
506
 */
507 508 509 510 511
static List *
matchLocks(CmdType event,
		   RuleLock *rulelocks,
		   int varno,
		   Query *parsetree)
512
{
513 514 515
	List	   *real_locks = NIL;
	int			nlocks;
	int			i;
516

517 518
	Assert(rulelocks != NULL);	/* we get called iff there is some lock */
	Assert(parsetree != NULL);
519

520
	if (parsetree->commandType != CMD_SELECT)
521
	{
522 523
		if (parsetree->resultRelation != varno)
			return NIL;
524
	}
525

526
	nlocks = rulelocks->numLocks;
527

528
	for (i = 0; i < nlocks; i++)
Bruce Momjian's avatar
Bruce Momjian committed
529
	{
530
		RewriteRule *oneLock = rulelocks->rules[i];
531

532
		if (oneLock->event == event)
533
		{
534 535 536 537 538 539
			if (parsetree->commandType != CMD_SELECT ||
				(oneLock->attrno == -1 ?
				 rangeTableEntry_used((Node *) parsetree, varno, 0) :
				 attribute_used((Node *) parsetree,
								varno, oneLock->attrno, 0)))
				real_locks = lappend(real_locks, oneLock);
540
		}
541
	}
542 543

	return real_locks;
544 545
}

546

547 548 549 550 551 552 553 554 555 556 557
static Query *
ApplyRetrieveRule(Query *parsetree,
				  RewriteRule *rule,
				  int rt_index,
				  bool relation_level,
				  Relation relation,
				  bool relIsUsed)
{
	Query	   *rule_action;
	RangeTblEntry *rte,
			   *subrte;
558

559 560 561 562
	if (length(rule->actions) != 1)
		elog(ERROR, "ApplyRetrieveRule: expected just one rule action");
	if (rule->qual != NULL)
		elog(ERROR, "ApplyRetrieveRule: can't handle qualified ON SELECT rule");
563
	if (!relation_level)
564
		elog(ERROR, "ApplyRetrieveRule: can't handle per-attribute ON SELECT rule");
565

566
	/*
567 568
	 * Make a modifiable copy of the view query, and recursively expand
	 * any view references inside it.
569
	 */
570
	rule_action = copyObject(lfirst(rule->actions));
571

572
	rule_action = fireRIRrules(rule_action);
573

574
	/*
575 576
	 * VIEWs are really easy --- just plug the view query in as a
	 * subselect, replacing the relation's original RTE.
577
	 */
578
	rte = rt_fetch(rt_index, parsetree->rtable);
579

580
	rte->rtekind = RTE_SUBQUERY;
581 582 583
	rte->relid = InvalidOid;
	rte->subquery = rule_action;
	rte->inh = false;			/* must not be set for a subquery */
584

585
	/*
586 587
	 * We move the view's permission check data down to its rangetable.
	 * The checks will actually be done against the *OLD* entry therein.
588
	 */
589 590 591 592
	subrte = rt_fetch(PRS2_OLD_VARNO, rule_action->rtable);
	Assert(subrte->relid == relation->rd_id);
	subrte->checkForRead = rte->checkForRead;
	subrte->checkForWrite = rte->checkForWrite;
593
	subrte->checkAsUser = rte->checkAsUser;
594

595 596
	rte->checkForRead = false;	/* no permission check on subquery itself */
	rte->checkForWrite = false;
597
	rte->checkAsUser = InvalidOid;
598

599
	/*
600
	 * FOR UPDATE of view?
601
	 */
602
	if (intMember(rt_index, parsetree->rowMarks))
603
	{
604
		/*
605 606 607
		 * Remove the view from the list of rels that will actually be
		 * marked FOR UPDATE by the executor.  It will still be access-
		 * checked for write access, though.
608
		 */
609
		parsetree->rowMarks = lremovei(rt_index, parsetree->rowMarks);
Bruce Momjian's avatar
Bruce Momjian committed
610 611

		/*
612
		 * Set up the view's referenced tables as if FOR UPDATE.
613
		 */
614
		markQueryForUpdate(rule_action, true);
615 616
	}

617
	return parsetree;
618 619
}

620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
/*
 * Recursively mark all relations used by a view as FOR UPDATE.
 *
 * This may generate an invalid query, eg if some sub-query uses an
 * aggregate.  We leave it to the planner to detect that.
 *
 * NB: this must agree with the parser's transformForUpdate() routine.
 */
static void
markQueryForUpdate(Query *qry, bool skipOldNew)
{
	Index		rti = 0;
	List	   *l;

	foreach(l, qry->rtable)
	{
		RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);

		rti++;

		/* Ignore OLD and NEW entries if we are at top level of view */
		if (skipOldNew &&
			(rti == PRS2_OLD_VARNO || rti == PRS2_NEW_VARNO))
			continue;

645
		if (rte->rtekind == RTE_RELATION)
646 647 648 649 650
		{
			if (!intMember(rti, qry->rowMarks))
				qry->rowMarks = lappendi(qry->rowMarks, rti);
			rte->checkForWrite = true;
		}
651 652 653 654 655
		else if (rte->rtekind == RTE_SUBQUERY)
		{
			/* FOR UPDATE of subquery is propagated to subquery's rels */
			markQueryForUpdate(rte->subquery, false);
		}
656 657 658
	}
}

659

660
/*
661 662 663
 * fireRIRonSubLink -
 *	Apply fireRIRrules() to each SubLink (subselect in expression) found
 *	in the given tree.
664 665
 *
 * NOTE: although this has the form of a walker, we cheat and modify the
666
 * SubLink nodes in-place.	It is caller's responsibility to ensure that
667
 * no unwanted side-effects occur!
668 669 670 671
 *
 * This is unlike most of the other routines that recurse into subselects,
 * because we must take control at the SubLink node in order to replace
 * the SubLink's subselect link with the possibly-rewritten subquery.
672 673
 */
static bool
674
fireRIRonSubLink(Node *node, void *context)
675 676
{
	if (node == NULL)
677 678
		return false;
	if (IsA(node, SubLink))
Bruce Momjian's avatar
Bruce Momjian committed
679
	{
680 681 682
		SubLink    *sub = (SubLink *) node;

		/* Do what we came for */
683 684
		sub->subselect = (Node *) fireRIRrules((Query *) (sub->subselect));
		/* Fall through to process lefthand args of SubLink */
685
	}
686

687 688
	/*
	 * Do NOT recurse into Query nodes, because fireRIRrules already
689
	 * processed subselects of subselects for us.
690
	 */
691
	return expression_tree_walker(node, fireRIRonSubLink,
692
								  (void *) context);
693 694 695 696 697 698 699 700 701 702
}


/*
 * fireRIRrules -
 *	Apply all RIR rules on each rangetable entry in a query
 */
static Query *
fireRIRrules(Query *parsetree)
{
Bruce Momjian's avatar
Bruce Momjian committed
703
	int			rt_index;
704

705 706 707
	/*
	 * don't try to convert this into a foreach loop, because rtable list
	 * can get changed each time through...
708
	 */
709
	rt_index = 0;
Bruce Momjian's avatar
Bruce Momjian committed
710 711
	while (rt_index < length(parsetree->rtable))
	{
712 713 714 715 716 717 718 719 720 721
		RangeTblEntry *rte;
		Relation	rel;
		List	   *locks;
		RuleLock   *rules;
		RewriteRule *rule;
		LOCKMODE	lockmode;
		bool		relIsUsed;
		int			i;
		List	   *l;

722 723
		++rt_index;

724
		rte = rt_fetch(rt_index, parsetree->rtable);
725

726 727 728 729 730
		/*
		 * A subquery RTE can't have associated rules, so there's nothing
		 * to do to this level of the query, but we must recurse into the
		 * subquery to expand any rule references in it.
		 */
731
		if (rte->rtekind == RTE_SUBQUERY)
732 733 734 735 736
		{
			rte->subquery = fireRIRrules(rte->subquery);
			continue;
		}

737 738 739 740 741 742
		/*
		 * Joins and other non-relation RTEs can be ignored completely.
		 */
		if (rte->rtekind != RTE_RELATION)
			continue;

743
		/*
744 745 746
		 * If the table is not referenced in the query, then we ignore it.
		 * This prevents infinite expansion loop due to new rtable entries
		 * inserted by expansion of a rule. A table is referenced if it is
747 748
		 * part of the join set (a source table), or is referenced by any
		 * Var nodes, or is the result table.
749
		 */
750 751 752
		relIsUsed = rangeTableEntry_used((Node *) parsetree, rt_index, 0);

		if (!relIsUsed && rt_index != parsetree->resultRelation)
753
			continue;
Bruce Momjian's avatar
Bruce Momjian committed
754

755
		/*
756 757 758 759 760 761
		 * This may well be the first access to the relation during the
		 * current statement (it will be, if this Query was extracted from
		 * a rule or somehow got here other than via the parser).
		 * Therefore, grab the appropriate lock type for the relation, and
		 * do not release it until end of transaction.	This protects the
		 * rewriter and planner against schema changes mid-query.
762
		 *
763 764 765 766
		 * If the relation is the query's result relation, then
		 * RewriteQuery() already got the right lock on it, so we need no
		 * additional lock. Otherwise, check to see if the relation is
		 * accessed FOR UPDATE or not.
767 768 769 770 771 772 773 774
		 */
		if (rt_index == parsetree->resultRelation)
			lockmode = NoLock;
		else if (intMember(rt_index, parsetree->rowMarks))
			lockmode = RowShareLock;
		else
			lockmode = AccessShareLock;

775
		rel = heap_open(rte->relid, lockmode);
776 777 778 779

		/*
		 * Collect the RIR rules that we must apply
		 */
780 781
		rules = rel->rd_rules;
		if (rules == NULL)
Bruce Momjian's avatar
Bruce Momjian committed
782
		{
783
			heap_close(rel, NoLock);
784 785
			continue;
		}
786
		locks = NIL;
Bruce Momjian's avatar
Bruce Momjian committed
787 788
		for (i = 0; i < rules->numLocks; i++)
		{
789 790 791
			rule = rules->rules[i];
			if (rule->event != CMD_SELECT)
				continue;
Bruce Momjian's avatar
Bruce Momjian committed
792

793 794 795
			if (rule->attrno > 0)
			{
				/* per-attr rule; do we need it? */
796
				if (!attribute_used((Node *) parsetree, rt_index,
797
									rule->attrno, 0))
798 799
					continue;
			}
800 801 802 803 804 805 806

			locks = lappend(locks, rule);
		}

		/*
		 * Now apply them
		 */
Bruce Momjian's avatar
Bruce Momjian committed
807 808
		foreach(l, locks)
		{
809 810
			rule = lfirst(l);

811
			parsetree = ApplyRetrieveRule(parsetree,
812
										  rule,
813
										  rt_index,
814
										  rule->attrno == -1,
815
										  rel,
816
										  relIsUsed);
817 818
		}

819
		heap_close(rel, NoLock);
820 821
	}

822 823 824 825
	/*
	 * Recurse into sublink subqueries, too.
	 */
	if (parsetree->hasSubLinks)
826
		query_tree_walker(parsetree, fireRIRonSubLink, NULL,
827
						false /* already handled the ones in rtable */ );
828

829
	/*
830 831 832 833 834
	 * If the query was marked having aggregates, check if this is still
	 * true after rewriting.  Ditto for sublinks.  Note there should be no
	 * aggs in the qual at this point.	(Does this code still do anything
	 * useful?	The view-becomes-subselect-in-FROM approach doesn't look
	 * like it could remove aggs or sublinks...)
835 836 837 838 839 840 841 842
	 */
	if (parsetree->hasAggs)
	{
		parsetree->hasAggs = checkExprHasAggs((Node *) parsetree);
		if (parsetree->hasAggs)
			if (checkExprHasAggs((Node *) parsetree->jointree))
				elog(ERROR, "fireRIRrules: failed to remove aggs from qual");
	}
843
	if (parsetree->hasSubLinks)
844
		parsetree->hasSubLinks = checkExprHasSubLink((Node *) parsetree);
845

846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
	return parsetree;
}


/*
 * idea is to fire regular rules first, then qualified instead
 * rules and unqualified instead rules last. Any lemming is counted for.
 */
static List *
orderRules(List *locks)
{
	List	   *regular = NIL;
	List	   *instead_rules = NIL;
	List	   *instead_qualified = NIL;
	List	   *i;

	foreach(i, locks)
	{
		RewriteRule *rule_lock = (RewriteRule *) lfirst(i);

		if (rule_lock->isInstead)
		{
			if (rule_lock->qual == NULL)
				instead_rules = lappend(instead_rules, rule_lock);
			else
				instead_qualified = lappend(instead_qualified, rule_lock);
872
		}
873 874
		else
			regular = lappend(regular, rule_lock);
875
	}
876
	return nconc(nconc(regular, instead_qualified), instead_rules);
877 878
}

879

880 881 882 883 884
/*
 * Modify the given query by adding 'AND NOT rule_qual' to its qualification.
 * This is used to generate suitable "else clauses" for conditional INSTEAD
 * rules.
 *
885
 * The rule_qual may contain references to OLD or NEW.	OLD references are
886 887 888 889 890
 * replaced by references to the specified rt_index (the relation that the
 * rule applies to).  NEW references are only possible for INSERT and UPDATE
 * queries on the relation itself, and so they should be replaced by copies
 * of the related entries in the query's own targetlist.
 */
891
static Query *
892 893
CopyAndAddQual(Query *parsetree,
			   Node *rule_qual,
894 895
			   int rt_index,
			   CmdType event)
896
{
897
	Query	   *new_tree = (Query *) copyObject(parsetree);
898 899 900 901 902 903 904 905 906 907 908 909 910
	Node	   *new_qual = (Node *) copyObject(rule_qual);

	/* Fix references to OLD */
	ChangeVarNodes(new_qual, PRS2_OLD_VARNO, rt_index, 0);
	/* Fix references to NEW */
	if (event == CMD_INSERT || event == CMD_UPDATE)
		new_qual = ResolveNew(new_qual,
							  PRS2_NEW_VARNO,
							  0,
							  parsetree->targetList,
							  event,
							  rt_index);
	/* And attach the fixed qual */
911 912 913
	AddNotQual(new_tree, new_qual);

	return new_tree;
914 915 916
}


917

918
/*
919
 *	fireRules -
920 921 922 923 924
 *	   Iterate through rule locks applying rules.
 *	   All rules create their own parsetrees. Instead rules
 *	   with rule qualification save the original parsetree
 *	   and add their negated qualification to it. Real instead
 *	   rules finally throw away the original parsetree.
925
 *
926
 *	   remember: reality is for dead birds -- glass
927 928
 *
 */
929
static List *
930
fireRules(Query *parsetree,
931 932
		  int rt_index,
		  CmdType event,
933 934 935
		  bool *instead_flag,
		  List *locks,
		  List **qual_products)
936
{
937 938
	List	   *results = NIL;
	List	   *i;
939 940 941

	/* choose rule to fire from list of rules */
	if (locks == NIL)
942
		return NIL;
943

944
	locks = orderRules(locks);	/* real instead rules last */
945

946 947
	foreach(i, locks)
	{
948
		RewriteRule *rule_lock = (RewriteRule *) lfirst(i);
949
		Node	   *event_qual;
950 951
		List	   *actions;
		List	   *r;
952 953 954 955 956

		/* multiple rule action time */
		*instead_flag = rule_lock->isInstead;
		event_qual = rule_lock->qual;
		actions = rule_lock->actions;
957

958 959 960
		if (event_qual != NULL && *instead_flag)
		{
			Query	   *qual_product;
961

962 963 964 965 966 967 968 969 970
			/*
			 * If there are instead rules with qualifications, the
			 * original query is still performed. But all the negated rule
			 * qualifications of the instead rules are added so it does
			 * its actions only in cases where the rule quals of all
			 * instead rules are false. Think of it as the default action
			 * in a case. We save this in *qual_products so
			 * deepRewriteQuery() can add it to the query list after we
			 * mangled it up enough.
971
			 */
972
			if (*qual_products == NIL)
973
				qual_product = parsetree;
974
			else
975
				qual_product = (Query *) lfirst(*qual_products);
976

977 978 979 980 981
			qual_product = CopyAndAddQual(qual_product,
										  event_qual,
										  rt_index,
										  event);

982
			*qual_products = makeList1(qual_product);
983 984
		}

985 986
		foreach(r, actions)
		{
987
			Query	   *rule_action = lfirst(r);
988

989 990 991
			if (rule_action->commandType == CMD_NOTHING)
				continue;

992 993
			rule_action = rewriteRuleAction(parsetree, rule_action,
											event_qual, rt_index, event);
994

995
			results = lappend(results, rule_action);
996
		}
997

998 999 1000
		/*
		 * If this was an unqualified instead rule, throw away an
		 * eventually saved 'default' parsetree
1001
		 */
1002
		if (event_qual == NULL && *instead_flag)
1003
			*qual_products = NIL;
1004 1005
	}
	return results;
1006 1007
}

1008 1009


1010
static List *
1011
RewriteQuery(Query *parsetree, bool *instead_flag, List **qual_products)
1012
{
1013
	CmdType		event;
Bruce Momjian's avatar
Bruce Momjian committed
1014
	List	   *product_queries = NIL;
1015
	int			result_relation;
Bruce Momjian's avatar
Bruce Momjian committed
1016
	RangeTblEntry *rt_entry;
1017 1018
	Relation	rt_entry_relation;
	RuleLock   *rt_entry_locks;
1019

1020 1021 1022 1023
	Assert(parsetree != NULL);

	event = parsetree->commandType;

1024
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1025 1026
	 * SELECT rules are handled later when we have all the queries that
	 * should get executed
1027 1028 1029 1030 1031 1032 1033
	 */
	if (event == CMD_SELECT)
		return NIL;

	/*
	 * Utilities aren't rewritten at all - why is this here?
	 */
1034 1035
	if (event == CMD_UTILITY)
		return NIL;
1036

1037
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1038
	 * the statement is an update, insert or delete - fire rules on it.
1039
	 */
1040
	result_relation = parsetree->resultRelation;
1041
	Assert(result_relation != 0);
1042
	rt_entry = rt_fetch(result_relation, parsetree->rtable);
1043
	Assert(rt_entry->rtekind == RTE_RELATION);
1044 1045

	/*
1046 1047 1048 1049 1050 1051
	 * This may well be the first access to the result relation during the
	 * current statement (it will be, if this Query was extracted from a
	 * rule or somehow got here other than via the parser). Therefore,
	 * grab the appropriate lock type for a result relation, and do not
	 * release it until end of transaction.  This protects the rewriter
	 * and planner against schema changes mid-query.
1052
	 */
1053
	rt_entry_relation = heap_open(rt_entry->relid, RowExclusiveLock);
1054

1055 1056 1057 1058 1059 1060 1061 1062
	/*
	 * If it's an INSERT or UPDATE, rewrite the targetlist into standard
	 * form.  This will be needed by the planner anyway, and doing it now
	 * ensures that any references to NEW.field will behave sanely.
	 */
	if (event == CMD_INSERT || event == CMD_UPDATE)
		rewriteTargetList(parsetree, rt_entry_relation);

1063 1064 1065
	/*
	 * Collect and apply the appropriate rules.
	 */
1066
	rt_entry_locks = rt_entry_relation->rd_rules;
1067

1068
	if (rt_entry_locks != NULL)
1069
	{
1070 1071
		List	   *locks = matchLocks(event, rt_entry_locks,
									   result_relation, parsetree);
1072

1073
		product_queries = fireRules(parsetree,
Bruce Momjian's avatar
Bruce Momjian committed
1074 1075 1076 1077 1078
									result_relation,
									event,
									instead_flag,
									locks,
									qual_products);
1079
	}
1080

1081
	heap_close(rt_entry_relation, NoLock);		/* keep lock! */
1082

1083
	return product_queries;
1084 1085
}

1086

1087 1088
/*
 * to avoid infinite recursion, we restrict the number of times a query
1089
 * can be rewritten. Detecting cycles is left for the reader as an exercise.
1090 1091
 */
#ifndef REWRITE_INVOKE_MAX
1092
#define REWRITE_INVOKE_MAX		10
1093 1094
#endif

1095
static int	numQueryRewriteInvoked = 0;
1096 1097 1098

/*
 * deepRewriteQuery -
1099
 *	  rewrites the query and apply the rules again on the queries rewritten
1100
 */
1101
static List *
1102
deepRewriteQuery(Query *parsetree)
1103
{
1104 1105
	List	   *n;
	List	   *rewritten = NIL;
1106
	List	   *result;
1107 1108
	bool		instead;
	List	   *qual_products = NIL;
1109 1110 1111

	if (++numQueryRewriteInvoked > REWRITE_INVOKE_MAX)
	{
1112
		elog(ERROR, "query rewritten %d times, may contain cycles",
1113 1114 1115
			 numQueryRewriteInvoked - 1);
	}

1116
	instead = false;
1117
	result = RewriteQuery(parsetree, &instead, &qual_products);
1118

1119 1120
	foreach(n, result)
	{
1121
		Query	   *pt = lfirst(n);
1122
		List	   *newstuff;
1123 1124 1125 1126 1127

		newstuff = deepRewriteQuery(pt);
		if (newstuff != NIL)
			rewritten = nconc(rewritten, newstuff);
	}
1128

1129
	/*
1130 1131 1132 1133 1134 1135 1136
	 * For INSERTs, the original query is done first; for UPDATE/DELETE,
	 * it is done last.  This is needed because update and delete rule
	 * actions might not do anything if they are invoked after the update
	 * or delete is performed. The command counter increment between the
	 * query execution makes the deleted (and maybe the updated) tuples
	 * disappear so the scans for them in the rule actions cannot find
	 * them.
1137
	 */
1138 1139 1140 1141 1142 1143 1144 1145
	if (parsetree->commandType == CMD_INSERT)
	{
		/*
		 * qual_products are the original query with the negated rule
		 * qualification of an INSTEAD rule
		 */
		if (qual_products != NIL)
			rewritten = nconc(qual_products, rewritten);
1146

1147 1148 1149 1150
		/*
		 * Add the unmodified original query, if no INSTEAD rule was seen.
		 */
		if (!instead)
1151
			rewritten = lcons(parsetree, rewritten);
1152 1153 1154 1155 1156 1157 1158 1159 1160
	}
	else
	{
		/*
		 * qual_products are the original query with the negated rule
		 * qualification of an INSTEAD rule
		 */
		if (qual_products != NIL)
			rewritten = nconc(rewritten, qual_products);
1161

1162 1163 1164 1165
		/*
		 * Add the unmodified original query, if no INSTEAD rule was seen.
		 */
		if (!instead)
1166
			rewritten = lappend(rewritten, parsetree);
1167
	}
1168

1169 1170
	return rewritten;
}
1171 1172 1173


/*
1174
 * QueryRewriteOne -
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
 *	  rewrite one query
 */
static List *
QueryRewriteOne(Query *parsetree)
{
	numQueryRewriteInvoked = 0;

	/*
	 * take a deep breath and apply all the rewrite rules - ay
	 */
	return deepRewriteQuery(parsetree);
}


/*
1190 1191 1192 1193 1194 1195 1196
 * QueryRewrite -
 *	  Primary entry point to the query rewriter.
 *	  Rewrite one query via query rewrite system, possibly returning 0
 *	  or many queries.
 *
 * NOTE: The code in QueryRewrite was formerly in pg_parse_and_plan(), and was
 * moved here so that it would be invoked during EXPLAIN.
1197
 */
1198 1199
List *
QueryRewrite(Query *parsetree)
1200
{
Bruce Momjian's avatar
Bruce Momjian committed
1201 1202 1203
	List	   *querylist;
	List	   *results = NIL;
	List	   *l;
1204 1205 1206 1207 1208 1209 1210 1211 1212

	/*
	 * Step 1
	 *
	 * Apply all non-SELECT rules possibly getting 0 or many queries
	 */
	querylist = QueryRewriteOne(parsetree);

	/*
1213
	 * Step 2
1214 1215 1216
	 *
	 * Apply all the RIR rules on each query
	 */
Bruce Momjian's avatar
Bruce Momjian committed
1217 1218
	foreach(l, querylist)
	{
1219
		Query	   *query = (Query *) lfirst(l);
Bruce Momjian's avatar
Bruce Momjian committed
1220

1221
		query = fireRIRrules(query);
1222

Bruce Momjian's avatar
Bruce Momjian committed
1223
		/*
1224
		 * If the query target was rewritten as a view, complain.
Bruce Momjian's avatar
Bruce Momjian committed
1225
		 */
1226
		if (query->resultRelation)
Bruce Momjian's avatar
Bruce Momjian committed
1227
		{
1228 1229
			RangeTblEntry *rte = rt_fetch(query->resultRelation,
										  query->rtable);
Bruce Momjian's avatar
Bruce Momjian committed
1230

1231
			if (rte->rtekind == RTE_SUBQUERY)
Bruce Momjian's avatar
Bruce Momjian committed
1232
			{
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
				switch (query->commandType)
				{
					case CMD_INSERT:
						elog(ERROR, "Cannot insert into a view without an appropriate rule");
						break;
					case CMD_UPDATE:
						elog(ERROR, "Cannot update a view without an appropriate rule");
						break;
					case CMD_DELETE:
						elog(ERROR, "Cannot delete from a view without an appropriate rule");
						break;
					default:
						elog(ERROR, "QueryRewrite: unexpected commandType %d",
							 (int) query->commandType);
						break;
				}
Bruce Momjian's avatar
Bruce Momjian committed
1249 1250 1251
			}
		}

1252
		results = lappend(results, query);
Bruce Momjian's avatar
Bruce Momjian committed
1253
	}
1254

1255
	return results;
Bruce Momjian's avatar
Hi!  
Bruce Momjian committed
1256
}